Vilniaus Universitetas Matematikos ir informatikos fakultetas Program sistem katedra

Tiesioginio ivedimo ir grafo metodai ivedimui produkcij sistemose

Pagal Neapolitano straipsn Forward-Chaining versus a graph approach as the inference engine in expert systems

Jurijus Belousas, Program sistemos, III k., 1 gr.

Vilnius 2009

Anotacija
iame darbe nagrinjamas Richard E. Neapolitano pasilyt tiesioginio ivedimo ir grafo metod paiekai ekspertiniuose sistemose panaudojimas labirinto udaviniui sprsti. Dokumento pradioje paaikinama dokumente naudojama terminologija. Po to seka abiej algoritm vadinis apraymas bei prie dokumento pridt Pascal programavimo kalba parayt j realizacij apvalga. Paskutinis skyrius yra algoritm pritaikymo labirinto udaviniui sprsti tyrimo apraymas bei rezultatai. Prieduose pateiktas realizacij kodas. Raant darb buvo vadovaujamasi Neapolitano straipsniu Forward-Chaining versus a graph approach as the inference engine in expert systems (Principles of Expert Systems, 1986) bei analogiku Miguelio ngel Camarena Nieto-Mrquez paraytu darbu Forward Chaining & Graph Method.

Turinys
TIESIOGINIO IVEDIMO IR GRAFO METODAI IVEDIMUI PRODUKCIJ SISTEMOSE...1 PAGAL NEAPOLITANO
STRAIPSN

FORWARD-CHAINING

VERSUS A GRAPH APPROACH AS THE INFERENCE

ENGINE IN EXPERT SYSTEMS...................................................................................................... 1

ANOTACIJA........................................................................................................ 2 1 VADAS........................................................................................................... 4 1.1 1.2 1.3 1.4 DOKUMENTO TEMA............................................................................................................. 4 DARBO PAGRINDAS............................................................................................................. 4 NAUDOTI DOKUMENTAI........................................................................................................ 4 TERMINOLOGIJA.................................................................................................................. 4

2 ALGORITM APRAAS IR REALIZACIJA..............................................................5 2.1 TIESIOGINIO IVEDIMO METODAS............................................................................................ 5 2.2 GRAFO METODAS................................................................................................................ 6 2.3 REALIZACIJOS..................................................................................................................... 7 3 TYRIMAS SU LABIRINTO UDAVINIU..................................................................9 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 UDAVINYS....................................................................................................................... 9 TYRIMO TIKSLAS................................................................................................................. 9 BANDYMAS 1: PRIEINGA NUO IJIM KRYPTIMI GYL TVARKA ...................................................9 BANDYMAS 2: IJIM LINK GYL TVARKA ............................................................................13 BANDYMAS 3: PAIEKOS PLOT TVARKA................................................................................16 BANDYMAS 4: PAGAL RATO TAISYKL..................................................................................18 BANDYMAS 5: PAGAL APVERST RATO TAISYKL....................................................................20 BANDYMAS 6: ATSITIKTIN TVARKA.......................................................................................22

3.9 IVADOS......................................................................................................................... 24 4 PRIEDAI........................................................................................................ 26 4.1 FORWARD_CHAINING.PAS PROGRAMOS KODAS........................................................................26 4.2 GRAPH_METHOD.PAS PROGRAMOS KODAS.............................................................................31

1 vadas
1.1 Dokumento tema
Dokumentas nagrinja tiesioginio ivedimo ir grafo metodus ir j taikym labirinto udaviniui sprsti.

1.2 Darbo pagrindas

Dokumentas buvo raomas kaip Dirbtino Intelekto kurso laboratorinis darbas.

1.3 Naudoti dokumentai

Forward-Chaining versus a graph approach as the inference engine in expert systems, Principles of Expert Systems, Richard E. Neopolitan, 1986. Forward Chaining & Graph Method, Miguel ngel Camarena NietoMrquez.

1.4 Terminologija
Teiginys (angl. assertion) teisingas faktas. Taisykl (angl. rule) operacija, kuriuos metu i vien teigini gaunamas kitas. Taisykl susideda i antecedento ir konsekvento ir turi pavidal: antecedentas -> konsekventas. Antecedentas (nebtinai teising) fakt sraas. Faktai antecedente dar vadinami taisykls prielaidomis. Sakoma, kad taisykls prielaidos yra patenkintos, kai visi jos antecedento faktai yra teisingi. Konsekventas faktas, kuris tampa teisingas, kai taisykls prielaidos yra patenkinamos. Tikslas faktas, kuriam tapus teiginiu (teisingu faktu), algoritmas sustabdomas.

2 Algoritm apraas ir realizacija

2.1 Tiesioginio ivedimo metodas
Ekspertinse sistemose paiekos udavinys formuluojamas sekaniai: turimas pradinis teigini sraas, taisykli sraas ir tikslas. Reikia nustatyti, ar taikant taisykles galima pasiekti nurodyt tiksl (t.y. i pradinio teigini srao ivesti iekom teigin). Kitame variante, kur pateik Neapolitanas, taisykls taikomos iki kol nebepavyksta ivesti nauj teigini. iame dokumente naudojamas pirmas udavinio variantas paieka iki nurodyto tikslo. Vienas i algoritm tam udaviniui sprsti yra tiesioginio ivedimo metodas. J taikant bgama per taisykli sra ir kiekvienai patikrinama, ar jos prielaidos yra patenkintos. Jei taip, taisykls konsekventas pridedamas prie teigini srao ir pradedama i naujo. Pastarasis veiksmas yra btinas dl to, kad teiginiu taps naujas faktas gali bti taisykls, kuri jau buvo patikrinta, prielaida. Pseudokodas:

0: 1: 2: 3: 4: 5: 6: 7:

teiginiai:= pradiniai teiginiai; R:= FIRST(taisykls); while R nil do { kol dar yra taisykli } if visos R prielaidos yra teigini srae and R konsekvento nra teigini srae then begin APPEND(teiginiai, R konsekventas); if R konsekventas yra iekomas tikslas then sustojama; R:= FIRST(taisykls); end else R:= NEXT(taisykls);

8:

Dl poreikio kiekvien kart pereiti taisykli sra i naujo is algoritmas yra prastesnis efektyvumo atvilgiu nei grafo metodas, k detaliai aptaria Neapolitanas savo straipsnyje. Taiau , skirtingai nuo jo, is algoritmas tinka atvejui, kai teiginiai yra predikatai (pvz.: F(x) teisinga, kai x yra teigiamas skaiius).

2.2 Grafo metodas

Kitas algoritmas tam paiam udaviniui sprsti yra grafo metodas, kuris silo sukonstruoti i fakt ir taisykli orientuot graf, kuriame i taisykls prielaid eina lankai t taisykl bei i kito galo i taisykls eina lankas jos konsekvent. Kiekviena taisykl taip pat saugo bendr skaii jos prielaid (Neapolitano straipsnyje vadinam TRIGVAL) bei kiek iki iol jos prielaid buvo patenkinta (atitinkamai COUNT). Pavyzdys i straipsnio:

Pav. 1 Pavyzdinis grafas (Neapolitano straipsnyje)

iuo atveju yra bgama per teigini sra, o ne per taisykles, ir tik vien kart. Perjus prie eilinio teiginio, prie kiekvienos taisykls, su kuria tas teiginys yra sujungtas lanku, patenkint prielaid skaiiaus (COUNT) pridedamas vienetas ir patikrinama, ar jis nra lygus tos taisykls bendram prielaid skaiiui (TRIGVAL). Jei skaiiai lygs, konsekventas, su kuriuo taisykl yra sujungta lanku, yra pridedamas prie teigini srao galo (btina pridti prie galo, kad jis ankiau ar vliau btinai bt pasiektas). Pseudokodas:

0: 1: 2: 3: 4: 5:

teiginiai:= pradiniai teiginiai; A:= FIRST(teiginiai); while A nil do { kol dar yra teigini } begin L:= FIRST(A lankai); while L nil do { kol dar yra lank } begin Prie taisykls, esanios L gale, lauko patenkinta prielaid pridedama 1; if tos taisykls patenkinta prielaid = tos taisykls skaiius prielaid and tos taisykls konsekvento nra teigini
6

6: 7: srae

8: 9: tikslas

then begin APPEND(teiginiai, tas konsekventas); if tas konsekventas yra iekomas then sustojama; end;

10: 11:

L:= NEXT(A lankai); end; A:= NEXT(teiginiai); end;

Efektyvumo atvilgiu, is algoritmas yra ymiai pranaesnis u tiesioginio ivedimo metod, taiau jo praktinis panaudojimas yra sudtingesnis dl poreikio konstruoti graf, kas bendruoju atveju yra komplikuotas udavinys. Taip pat iuo atveju sudtinga irayti taisykles, nebent jos paios saugo po sra nuorod savo prielaidas.

2.3 Realizacijos
Tiesioginio ivedimo metodas realizuotas programa Forward_Chaining.pas. Programa ima duomenis i tekstinio ASCII failo Duomenys.txt, kurio struktra yra sekanti: tikslas pradiniai teiginiai [tuia eilut] taisykl1 taisykl2 ... taisyklN Bet kur galima terpti komentar komentaras prasideda nuo / ir tsiasi iki eiluts pabaigos. Aukiau parodytas pavyzdys i Neapolitano straipsnio atrodyt: C DEFG DEF -> A AB -> C G -> B / tikslas / pradiniai teiginiai / taisykle 1 / taisykle 2 / taisykle 3

Pradedama darb, program iveda pradin teigini sra, baigdama patenkint taisykli sra tokia tvarka, kuria jie buvo patenkinti (ia naudojamas kodavimas R#, kur # yra taisykls numeris duomen faile, pradedant nuo 1), galutin teigini sra ir ar tikslas buvo pasiektas. Minto pavyzdio ivestis bt: 7

Pradinis teigini sraas: D E F G Pritaikytos taisykls: R1 R3 R2 Galutinis teigini sraas: D E F G A B C Tikslas pasiektas. ioje realizacijoje srao pirmas elementas nra jo aknis, bet elementas, kur rodo aknis. is kodavimas padaro kod kompaktik. Grafo metodas realizuotas programoje Graph_Method.pas. Jos vestis ir ivestis yra identiko pavidalo, kaip ir Forward_Chaining.pas (vedimui naudojamas tas pats failas Duomenys.txt). Abiej program kodas pateiktas dokumento prieduose.

3 Tyrimas su labirinto udaviniu

3.1 Udavinys
Paimkime labirint:

Pav. 2 Labirinto udavinys

Pradin bsena: laukelis S Terminalin bsena: pasiektas laukelis, lieiantis labirinto krat (iuo atveju j yra du)

3.2 Tyrimo tikslas

Tyrimas atliekamas siekiant nustatyti, ar paiekos rezultatas taikant tiesioginio ivedimo ir grafo metodus priklauso nuo to, kokia tvarka pateikiamos taisykls sprendiant labirinto udavin, ir jei priklauso, tai kokie yra tos priklausomybs dsningumai.

3.3 Bandymas 1: prieinga nuo ijim kryptimi gyl tvarka

Laukeliai numeruojami paiekos gyl tvarka naudojant produkcijas:

Gaunamas vaizdas ir programos vestis:

@ S S -> A A -> S A -> B B -> A B -> C C -> B C -> D D -> C D -> E E -> D E -> F F -> E F -> G G -> F E -> H H -> E H -> I I -> H I -> J J -> I J -> K K -> J K -> L L -> K L -> C C -> L K -> M M -> K M -> N N -> M N -> O O -> N O -> P P -> O P -> S S -> P S -> Q Q -> S Q -> R R -> Q S -> U

/ tikslas, kur rodo T ir Z / pradinis laukelis S / R1 / R2 / R3 / R4 / R5 / R6 / R7 / R8 / R9 / R10 / R11 / R12 / R13 / R14 / R15 / R16 / R17 / R18 / R19 / R20 / R21 / R22 / R23 / R24 / R25 / R26 / R27 / R28 / R29 / R30 / R31 / R32 / R33 / R34 / R35 / R36 / R37 / R38 / R39 / R40 / R41

10

U -> S U -> V V -> U V -> W W -> V V -> X X -> V X -> Y Y -> X Y -> T T -> Y T -> @ V -> Z Z -> V Z -> @

/ R42 / R43 / R44 / R45 / R46 / R47 / R48 / R49 / R50 / R51 / R52 / R53 / R54 / R55 / R56

Pastaba: @ vestas todl, kad iame labirinte yra daugiau nei vienas ijimas. Taikant grafo metod gaunamas grafas:

11

Pav. 3 Grafo metodo grafas

Pastabos: visuose kituose bandymuose grafai bus izomorfiki iam juose bus tiktai skirtingai sunumeruotos taisykls ir pavadintos virns. Taip pat iame brieinyje nra surayti taisykli prielaid ir patenkint prielaid skaiiai, nes visuose taisyklse tie skaiiai yra atitinkamai 1 ir 0. Paleidus programas buvo gauti tokie rezultatai: Forward_Chaining.pas ivestis: Pradinis teigini sraas: S Pritaikytos taisykls: R1 R3 R5 R7 R9 R11 R13 R15 R17 R19 R21 R23 R27 R29 R31 R33 R37 R39 R41 R43 R45 R47 R49 R51 R53 Galutinis teigini sraas: S A B C D E F G H I J K L M N O P Q R U V W X Y T @ Tikslas pasiektas.

Kaip matome, pateikus taisykles paiekos gyl tvarka tiesioginio ivedimo metodas atlieka paiek identik paiekai gyl. Todl galutinis teigini sraas yra visos alfabeto raids iki pirmo laukelio, kuris yra tikslas, einanios alfabeto tvarka.

Graph_Method.pas ivestis: Pradinis teigini sraas: S Pritaikytos taisykls: R1 R36 R37 R41 R3 R34 R39 R43 R5 R32 R45 R47 R54 R7 R26 R30 R49 R56 Galutinis teigini sraas: S A P Q U B O R V C N W X Z D L M Y @ Tikslas pasiektas.

Prieingai nei tiesioginio ivedimo atveju, grafo metodas iame bandyme elgiasi analogikai paiekai plot.

3.4 Bandymas 2: ijim link gyl tvarka

iame bandyme taip pat taikoma paiekos gyl tvarka, bet su produkcijomis, kurios nukreipia ijim link:

13

Gaunamas vaizdas ir programos vestis:

@ S S -> A A -> S A -> B B -> A B -> T T -> B T -> @ B -> C C -> B C -> D D -> C D -> E E -> C E -> @ B -> F F -> B S -> G G -> S G -> H H -> G H -> I I -> H I -> J J -> I J -> K K -> J K -> L L -> K L -> M M -> L M -> N N -> M N -> O O -> N O -> S S -> O M -> P P -> M P -> Q Q -> P Q -> R

/ tikslas, kur rodo T ir E / pradinis laukelis S / R1 / R2 / R3 / R4 / R5 / R6 / R7 / R8 / R9 / R10 / R11 / R12 / R13 / R14 / R15 / R16 / R17 / R18 / R19 / R20 / R21 / R22 / R23 / R24 / R25 / R26 / R27 / R28 / R29 / R30 / R31 / R32 / R33 / R34 / R35 / R36 / R37 / R38 / R39 / R40 / R41

14

R -> Q R -> U U -> R U -> V V -> U V -> K K -> V Q -> W W -> Q W -> X X -> W S -> Y Y -> S Y -> Z Z -> Y

/ R42 / R43 / R44 / R45 / R46 / R47 / R48 / R49 / R50 / R51 / R52 / R53 / R54 / R55 / R56

Paleidus programas buvo gauti tokie rezultatai: Forward_Chaining.pas ivestis: Pradinis teigini sraas: S Pritaikytos taisykls: R1 R3 R5 R7 Galutinis teigini sraas: S A B T @ Tikslas pasiektas.

Pateikus taisykles tikslo kryptim naudojant tiesioginio ivedimo metod, kaip ir paiekos gyl atveju, tikslas pasiekiamas greitai.

Graph_Method.pas ivestis: Pradinis teigini sraas: S Pritaikytos taisykls: R1 R17 R36 R53 R3 R19 R34 R55 R5 R8 R15 R21 R32 R7 Galutinis teigini sraas: S A G O Y B H N Z T C F I M @ Tikslas pasiektas.

Tuo tarpu grafo metodo rezultatas, vl gi, yra paiekos plot analogas ir todl kitokia tvarka pateiktos taisykls neturjo takos (keturi taisykli skirtumas slygojamas tik skirtingomis tos paios bangos produkcij preferencijomis pats bang skaiius nesiskiria). 15

3.5 Bandymas 3: paiekos plot tvarka

kart taisykls pateikiamos paiekos plot tvarka naudojant produkcijas:

Gaunamas vaizdas ir programos vestis:

@ S S -> A A -> S S -> B B -> S S -> C C -> S S -> D D -> S A -> E E -> A B -> F F -> B C -> G G -> C D -> H H -> D E -> I I -> E F -> J J -> F H -> K K -> H H -> L L -> H H -> T T -> H T -> @ I -> M M -> I J -> N N -> J J -> O O -> J K -> P P -> K M -> Q Q -> M

/ tikslas, kur rodo T ir U / pradinis laukelis S / R1 / R2 / R3 / R4 / R5 / R6 / R7 / R8 / R9 / R10 / R11 / R12 / R13 / R14 / R15 / R16 / R17 / R18 / R19 / R20 / R21 / R22 / R23 / R24 / R25 / R26 / R27 / R28 / R29 / R30 / R31 / R32 / R33 / R34 / R35 / R36 / R37

16

N -> Q Q -> N O -> R R -> O P -> U U -> P U -> @ Q -> V V -> Q R -> W W -> R R -> X X -> R V -> Y Y -> V W -> Y Y -> W X -> Z Z -> X

/ R38 / R39 / R40 / R41 / R42 / R43 / R44 / R45 / R46 / R47 / R48 / R49 / R50 / R51 / R52 / R53 / R54 / R55 / R56

Paleidus programas buvo gauti tokie rezultatai: Forward_Chaining.pas ivestis: Pradinis teigini sraas: S Pritaikytos taisykls: R1 R3 R5 R7 R9 R11 R13 R15 R17 R19 R21 R23 R25 R27 Galutinis teigini sraas: S A B C D E F G H I J K L T @ Tikslas pasiektas.

Graph_Method.pas ivestis: Pradinis teigini sraas: S Pritaikytos taisykls: R1 R3 R5 R7 R9 R11 R13 R15 R17 R19 R21 R23 R25 R28 R30 R32 R34 R27 Galutinis teigini sraas: S A B C D E F G H I J K L T M N O P @ Tikslas pasiektas.

I pirmo vilgsnio rezultatai skiriasi. Taiau inagrinjus paveiksll tampa aiku, kad keturi papildomi ingsniai slygojami tik to, kad tiesioginio ivedimo metodas neubaigia paskutins bangos. Abu metodai iekojo pagal t pai paiek plot. 17

3.6 Bandymas 4: pagal rato taisykl

iame bandyme taisykls suraomos pagal rato taisykl: i kairs dein, i viraus apai. Vertikalioms laukeli sandroms panaudota taisykl, kad jos raomos i karto, o ne sulaukus einamos eiluts pabaigos. Gaunamas vaizdas ir programos vestis:

@ S T -> D D -> T T -> @ A -> B B -> A A -> @ B -> C C -> B C -> D D -> C D -> E E -> D D -> F F -> D F -> S S -> F G -> H H -> G H -> S S -> H S -> I I -> S I -> J J -> I G -> K K -> G S -> L L -> S K -> M M -> K L -> N N -> L M -> O O -> M N -> Q Q -> N O -> P P -> O

/ tikslas, kur rodo T ir A / pradinis laukelis S / R1 / R2 / R3 / R4 / R5 / R6 / R7 / R8 / R9 / R10 / R11 / R12 / R13 / R14 / R15 / R16 / R17 / R18 / R19 / R20 / R21 / R22 / R23 / R24 / R25 / R26 / R27 / R28 / R29 / R30 / R31 / R32 / R33 / R34 / R35 / R36 / R37 / R38 18

P -> Q Q -> P O -> R R -> O Q -> U U -> Q R -> V V -> R U -> X X -> U V -> W W -> V W -> X X -> W X -> Y Y -> X Y -> Z Z -> Y

/ R39 / R40 / R41 / R42 / R43 / R44 / R45 / R46 / R47 / R48 / R49 / R50 / R51 / R52 / R53 / R54 / R55 / R56

Paleidus programas buvo gauti tokie rezultatai: Forward_Chaining.pas ivestis: Pradinis teigini sraas: S Pritaikytos taisykls: R16 R14 R2 R3 Galutinis teigini sraas: S F D T @ Tikslas pasiektas.

iuo atveju rezultatas toks pat kaip ir pateikiant ijimo link gyl tvarka, taiau pasireik tiesioginio ivedimo savyb kartoti paiek pridjus nauj teigin. Abu faktai slygojami to, kad kiekviename ingsnyje perjimai btent tarp i laukeli pateikti anksiau nei bet kokios alternatyvos.

Graph_Method.pas ivestis: Pradinis teigini sraas: S Pritaikytos taisykls: R16 R20 R21 R27 R14 R18 R23 R31 R2 R10 R11 R25 R35 R3 Galutinis teigini sraas: S F H I L D G J N T C E K Q @ Tikslas pasiektas.

19

Tuo tarpu grafo metodas vl imitavo paiek plot, kart su aikiai apibrtomis produkcijomis:

Tai ir yra rato taisykl.

3.7 Bandymas 5: pagal apverst rato taisykl

kart vl taikoma rato taisykl, taiau eiluts eina i apaios vir. Gaunamas vaizdas ir programos vestis:

@ S A -> B B -> A A -> F F -> A B -> C C -> B C -> D D -> C C -> G G -> C D -> E E -> D F -> H H -> F G -> J J -> G H -> I I -> H H -> K K -> H I -> J J -> I J -> L L -> J K -> M M -> K L -> N N -> L M -> O

/ tikslas, kur rodo T ir Z / pradinis laukelis S / R1 / R2 / R3 / R4 / R5 / R6 / R7 / R8 / R9 / R10 / R11 / R12 / R13 / R14 / R15 / R16 / R17 / R18 / R19 / R20 / R21 / R22 / R23 / R24 / R25 / R26 / R27 / R28 / R29 20

O -> M N -> S S -> N O -> P P -> O P -> S S -> P S -> Q Q -> S S -> U U -> S Q -> R R -> Q U -> X X -> U T -> V V -> T T -> @ V -> W W -> V W -> X X -> W X -> Y Y -> X X -> Z Z -> X Z -> @

/ R30 / R31 / R32 / R33 / R34 / R35 / R36 / R37 / R38 / R39 / R40 / R41 / R42 / R43 / R44 / R45 / R46 / R47 / R48 / R49 / R50 / R51 / R52 / R53 / R54 / R55 / R56

Paleidus programas buvo gauti tokie rezultatai: Forward_Chaining.pas ivestis: Pradinis teigini sraas: S Pritaikytos taisykls: R32 R28 R24 R16 R10 R6 R2 R3 R7 R11 R13 R17 R19 R25 R29 R33 R37 R39 R41 R43 R51 R49 R46 R47 Galutinis teigini sraas: S N L J G C B A F D E H I K M O P Q U R X W V T @ Tikslas pasiektas.

iuo atveju tiesioginis ivedimo metodas rodo savotik elgsen i pradi jis nukeliauja iki A ir po to atkartoja vedimo tvark.

Graph_Method.pas ivestis: 21

Pradinis teigini sraas: S Pritaikytos taisykls: R32 R36 R37 R39 R28 R34 R41 R43 R24 R30 R51 R52 R54 R16 R22 R26 R49 R56 Galutinis teigini sraas: S N P Q U L O R X J M W Y Z G I K V @ Tikslas pasiektas.

Ir kart grafo metodas ieko pagal paiekos plot princip.

3.8 Bandymas 6: atsitiktin tvarka

iam bandymui buvo paimta prieinga nuo sjim kryptimi gyl tvarka ir sumaiyta atsitiktiniu bdu. Klaidingoms ivadoms dl konkretaus gauto atvejo panaikinti dar vienas bandymas buvo sudarytas suriavus jau gaut seka prieinga tvarka. Gautos programos vestys nurodytos viena alia kitos:

@ S I -> J R -> Q N -> M U -> T U -> Z Z -> U L -> C K -> M S -> A B -> C E -> D T -> U W -> X O -> N I -> H Z -> @ E -> F K -> J K -> L B -> A H -> E Q -> S D -> C X -> W

/ tikslas / pradinis laukelis S / R1 / R2 / R3 / R4 / R5 / R6 / R7 / R8 / R9 / R10 / R11 / R12 / R13 / R14 / R15 / R16 / R17 / R18 / R19 / R20 / R21 / R22 / R23 / R24

@ S Q -> R S -> P C -> D E -> H S -> Q S -> T H -> I T -> S C -> B P -> O Y -> X W -> U Y -> @ A -> B V -> U L -> K U -> V J -> K O -> P A -> S F -> G D -> E G -> F P -> S

/ tikslas / pradinis laukelis S / R1 / R2 / R3 / R4 / R5 / R6 / R7 / R8 / R9 / R10 / R11 / R12 / R13 / R14 / R15 / R16 / R17 / R18 / R19 / R20 / R21 / R22 / R23 / R24

22

X -> Y U -> W F -> E M -> K C -> L N -> O J -> I M -> N P -> S G -> F D -> E F -> G A -> S O -> P J -> K U -> V L -> K V -> U A -> B Y -> @ W -> U Y -> X P -> O C -> B T -> S H -> I S -> T S -> Q E -> H C -> D S -> P Q -> R

/ R25 / R26 / R27 / R28 / R29 / R30 / R31 / R32 / R33 / R34 / R35 / R36 / R37 / R38 / R39 / R40 / R41 / R42 / R43 / R44 / R45 / R46 / R47 / R48 / R49 / R50 / R51 / R52 / R53 / R54 / R55 / R56

M -> N J -> I N -> O C -> L M -> K F -> E U -> W X -> Y X -> W D -> C Q -> S H -> E B -> A K -> L K -> J E -> F Z -> @ I -> H O -> N W -> X T -> U E -> D B -> C S -> A K -> M L -> C Z -> U U -> Z U -> T N -> M R -> Q I -> J

/ R25 / R26 / R27 / R28 / R29 / R30 / R31 / R32 / R33 / R34 / R35 / R36 / R37 / R38 / R39 / R40 / R41 / R42 / R43 / R44 / R45 / R46 / R47 / R48 / R49 / R50 / R51 / R52 / R53 / R54 / R55 / R56

Paleidus Forward_Chaining.pas su abiem vestimis buvo gauti tokie rezultatai:

Pradinis teigini sraas: S Pritaikytos taisykls: R9 R43 R10 R29 R41 R8 R18 R31 R15 R21 R11 R17 R32 R30 R36 R38 R51 R12 R5 R16 Galutinis teigini sraas: S A B C L K M J I H E D F N O G P T U Z @ Tikslas pasiektas.

23

Pradinis teigini sraas: S Pritaikytos taisykls: R2 R5 R1 R6 R10 R43 R45 R17 R31 R44 R32 R13 Galutinis teigini sraas: S P Q R T O N U V W X Y @ Tikslas pasiektas.

Paleidus Graph_Method.pas su abiem vestimis buvo gauti tokie rezultatai:

Pradinis teigini sraas: S Pritaikytos taisykls: R9 R51 R52 R55 R43 R12 R56 R47 R10 R5 R26 R40 R14 R29 R54 R16 Galutinis teigini sraas: S A T Q P B U R O C Z W V N L D @ Tikslas pasiektas.

Pradinis teigini sraas: S Pritaikytos taisykls: R2 R5 R6 R48 R10 R1 R45 R14 R43 R17 R31 R52 R47 R54 R44 R41 Galutinis teigini sraas: S P Q T A O R U B N V W Z C M X @ Tikslas pasiektas.

is pavyzdys galutinai parodo, kad sprendiant udavin tiesioginio ivedimo metodas priklauso nuo taisykli pateikimo tvarkos matomas enklus skirtumas, kai ta pati seka pateikiama atvirkia tvarka. Tuo tarpu grafo metodas vl suveik analogikai paiekai plot, todl beveik jokio skirtumo nra. Pairjus atidiai, galima netgi pastebti, kad bangos A T Q P, B U R O ir C Z W V N uima tas paias pozicijas sekoje, tik bang viduje teiginiai tarpusavyje suriuoti skirtingai.

3.9 Ivados
1. Tiesioginio ivedimo metodas priklauso nuo taisykli pateikimo tvarkos.

24

2. Jei tiesioginio ivedimo metodui taisykls pateikiamos remiantis kakokia taisykle ar algoritmu, tai jis sprendiant udavin imituoja ta taisykl ar algoritm. 3. Grafo metodas nepriklauso nuo taisykli pateikimo tvarkos ir visuomet vykdo paiek plot. 4. Jei konkreiu atveju turima kakoki iankstini ini, kurios leist sutvarkyti taisykles taip, kad tiesioginio ivedimo metodas duot atsakym greiiau, tuomet jo taikymas yra adekvatus. Prieingu atveju geriau taikyti grafo metod, nes jis nepriklauso nuo taisykli pateikimo tvarkos. Visos ios ivados galioja tik labirinto tipo udaviniams, t.y. kai vis taisykli antecedentai turi tik po vien fakt. Galima ikelti hipotez, kad tas pats dsningumas galioja ir platesnei udavini aibei, taiau j patikrinti prireikt kito tyrimo.

25

4 Priedai
4.1 Forward_Chaining.pas programos kodas
program Forward_Chaining; type nuoroda = ^elementas; elementas = record teiginys: char; sekantis: nuoroda; end; Tnuoroda = ^Telementas; { nuoroda taisykl } Telementas = record numeris: integer; prielaidos: nuoroda; konsekventas: char; sekantis: Tnuoroda; end; var tikslas: char; teiginiai: nuoroda; taisykles: Tnuoroda; tikslas_pasiektas: boolean; R: Tnuoroda; tmp: nuoroda; visi: boolean; { ---------------- Sra funkcjonalumas ---------------- } { teigini sraai } procedure Prideti(teiginys: char; var sarasas: nuoroda); { prideda teigin prie srao galo } begin if(sarasas^.sekantis = nil) then begin New(sarasas^.sekantis); sarasas^.sekantis^.teiginys:= teiginys; sarasas^.sekantis^.sekantis:= nil; end else Prideti(teiginys, sarasas^.sekantis); end; function Sarase(teiginys: char; sarasas: nuoroda): boolean; { grina true jei teiginys yra srae } begin Sarase:= false;

26

if sarasas^.sekantis <> nil then Sarase:= Sarase(teiginys, sarasas^.sekantis); Sarase:= Sarase or (sarasas^.teiginys = teiginys); end; procedure Israsyti(sarasas: nuoroda); { irao teigini sra } begin if sarasas^.sekantis <> nil then begin Write(sarasas^.sekantis^.teiginys, ' '); Israsyti(sarasas^.sekantis); end; end; procedure Istrinti(var sarasas: nuoroda); { itrina teigini sra } begin if sarasas^.sekantis <> nil then Istrinti(sarasas^.sekantis); Dispose(sarasas); end; { taisykli sraai } procedure Prideti_taisykle(numeris: integer; konsekventas: char; prielaidos: nuoroda; var sarasas: Tnuoroda); { prideda taisykl prie srao galo } begin if sarasas^.sekantis = nil then begin New(sarasas^.sekantis); sarasas^.sekantis^.numeris:= numeris; sarasas^.sekantis^. konsekventas:= konsekventas; sarasas^.sekantis^.prielaidos:= prielaidos; sarasas^.sekantis^.sekantis:= nil; end else Prideti_taisykle(numeris, konsekventas, prielaidos, sarasas^.sekantis); end; procedure TIstrinti(var sarasas: Tnuoroda); { itrina taisykli sra } begin

27

if sarasas^.sekantis <> nil then TIstrinti(sarasas^.sekantis); if sarasas^.prielaidos <> nil then Istrinti(sarasas^.prielaidos); Dispose(sarasas); end; { ---------------------- vedimas ----------------------- } procedure Panaikinti_siuksles(var s: string); { panaikina tarpus, tabuliacijas, komentarus ir '->' } var rez: string; i: integer; koment: boolean; begin koment:= false; rez:= ''; if s <> '' then for i:= 1 to Length(s) do if not koment then if s[i] = '/' then koment:= true else if (s[i] <> ' ') and (s[i] <> '\t') and (s[i] <> '>') and (s[i] <> '-') then rez:= rez + s[i]; s:= rez; end; procedure Nuskaityti(failas: string); { nuskaito duomen fail } var t: text; eilute: string; prielaidos: nuoroda; i, t_numeris: integer; begin tikslas:= '-'; { '-' - tikslo nra } New(teiginiai); teiginiai^.sekantis:= nil; New(taisykles); taisykles^.sekantis:= nil; taisykles^.prielaidos:= nil; Assign(t, failas); Reset(t); { tikslas } if not Eof(t)

28

then begin Readln(t, eilute); Panaikinti_siuksles(eilute); if eilute <> '' then tikslas:= eilute[1]; end; { teiginiai } if not Eof(t) then begin Readln(t, eilute); Panaikinti_siuksles(eilute); if eilute <> '' then for i:= 1 to Length(eilute) do Prideti(eilute[i], teiginiai); end; { tuia eilut } if not Eof(t) then Readln(t); { taisykls } t_numeris:= 1; while not Eof(t) do begin Readln(t, eilute); Panaikinti_siuksles(eilute); if Length(eilute) > 1 then begin New(prielaidos); prielaidos^.sekantis:= nil; for i:= 1 to Length(eilute)-1 do Prideti(eilute[i], prielaidos); Prideti_taisykle(t_numeris, eilute[Length(eilute)], prielaidos, taisykles); t_numeris:= t_numeris + 1; end;

end;

Close(t); end; { ----------------- Pagrindin programa ------------------ } begin Nuskaityti('Duomenys.txt'); tikslas_pasiektas:= false; Write('Pradinis teigini sraas: '); Israsyti(teiginiai);

29

Writeln; Writeln; Write('Pritaikytos taisykls: '); {1} { R:= pirm taisykl } R:= taisykles^.sekantis; {2} { kol dar yra taisykli } while (not tikslas_pasiektas) and (R <> nil) do begin {3} { jei visos R prielaidos patenkintos } visi:= true; tmp:= R^.prielaidos^.sekantis; while tmp <> nil do begin if not Sarase(tmp^.teiginys, teiginiai) then visi:= false; tmp:= tmp^.sekantis; end; if visi then { jei R konsekvento dar nra teig. sarae } if not Sarase(R^.konsekventas, teiginiai) then begin { pridti R konsekvent } Prideti(R^.konsekventas, teiginiai); { jei jis tikslas, sustojame } if R^.konsekventas = tikslas then tikslas_pasiektas:= true; { iraomas ingsnis } Write('R', R^.numeris, ' '); {7} { R:= pirm taisykl } R:= taisykles^.sekantis; end else {8} { R:= sekani taisykl } R:= R^.sekantis else R:= R^.sekantis; end; Writeln; Writeln; Write('Galutinis teigini sraas: '); Israsyti(teiginiai); Writeln; Writeln; if tikslas_pasiektas

{4}

{5}

{6}

30

then Writeln('Tikslas pasiektas.') else if tikslas <> '-' then Writeln('Tikslas nepasiektas.'); Readln; Istrinti(teiginiai); TIstrinti(taisykles); end.

4.2 Graph_Method.pas programos kodas

program Graph_Method; type { nuoroda teigin } nuoroda = ^elementas; { Rodykl - nuorod nuorod teigin } Rnuoroda = ^Relementas; { nuorod i taisykl } Tnuoroda = ^Telementas; { Lankas - nuoroda nuorod taisykl } Lnuoroda = ^Lelementas; elementas = record teiginys: char; lankai: Lnuoroda; sekantis: nuoroda; end; Relementas = record rodykle: nuoroda; sekantis: Rnuoroda; end; Telementas = record numeris: integer; konsekventas: nuoroda; skaicius_salygu, patenkinta_salygu: integer; sekantis: Tnuoroda; end; Lelementas = record lankas: Tnuoroda; sekantis: Lnuoroda; end; var tikslas: char; teiginiai: Rnuoroda; grafas: nuoroda; taisykles: Tnuoroda; tikslas_pasiektas: boolean; A: Rnuoroda;

31

L: Lnuoroda; { ----------------- Graf funkcjonalumas ----------------- } { taisykls } procedure Prideti_taisykle(taisykle: Tnuoroda; var sarasas: Tnuoroda); { prideda taisykl prie srao galo } begin if sarasas^.sekantis = nil then sarasas^.sekantis:= taisykle else Prideti_taisykle(taisykle, sarasas^.sekantis); end; procedure LPrijungti(taisykle: Tnuoroda; var sarasas: Lnuoroda); { prijungia lank prie lank srao } begin if sarasas^.sekantis = nil then begin New(sarasas^.sekantis); sarasas^.sekantis^.lankas:= taisykle; sarasas^.sekantis^.sekantis:= nil; end else LPrijungti(taisykle, sarasas^.sekantis); end; procedure TIstrinti(var sarasas: Tnuoroda); { itrina taisykli sra } begin if sarasas^.sekantis <> nil then TIstrinti(sarasas^.sekantis); Dispose(sarasas); end; procedure LIstrinti(var sarasas: Lnuoroda); { itrina lank sra } begin if sarasas^.sekantis <> nil then LIstrinti(sarasas^.sekantis); Dispose(sarasas); end;

32

{ teiginiai } procedure Prijungti(teiginys: nuoroda; var sarasas: nuoroda); { prideda nuorod teigin prie srao galo } begin if sarasas^.sekantis = nil then sarasas^.sekantis:= teiginys else Prijungti(teiginys, sarasas^.sekantis); end; procedure RPrijungti(rodykle: nuoroda; var sarasas: Rnuoroda); { prijungia rodykl prie rodykli srao } begin if sarasas^.sekantis = nil then begin New(sarasas^.sekantis); sarasas^.sekantis^.rodykle:= rodykle; sarasas^.sekantis^.sekantis:= nil; end else RPrijungti(rodykle, sarasas^.sekantis); end; function Nuoroda_sarase(teiginys: char; sarasas: nuoroda): nuoroda; { grina nuorod surast teigin arba nil jei tokio srae nra } begin Nuoroda_sarase:= nil; if sarasas^.sekantis <> nil then Nuoroda_sarase:= Nuoroda_sarase(teiginys, sarasas^.sekantis); if sarasas^.teiginys = teiginys then Nuoroda_sarase:= sarasas; end; function Yra_Rsarase(teiginys: nuoroda; sarasas: Rnuoroda): boolean; { grina true jei srae yra rodykl i iekom teigin } begin Yra_Rsarase:= false; if sarasas^.sekantis <> nil then Yra_Rsarase:= Yra_Rsarase(teiginys,

33

sarasas^.sekantis); Yra_Rsarase:= Yra_Rsarase or (sarasas^.rodykle = teiginys); end; procedure Israsyti(sarasas: Rnuoroda); { irao teiginius, kuriuos rodo srao rodykls } begin if sarasas^.sekantis <> nil then begin Write(sarasas^.sekantis^.rodykle^. teiginys, ' '); Israsyti(sarasas^.sekantis); end; end; procedure Istrinti(var sarasas: nuoroda); { itrina teigini sra } begin if sarasas^.sekantis <> nil then Istrinti(sarasas^.sekantis); if sarasas^.lankai <> nil then LIstrinti(sarasas^.lankai); Dispose(sarasas); end; procedure RIstrinti(var sarasas: Rnuoroda); { itrina rodykli sra } begin if sarasas^.sekantis <> nil then RIstrinti(sarasas^.sekantis); Dispose(sarasas); end; { ---------------------- vedimas ----------------------- } procedure Panaikinti_siuksles(var s: string); { panaikina tarpus, tabuliacijas, komentarus ir '->' } var rez: string; i: integer; koment: boolean; begin

34

koment:= false; rez:= ''; if s <> '' then for i:= 1 to Length(s) do if not koment then if s[i] = '/' then koment:= true else if (s[i] <> ' ') and (s[i] <> '\t') and (s[i] <> '>') and (s[i] <> '-') then rez:= rez + s[i]; s:= rez; end; procedure Nuskaityti(failas: string); { nuskaito duomen fail ir sukonstruoja graf } var t: text; eilute: string; teiginys: nuoroda; taisykle: Tnuoroda; i, t_numeris: integer; c: char; begin tikslas:= '-'; { '-' - tikslo nra } New(teiginiai); teiginiai^.sekantis:= nil; New(grafas); grafas^.sekantis:= nil; New(taisykles); taisykles^.sekantis:= nil; Assign(t, failas); Reset(t); { tikslas } if not Eof(t) then begin Readln(t, eilute); Panaikinti_siuksles(eilute); if eilute <> '' then tikslas:= eilute[1]; end; { teiginiai } if not Eof(t) then begin Readln(t, eilute); Panaikinti_siuksles(eilute); if eilute <> '' then for i:= 1 to Length(eilute) do begin

35

end;

New(teiginys); teiginys^.teiginys:= eilute[i]; teiginys^.sekantis:= nil; New(teiginys^.lankai); teiginys^.lankai^.sekantis:= nil; Prijungti(teiginys, grafas); RPrijungti(teiginys, teiginiai); end;

{ tuia eilut } if not Eof(t) then Readln(t); { taisykls } t_numeris:= 1; while not Eof(t) do begin Readln(t, eilute); Panaikinti_siuksles(eilute); if Length(eilute) > 1 then begin { sukrimas } New(taisykle); taisykle^.numeris:= t_numeris; taisykle^.skaicius_salygu:= Length(eilute) - 1; taisykle^.patenkinta_salygu:= 0; taisykle^.sekantis:= nil; Prideti_taisykle(taisykle, taisykles); t_numeris := t_numeris + 1; { sujungimas su grafu i konsekvento puss } c:= eilute[Length(eilute)]; teiginys:= Nuoroda_sarase(c, grafas); if teiginys <> nil then taisykle^.konsekventas:= teiginys else begin New(taisykle^.konsekventas); taisykle^.konsekventas^. teiginys:= c; New(taisykle^.konsekventas^. lankai); taisykle^.konsekventas^.lankai^. sekantis:= nil; Prijungti(taisykle^.konsekventas, grafas); end; end; { sujungimas su prielaidomis grafe } if Length(eilute) > 1

36

then for i:= 1 to Length(eilute) - 1 do begin teiginys:= Nuoroda_sarase(eilute[i], grafas); if teiginys <> nil then LPrijungti(taisykle, teiginys^.lankai) else begin New(teiginys); teiginys^.teiginys:= eilute[i]; teiginys^.sekantis:= nil; New(teiginys^.lankai); teiginys^.lankai^.sekantis:= nil; LPrijungti(taisykle, teiginys^.lankai); Prijungti(teiginys, grafas); end; end; end; Close(t); end; { ----------------- Pagrindine programa ------------------ } begin Nuskaityti('Duomenys.txt'); tikslas_pasiektas:= false; Write('Pradinis teigini sraas: '); Israsyti(teiginiai); Writeln; Writeln; Write('Pritaikytos taisykls: '); {1} { A:= pirmas teiginys } A:= teiginiai^.sekantis; {2} { kol dar yra teigini } while (A <> nil) and (not tikslas_pasiektas) do begin {3} {4} {5} { L:= pirmas A lankas } L:= A^.rodykle^.lankai^.sekantis; { kol dar yra lank } while (L <> nil) and (not tikslas_pasiektas) do begin { +1 prie taisykls COUNT lanko gale } L^.lankas^.patenkinta_salygu:= L^.lankas^.patenkinta_salygu + 1; { jei patenkintos visos taisykls slygos } if (L^.lankas^.patenkinta_salygu =

{6}

37

{7}

L^.lankas^.skaicius_salygu) { ir jos konsekvento nra teigini srae } and not Yra_Rsarase( L^.lankas^.konsekventas, teiginiai) then begin { konsekventas prijungiamas prie teigini srao galo } RPrijungti( L^.lankas^.konsekventas, teiginiai); { iraomas ingsnis } Write('R', L^.lankas^.numeris, ' ');

{8}

{9}

{ jei konsekventas yra tikslas, sustojama } if L^.lankas^.konsekventas^. teiginys = tikslas then tikslas_pasiektas:= true; end; { L:= sekant A lank } L:= L^.sekantis; end;

{10}

{11}

{ A:= sekant teigin } A:= A^.sekantis; end;

Writeln; Writeln; Write('Galutinis teigini sraas: '); Israsyti(teiginiai); Writeln; Writeln; if tikslas_pasiektas then Writeln('Tikslas pasiektas.') else if tikslas <> '-' then Writeln('Tikslas nepasiektas.'); Readln; Istrinti(grafas); RIstrinti(teiginiai); TIstrinti(taisykles); end.

38