Metod tabloa za logiku prvog reda i njegovaimplementacija u programskom jeziku C++

Seminarski rad u okviru kursaAutomatsko rezonovanje

Matematički fakultet

Mentor: Filip Marić

Ajzenhamer Nikolaajzenhamernikola@gmail.com

2. avgust 2017.Sažetak

Logika prvog reda predstavlja moćan alat u kojem se mnogobrojniproblemi iz realnog života mogu jednostavno iskazati. Postojanje pro-cedura koje rešavaju probleme, odnosno, daju odgovore na pitanja kojase postavljaju u logici prvog reda su neophodni da bismo dobili rešenjana probleme iz stvarnog života koje zapisujemo u terminima logike prvogreda. Metod tabloa predstavlja jedan takav metod koji daje odgovor napitanje tautologičnosti formule, pri čemu daje i dokaz, ukoliko je formulatautologija. Cilj ovog rada jeste automatizacija ovog metoda korišćenjemprogramskog jezika C++.

Sadržaj1 Uvod 1

2 Osnovni pojmovi 2

3 Metod tabloa 6

4 Implementacija metoda tabloa 7

5 Zaključak 25

Literatura 25

1 UvodMetod tabloa predstavlja elegantan način formiranja dokaza, koji se

prevashodno koristi za ispitivanje tautologičnosti formula. U odnosu nametod tabloa za iskaznu logiku, metod tabloa u logici prvog reda donosisa sobom nove mogućnosti, ali i velike izazove. Ideja ovog rada jeste dauputi čitaoca u jednu moguću implementaciju metoda tabloa u logici pr-vog reda kroz programski jezik C++. Kroz rad, autor će napominjati da

1

metod može da se implementira na mnogo načina, pri čemu ova implemen-tacija nije najbolja niti najefikasnija. Štaviše, autor podstiče čitaoca narazmišljanje o ili alternativnim implementacijama ili načinu za podizanjeefikasnosti ove implementacije.

S obzirom da ovaj rad predstavlja proširenje rada [2] od istog autora, onse u velikoj meri oslanja na pojmove uvedene u njemu, ali i na programskikôd, te se čitaocu preporučuje da se prvo upozna za metodom tabloauvedenim u tom radu.

Izlaganje u ovom radu je podeljeno na nekoliko delova. U delu 2, uvodise sintaksa i semantika logike prvog reda, i to delom formalno, ali i delomneformalno jer to nije fokus ovog rada. Ipak, trebalo bi da čitalac dobrovlada formalnim delom logike prvog reda pre nego što se upusti u daljitekst. Kao dodatna literatura može se uzeti bilo koja knjiga koja govorio logici prvog reda, na primer, [3] ili [4].

U delu 3 čitalac se uvodi u metod tabloa za logiku prvog reda, pričemu je akcenat na razlikama između metoda u iskaznoj logici i logiciprvog reda. Takođe, daje se neformalni opis konstrukcije metoda. Ovajdeo je najpre zasnovan na [3], ali i značajnim delom na [5].

Glavni i finalni deo predstavlja deo 4, u kojem se prvobitno daje al-goritam metoda tabloa, koji je gotovo u potpunosti preuzet iz [3], presvega zbog postojanja dokaza korektnosti u istoj knjizi, ali i zbog do-datnih razmatranja pre samog algoritma. Zatim sledi implementacija uprogramskom jeziku C++ za čiji je sadržaj u potpunosti odgovoran autorrada. Deo se završava pomoću nekoliko primera rada programa, nakončega sledi zaključak rada.

2 Osnovni pojmoviU ovom delu biće predstavljeni osnovni pojmovi logike prvog reda

(engl. first-order logic). Čitalac će biti postepeno uveden putem sintakse isemantike logike prvog reda, za čime će uslediti diskusija o (polu)odlučivosti.Ipak, za razliku od osnovnog rada [2], u ovom radu neće biti dat velikiakcenat ovom delu teksta.

2.1 Formule logike prvog redaNa logiku prvog reda se može posmatrati kao proširenje iskazne lo-

gike koja uključuje iskaze sa predikatima koji se interpretiraju relacijamanad nekakvim (nepraznim) domenima. Dakle, predikati imaju određenustrukturu. Objekti su predstavljeni simbolima konstanti, a svojstva i od-nosi relacijskim simbolima. Takođe, možemo govoriti o objektima kojisu određeni na osnovu drugih objekata, čime nastaju funkcije koje seoznačavaju funkcijskim simbolima. Svakom simbolu je pridružena arnost,odnosno, broj argumenata na koji se funkcijski ili relacijski simbol pri-menjuje. U skladu sa time, konstante se mogu posmatrati kao funkcijskisimboli arnosti nula.Definicija 2.1. Jezik logike prvog reda L čini skup funkcijskih simbolaΣ, skup relacijskih simbola Π i funkcija ar : (Σ ∪ Π) −→ N koja svakomsimbolu dodeljuje arnost.

2

Nekada želimo da kažemo da određeno svojstvo važi za sve objekte iliza neke objekte. Takođe, nekada želimo da kažemo da su svi objekti unekom odnosu ili da su neki objekti u nekom odnosu. Zbog toga uvodimopromenljive i kvantifikatore [3].Definicija 2.2. Simbol ∀ predstavlja univerzalni kvantifikator (engl. uni-versal quantifier) i čita se ‚‚za svako”. Simbol ∃ predstavlja egzistencijalnikvantifikator (engl. existential quantifier) i čita se ‚‚postoji”. Kvantifika-tor (engl. quantifier) jeste ∀ ili ∃.

Naredne dve definicije uvode strukturu u predikatskim iskazima. Da-vanje unutrašnje strukture iskazima igra veoma važnu ulogu u logici prvogreda [4].Definicija 2.3. Skup termova jezika L (engl. terms) najmanji je skupkoji zadovoljava:

• Svaka promenljiva je term.• Ako je c simbol konstante jezika L, onda je c term.• Ako su t1, . . . , tk termovi, i f funkcijski simbol jezika L arnosti k,

onda je i f(t1, . . . , tk) takode term.Definicija 2.4. Skup atomičkih formula jezika L (engl. atomic formulas)najmanji je skup koji zadovoljava:

• Logičke konstante ⊤ i ⊥ su atomičke formule.• Ako je ρ relacijski simbol jezika L arnosti k, i t1, . . . , tk termovi

jezika L, onda je ρ(t1, . . . , tk) atomička formula.Formule logike prvog reda ćemo definisati po uzoru na definiciju iz

rada [2], pomoću strukture podataka stablo.Definicija 2.5. Skup formula logike prvog reda (kraće, skup formula)najmanji je skup koji zadovoljava:

• Formula je list koji je označen atomičkom formulom.• Formula je unutrašnji čvor koji je označen ¬ i koji ima jedno dete

koji je formula.• Formula je unutrašnji čvor koji je označen ∀x ili ∃x (za neku pro-

menljivu x) i koji ima jedno dete koji je formula.• Formula je unutrašnji čvor koji je označen jednim od simbola ∧, ∨,

⇒ ili ⇔ i koji ima dvoje dece koji su formule.Posledica prethodne definicije jeste da je algoritam za reprezentaciju

formule u linearnom obliku isti za formule iskazne logike i formule logikeprvog reda [2]. Dajmo jedan primer formule logike prvog reda i njenoglinearnog oblika.

3

Primer 2.6. Linearni oblik formule

∀x

∨

¬

∃y

p(x, y)

¬

∃y

p(y, x)

izgleda∀x(¬(∃y(p(x, y))) ∨ ¬(∃y(p(y, x)))).

2.2 Slobodne i vezane promenljiveVeć smo napomenuli da nam promenljive i kvantifikatori igraju važnu

ulogu u logici prvog reda. Naime, iz definicije 2.5 vidimo da formula kojaima kvantifikator, uz taj kvantifikator obavezno ide i promenljiva kojase kvantifikuje. U skladu sa time, biće nam važno da usvojimo pojmoveslobodne i vezane promenljive [4].Definicija 2.7. Slobodno pojavljvianje i vezano pojavljivanje promen-ljive u formuli definiše se na sledeći način:

• Svako pojavljivanje promenljive u atomičkoj formuli je slobodno u tojformuli.

• Svako pojavljivanje promenljive koje je slobodno u F je slobodno i u¬F . Svako pojavljivanje promenljive koje je vezano u F je vezano iu ¬F .

• Svako pojavljivanje promenljive koje je slobodno u F ili u G je slo-bodno i u F ∧ G, F ∨ G, F ⇒ G, F ⇔ G. Svako pojavljivanjepromenljive koje je vezano u F ili u G je vezano i u F ∧G, F ∨G,F ⇒ G, F ⇔ G.

• Svako slobodno pojavljivanje promenljive različite od x u formuli Fje takođe slobodno u formuli (∀x)F . Svako slobodno pojavljivanjepromenljive x u F je vezano (vodećim kvantifikatorom) u (∀x)F(tada kažemo da je x u dosegu vodećeg kvantifikatora). Pojavljivanjepromenljive x u (∀x) u formuli (∀x)F je vezano. Analogno važi zaegzistencijalni kvantifikator.

Definicija 2.8. Promenljiva je vezana (slobodna) u formuli ako i samoako ima vezano (slobodno) pojavljivanje u toj formuli.

Napomenimo da oznaka F (x1, . . . , xk) predstavlja da je skup slobodnihpromenljivih formule F podskup skupa {x1, . . . , xk}.

4

2.3 Značenje formula prvog redaZnačenje formula prvog reda je određeno semantikom logike prvog

reda. Opet će značenje formula logike prvog reda biti uvedeno slično kaou iskaznoj logici [2, 4].Definicija 2.9. Neka je dat jezik L. L-strukturu (ili, model) D čini:

• Neprazan skup objekata (domen) D.• Za svaki simbol konstante c, njegova interpretacija cD ∈ D.• Za svaki funkcijski simbol f arnosti k, njegova interpretacija fD : Dk −→ D.• Za svaki relacijski simbol ρ arnosti k, njegova interpretacija ρD ⊆ Dk.

Definicija 2.10. Valuacija v za skup promenljivih V u odnosu na domenD je preslikavanje koje svakom elementu iz V dodeljuje jedan element izD. Ako je v(xi) = dj, onda kažemo da je dj vrednost promenljive xi uvaluaciji v.

Narednim definicijama uvodimo vrednost termova i zadovoljenje (tač-nost) formula logike prvog reda. Obe definicije se definišu rekurzivno postrukturi terma, odnosno, formule.Definicija 2.11. Vrednost terma t se definiše na sledeći način:

• Ako je term t promenljiva x, onda je njegova vrednost vrednost pro-menljive x u valuaciji v, tj. Dv(t) = v(x).

• Ako je term t konstantni simbol c, onda je njegova vrednost inter-pretacija simbola c u L-strukturi D, tj. Dv(t) = cD.

• Ako je term t oblika f(t1, . . . , tk), onda je njegova vrednost jed-naka rezultatu primene funkcije koja je interpretacija simbola f uL-strukturi D na vrednosti termova t1, . . . , tk, tj. Dv(t) = fD(Dv(t1), . . . ,Dv(tk)).

Definicija 2.12. Zadovoljenje (ili, tačnost) formule se definiše na sledećinačin:

• Konstanta ⊤ je tačna u svakoj L-strukturi D i valuaciji v. Konstanta⊥ je netačna u svakoj L-strukturi D i valuaciji v.

• Atomička formula ρ(t1, . . . , tk) je tačna u L-strukturi D pri valuacijiv ako i samo ako važi ρD(Dv(t1), . . . ,Dv(tk)), gde je Dv(t) funkcijavrednosti terma t u L-strukturi D pri valuaciji v.

• Formula oblika ¬F je tačna u L-strukturi D pri valuaciji v ako isamo ako je formula F netačna u L-strukturi D pri valuaciji v.

• Formula oblika F ∧G je tačna u L-strukturi D pri valuaciji v ako isamo ako su obe formule F i G tačne u L-strukturi D pri valuacijiv.

• Formula oblika F ∨G je tačna u L-strukturi D pri valuaciji v ako isamo ako je bar jedna od formula F i G tačna u L-strukturi D privaluaciji v.

• Formula oblika F ⇒ G je tačna u L-strukturi D pri valuaciji v ako isamo ako je formula F netačna ili je formula G tačna u L-strukturiD pri valuaciji v.

5

• Formula oblika F ⇔ G je tačna L-strukturi D pri valuaciji v ako isamo ako su formule F i G istovremeno tačne ili istovremeno netačneu L-strukturi D pri valuaciji v.

• Formula oblika (∃x)F je tačna u L-strukturi D pri valuaciji v ako isamo ako postoji valuacija v′ dobijena od v samo izmenom vrednostipromenljive x takva da je F tačna u L-strukturi D pri valuaciji v′.

• Formula oblika (∀x)F je tačna u L-strukturi D pri valuaciji v ako isamo ako za svaku valuaciju v′ dobijenu od v samo izmenom vrednostipromenljive x važi da je F tačna u L-strukturi D pri valuaciji v′.

Činjenicu da je formula F tačna u L-strukturi D pri valuaciji v ozna-čavamo (D, v) � F . Kažemo još i da valuacija v zadovoljava formulu Fu L-strukturi D pri valuaciji v, da su L-struktura D i valuacija v modelformule F , itd. Formula je valjana ako je tačna u svakoj valuaciji, prisvakoj interpretaciji1.

Pojmovi logička posledica, logički ekvivalentna formula i zamena nećebiti formalno uvedeni u ovom tekstu, pa se čitalac upućuje na [4]. Ukolikoje čitalac upoznat sa osnovnim radom [2], onda neće imati problem sarazumevanjem daljeg teksta. Napomenimo samo da se u logici prvog redaposebno definiše zamena promenljive termom u termu i zamena promen-ljive termom u formuli.

3 Metod tabloaDa skok sa iskazne logike na logiku prvog reda predstavlja značajan

problem, najbolje se može videti u [3], u kojem su pre formalnog uvođenjametoda tabloa dati primeri koji demonstriraju probleme sa kojima se su-srećemo. Kao što je najavljeno, metod tabloa u ovom radu će biti uvedenkao proširenje metoda tabloa iz osnovnog rada [2].

3.1 Konstrukcija metoda tabloaMetod tabloa za iskaznu logiku se zasniva na četirima pravilima za

operatore ¬, ∧, ∨ i ⇒. Ova pravila se mogu opisati u terminima označenihformula. Među ovim označenim formulama su označene formule tipa α itipa β. Sva navedena pravila (tipovi označenih formula) se u potpunostiprenose u logiku prvog reda.

U logici prvog reda uvodimo dva nova tipa pravila: tip γ i tip δ.Označene formule tipa γ su označene formule T (∀x)A(x) i F (∃x)A(x),a označene formule tipa δ su označene formule T (∃x)A(x) i F (∀x)A(x).Pravila za ova dva tipa označenih formula su prikazana na slici 1.

1Primetimo da ovde nismo uveli formalno pojam interpretacije, zbog čega se čitalac upućujena [4] za više detalja.

6

T (∀x)A

TA[x → a]

F (∃x)A

FA[x → a]

Pravila za γ označene formule.

T (∃x)A

TA[x → a]

F (∀x)A

FA[x → a]

Pravila za δ označene formule.

Slika 1: Grafički prikaz γ i δ označenih formula.

Važno je da na ovom mestu damo neke napomene. Kao što vidimo,prethodna pravila služe za eliminaciju kvantifikatora i predstavljaju di-rektna pravila. Oznaka A[x → a] predstavlja zamenu svih pojavljivanjapromenljive x konstantom a u formuli A. Ovakva eliminacija kvantifika-tora iz formule oblika Qx(A), pri čemu je Q ∈ {∀, ∃}, naziva se instanci-jacija formule Qx(A). Prirodno se postavlja pitanje odabira konstante aza instanciju u pravilima 1. O ovome će biti reči u nastavku.

4 Implementacija metoda tabloaPre nego što pređemo na konkretnu implementaciju metoda tabloa u

programskom jeziku C++, prikažimo prvo pseudokôd algoritma. Algori-tam koji sledi je gotovo identičan onom koji je prikazan u [3], sa jednomizmenom koja će biti značajna za implementaciju algoritma koja mu sledi.Ta izmena će u kodu biti označena komentarom.

4.1 Pseudokôd izvršavanja algoritmaRezultat izvršavanja algoritma 1 je tablo. Tablo T je drvo u kojem je

svaki čvor označen parom W (n) = (U(n), C(n)), gde je

U(n) = {An1 , . . . , Ank}

skup formula iC(n) = {cn1 , . . . , cnm}

skup konstanti. C(n) sadrži listu svih konstanti koji se pojavljuju u U(n).

7

Algoritam 1 Metod tabloa za logiku prvog reda.Input: Formula logike prvog reda FOutput: Tablo T za F : svaka grana će biti beskonačna, konačna i markirana

otvorenom, ili konačna i markirana zatvorenom.1: procedure MetodTabloa(F )2: state: Inicijalno, tablo T se sastoji od jednog čvora n0, korena drveta,

čija je oznaka({F}, {a01 , . . . , a0k}),

gde je {a01 , . . . , a0k} skup konstanti koji se nalaze u F . Ako se u F nenalaze konstante, onda se bira proizvoljna konstanta a0 i čvor se označava({F}, {a0}).

3: state: Tablo se gradi induktivno biranjem neoznačenog lista l označenogW (l) = (U(l), C(l)).

4: if U(l) sadrži komplementarni par literala then5: state: Označi list kao zatvoren.6: else if U(l) nije lista literala then7: state: Izaberi formulu A u U(l) koja je α-, β- ili δ-formula.8: if A je α-formula then9: state: Napravi novi čvor l′ kao dete od l.

10: state: Označi l′ oznakom

W (l′) = ((U(l)− {A}) ∪ {α1, α2}, C(l)),

pri čemu su α1 i α2 formule koje nastaju primenom odgovarajućeg pravila(ako je A oblika ¬¬A1, onda ne postoji α2).

11: else if A je β-formula then12: state: Napravi nove čvorove l′ i l′′ kao decu od l.13: state: Označi l′ i l′′ oznakama

W (l′) = ((U(l)− {A}) ∪ {β1}, C(l)),W (l′′) = ((U(l)− {A}) ∪ {β2}, C(l)),

pri čemu su β1 i β2 formule koje nastaju primenom odgovarajućeg pravila.14: else if A je δ-formula then15: state: Napravi novi čvor l′ kao dete od l.16: state: Označi l′ oznakom

W (l′) = ((U(l)− {A}) ∪ {δ(a′)}, C(l) ∪ {a′}),

pri čemu je δ(a′) odgovarajuća instancija formule A i a′ je konstanta kojase ne pojavljuje u U(l).

17: end if

8

18: else19: Neka je {γl1 , . . . , γlm} ⊆ U(l) skup svih γ-formula u U(l).20: Neka je C(l) = {cl1 , . . . , clk}.21: state: Napravi novi čvor l′ kao dete od l.22: state: Označi l′ oznakom

W (l′) =

U(l) ∪

m∪i=1

k∪j=1

γli(γlj )

, C(l)

,

pri čemu su γli(γlj , i = 1,m, j = 1, n odgovarajuće instancije.23: if skup U(l) sadrži samo literale i γ-formule and U(l′) = U(lp), pri

čemu je lp čvor l ili neki njegov predak then24: state: Nemoj da napraviš čvor l′ već označi granu kao otvorenu.25: ◃ U originalnom izvoru, drugi uslov glasi U(l′) = U(l), odnosno, ne

razmatraju se preci čvora l.26: end if27: end if28: end procedure

4.2 Implementacija u programskom jeziku C++Opis implementacije metoda tabloa će teći sledećim redom. Prvo, na-

vodimo hijerarhiju termova kao i metode kojima smo dopunili hijerarhijuklasa formula iz [2] da bismo mogli da kreiramo proizvoljne formule logikeprvog reda. Zatim dajemo kratak opis metoda klase BaseSignedFormulai Tableaux i upućujemo na modifikacije u odnosu na [2]. Konačno, prika-zujemo detalje implementacije za svaki značajan metod. Ceo projekat2 jeu celovitosti dostupan na [1].

4.2.1 Hijerarhija termova i formulaU odnosu na iskaznu logiku, u logici prvog reda iskazi imaju struk-

turu. Tu strukturu čine promenljive, konstante i funkcije, koje predsta-vljaju termove. U skladu sa time i formalnim uvođenjem elemenata logikeprvog reda uvedene u delu 2, definišemo klasu BaseTerm iz koje izvodimoVariableTerm i FunctionTerm (primetićemo da su konstante implemen-tirane kao funkcijski termovi arnosti nula, tj. bez operandi). Na slici 2dat je dijagram klasa hijerarhije termova sa metodima implementiranimu njima. U nastavku dajemo kratak opis svake od njih, pri čemu nećemoopisivati get-metode i konstruktore.

2Autor skreće pažnju da je projekat kreiran korišćenjem Visual Studio 2017 Communityrazvojnog okruženja, pomoću Visual Studio 2017 (v141) platform toolset, za Windows SDKVersion 10.0.15063.0. Moguće je da je potrebno prilagoditi izvorni kôd da bi mogao bitipreveden od strane drugih kompilatora.

9

Slika 2: Hijerarhija termova.

Prvo, određujemo tip terma na osnovu enum Type { TT_VARIABLE,TT_FUNCTION };, enumeracije definisane u baznoj klasi. Metod printTermdefiniše na koji način se term ispisuje u izlazni tok. Metod equalTo porediterm sa drugim termom i vraća true ukoliko su sintaksno jednaki, a falseinače. Konačno, metod instantiate vrši sintaksnu operaciju zamene svihpojavljivanja neke promenljive nekim termom u termu i kao rezultat vraćaterm. U nastavku su date detaljne deklaracije opisanih klasa.

1 using namespace std;23 typedef string FunctionSymbol;4 typedef string PredicateSymbol;5 typedef string Variable;67 class BaseTerm;8 typedef shared_ptr<BaseTerm> Term;9

10 class BaseTerm : public enable_shared_from_this<BaseTerm>11 {12 public:13 enum Type { TT_VARIABLE, TT_FUNCTION };14 virtual Type getType() const = 0;15 virtual void printTerm(ostream & ostr) const = 0;16 virtual void getConstants(deque<FunctionSymbol> &

10

↪→ d_constants) const = 0;17 virtual bool equalTo(const Term & t) const = 0;18 virtual Term instantiate(const Variable & v, const Term & t)

↪→ = 0;1920 virtual ~BaseTerm() {}21 };2223 class VariableTerm : public BaseTerm24 {25 private:26 Variable _v;27 public:28 VariableTerm(const Variable & v);2930 virtual Type getType() const;31 const Variable & getVariable() const;32 virtual void printTerm(ostream & ostr) const;33 virtual void getConstants(deque<FunctionSymbol> &

↪→ d_constants) const;34 virtual bool equalTo(const Term & t) const;35 virtual Term instantiate(const Variable & v, const Term & t)

↪→ ;36 };3738 class FunctionTerm : public BaseTerm39 {40 private:41 FunctionSymbol _f;42 vector<Term> _ops;43 public:44 FunctionTerm(const FunctionSymbol & f,45 const vector<Term> & ops = vector<Term>());4647 virtual Type getType() const;48 const FunctionSymbol & getSymbol() const;49 const vector<Term> & getOperands() const;50 virtual void printTerm(ostream & ostr) const;51 virtual void getConstants(deque<FunctionSymbol> &

↪→ d_constants) const;52 virtual bool equalTo(const Term & t) const;53 virtual Term instantiate(const Variable & v, const Term & t)

↪→ ;54 };

4.2.2 Hijerarhija formulaHijerarhija formula je detaljno opisana u [2], te ovde neće biti mnogo

detalja o tome. Napomenimo da je hijerarhija proširena za strukturu klaseAtom, kao i za metode equalTo, koja poredi sintaksnu jednakost dvaju

11

formula i instantiate, koja zamenjuje svako pojavljivanje promenljivetermom u formuli i kao rezultat vraća formulu. Razlika između instan-ciranja i klasične zamene se ogleda posebno u klasama Forall i Exists,u kojima dolazi do eliminacije kvantifikatora ukoliko je promenljiva kojase menja vezana tim kvantifikatorom. Na slici 3 dat je dijagram klasahijerarhije formula3.

Slika 3: Hijerarhija formula.

4.2.3 Implementacija analitičkog tabloaPrvo navedimo razlike u odnosu na rad [2]. U okviru klase BaseSignedFormula

dodata je enumeracija

1 enum TableauxType {2 TT_ALPHA, TT_BETA, TT_GAMMA, TT_DELTA, TT_ATOM3 };

kojom se definišu tipovi označenih formula. Primetimo da atome posma-tramo kao poseban tip, što će nam biti korisno nadalje. Osim imple-mentacije get-metoda za tip označene formule, ova klasa nema dodatnihpromena.

U klasi Tableaux dolazi do najvećih izmena, te je nju potrebno posebnoopisati. Za početak, deklarišemo pomoćni metod getUniqueConstantSymbolkoji pronalazi konstantni simbol koji se ne nalazi u deku, koji je argumentmetoda. Implementacija ovog metoda je data sa

1 FunctionSymbol Tableaux::getUniqueConstantSymbol(deque<↪→ SignedFormula> & d_formulae) const

2 {3 static unsigned i = 0;4 FunctionSymbol uniqueConstant = "uc" + to_string(i);

3Slika je dostupna takođe i na adresi https://github.com/theikeofficial/Analytic-Tableaux-FOL/blob/master/classDiagrams/Formula.png, odakle je prikaz pre-gledniji.

12

56 deque<SignedFormula>::const_iterator iterFormulae =

↪→ d_formulae.cbegin();7 for (; iterFormulae != d_formulae.cend(); ++iterFormulae)8 {9 deque<FunctionSymbol> d_constants;

10 (*iterFormulae)->getFormula()->getConstants(d_constants);1112 deque<FunctionSymbol>::const_iterator iterConstants;13 do14 {15 ++i;16 uniqueConstant = "uc" + to_string(i);17 iterConstants = find(d_constants.cbegin(), d_constants.

↪→ cend(), uniqueConstant);18 } while (iterConstants != d_constants.cend());1920 }2122 return uniqueConstant;23 }

Dalje, dodajemo tri nova pomoćna metoda kojima se određuje odabirjednog od slučajeva iz algoritma 1. Ti metodi su redom, checkIfExistsComplementaryPairOfLiterals,checkIfExistsNonGammaRule i checkIfShouldBranchBeOpenForGammaRule.Njihove deklaracije su date sa

1 bool checkIfExistsComplementaryPairOfLiterals(deque<↪→ SignedFormula> & d_formulae) const;

2 bool checkIfExistsNonGammaRule(deque<SignedFormula> &↪→ d_formulae, SignedFormula & rule, BaseSignedFormula::↪→ TableauxType & ruleType) const;

3 bool checkIfShouldBranchBeOpenForGammaRule(deque<↪→ SignedFormula> & d_formulae, deque<FunctionSymbol> &↪→ d_constants) const;

U daljem tekstu dajemo njihov detaljni opis i implementaciju.Metod checkIfExistsComplementaryPairOfLiterals prolazi kroz dek

i proverava da li postoje dva literala koji su komplementarni, u skladu sanarednom definicijom.Definicija 4.1. Neka je X (neoznačeni) literal. Komplementarni lite-ral (označenom) literalu TX je (označeni) literal FX, a komplementarniliteral (označenom) literalu FX je (označeni) literal TX.Implementacija ovog metoda data je sa

1 bool Tableaux::checkIfExistsComplementaryPairOfLiterals(deque<↪→ SignedFormula>& d_formulae) const

2 {3 deque<SignedFormula>::const_iterator iter_outer = d_formulae

↪→ .cbegin();4 for (; iter_outer != d_formulae.cend(); ++iter_outer)

13

5 {6 // If the formula is not an atom, we can skip the check7 if ((*iter_outer)->getFormula()->getType() != BaseFormula

↪→ ::T_ATOM)8 {9 continue;

10 }1112 deque<SignedFormula>::const_iterator iter_inner =

↪→ iter_outer + 1;13 for (; iter_inner != d_formulae.cend(); ++iter_inner)14 {15 // Complementary pair of literals are TX and FX, where X

↪→ is a literal16 if ((*iter_outer)->getSign() != (*iter_inner)->getSign()

↪→ &&17 (*iter_outer)->getFormula()->equalTo((*iter_inner)->

↪→ getFormula()))18 {19 return true;20 }21 }22 }2324 return false;25 }

Metod checkIfExistsNonGammaRule proverava da li u deku postojioznačena formula tipa α, β ili δ, i ako postoji, onda čuva referencu natakvu označenu formulu kao i njen tip, i vraća true. Ne bi trebalo koristitiove dve vrednosti ukoliko metod vrati false. Implementacija ovog metodadata je sa

1 bool Tableaux::checkIfExistsNonGammaRule(deque<SignedFormula>&↪→ d_formulae, SignedFormula & rule, BaseSignedFormula::↪→ TableauxType & ruleType) const

2 {3 deque<SignedFormula>::const_iterator iter = d_formulae.

↪→ cbegin();4 for (; iter != d_formulae.cend(); ++iter)5 {6 BaseSignedFormula::TableauxType tType = (*iter)->getType()

↪→ ;7 if (tType == BaseSignedFormula::TT_ALPHA || tType ==

↪→ BaseSignedFormula::TT_BETA || tType ==↪→ BaseSignedFormula::TT_DELTA)

8 {9 rule = *iter;

10 ruleType = tType;11 return true;12 }

14

13 }1415 return false;16 }

Metod checkIfShouldBranchBeOpenForGammaRule predstavlja najkom-plikovaniji metod od pomenutih tri metoda. Ova metod proverava da litreba granu proglasiti otvorenom. Ovaj metod koristi dodatnu funkcijui strukturu podataka, te zbog toga predstavlja usko grlo ovog algoritma,pa bi se unapređenje implementacije moglo pre svega ogledati kroz una-pređenje ovog metoda. Koristićemo oznake uvedene algoritmom 1. Im-plementaciju ćemo opisivati i prikazivati deo po deo.

Prvo, metod izdvaja sve γ-formule u poseban dek i ujedno započinjeformiranje narednog čvora, tj. U(l′), u izradi tabloa. Zatim, počinjesa instancijacijom γ-formula i time završava formiranje U(l′). Pri tome,ukoliko se naiđe na označenu formulu koja već postoji u deku, ona nećebiti dodata.

1 bool Tableaux::checkIfShouldBranchBeOpenForGammaRule(deque<↪→ SignedFormula>& d_formulae, deque<FunctionSymbol> &↪→ d_constants) const

2 {3 deque<SignedFormula> d_gammaFormulae, d_nextFormulaeNode;4 deque<SignedFormula>::const_iterator iterFormulae =

↪→ d_formulae.cbegin();56 for (; iterFormulae != d_formulae.cend(); ++iterFormulae)7 {8 // Extract all gamma formulae9 if ((*iterFormulae)->getType() == BaseSignedFormula::

↪→ TT_GAMMA)10 {11 d_gammaFormulae.push_back(*iterFormulae);12 }1314 // Start filling the next node queue15 d_nextFormulaeNode.push_back(*iterFormulae);16 }1718 // Complete filling the next node deque by instantiating

↪→ gamma formulae19 iterFormulae = d_gammaFormulae.cbegin();20 for (; iterFormulae != d_gammaFormulae.cend(); ++

↪→ iterFormulae)21 {22 deque<FunctionSymbol>::const_iterator iterConstants =

↪→ d_constants.cbegin();23 for (; iterConstants != d_constants.cend(); ++

↪→ iterConstants)24 {25 Variable v;

15

26 BaseFormula::Type fType = (*iterFormulae)->getFormula()↪→ ->getType();

27 Quantifier * pQuantFormula = (Quantifier *)((*↪→ iterFormulae)->getFormula().get());

28 v = pQuantFormula->getVariable();2930 Formula instFormula = (*iterFormulae)->getFormula()->

↪→ instantiate(v, make_shared<FunctionTerm>(*iterConstants↪→ ));

31 SignedFormula instSignedFormula = make_shared<↪→ BaseSignedFormula>(instFormula, (*iterFormulae)->↪→ getSign());

3233 deque<SignedFormula>::const_iterator

↪→ iterFindFormulaeInner = find(d_nextFormulaeNode.cbegin↪→ (), d_nextFormulaeNode.cend(), instSignedFormula);

34 if (iterFindFormulaeInner == d_nextFormulaeNode.cend())35 {36 d_nextFormulaeNode.push_back(instSignedFormula);37 }38 }39 }

Dalje, metod izvršava proveru da li je formirani dek U(l′) jednak ne-kom deku U(lp). Ukoliko takav dek već postoji u tablou, to znači da granutreba proglasiti otvorenom. Inače, treba nastaviti sa konstrukcijom tabloai ažurirati odgovarajuće strukture. Ova opisana provera se vrši kroz po-moćnu funkciju checkIfAlreadyExistsSuchNode, i njena implementacijaće biti data nešto kasnije. Za sada, prikažimo opisanu implementacijuostatka metoda

1 if (checkIfAlreadyExistsSuchNode(d_nextFormulaeNode))2 {3 return true;4 }56 deque<SignedFormula> d_copyFormulae(d_nextFormulaeNode);7 _nodes.push_back(d_copyFormulae);89 d_formulae = move(d_nextFormulaeNode);

10 return false;11 }

U ovoj implementaciji, postoji poseban vektor dekova _nodes, dekla-risan sa

1 vector< deque<SignedFormula> > _nodes;

u kojem se čuvaju vrednosti svih prethodnih dekova. Tako imamo po-moćnu funkciju

1 bool checkIfAlreadyExistsSuchNode(deque<SignedFormula> &↪→ d_nextFormulaeNode);

16

koja proverava da li njen argument već postoji u vektoru _nodes, i njenaimplementacija je data sa

1 bool checkIfAlreadyExistsSuchNode(deque<SignedFormula>&↪→ d_nextFormulaeNode)

2 {3 vector<deque<SignedFormula>>::const_iterator iterNodes =

↪→ _nodes.cbegin();4 for (; iterNodes != _nodes.cend(); ++iterNodes)5 {6 deque<SignedFormula> d_formulae = *iterNodes;78 if (d_formulae.size() != d_nextFormulaeNode.size())9 {

10 continue;11 }1213 bool isEqual = true;14 deque<SignedFormula>::const_iterator iterFormulae =

↪→ d_formulae.cbegin();15 for (; iterFormulae != d_formulae.cend(); ++iterFormulae)16 {17 deque<SignedFormula>::const_iterator iterFindFormulae =

↪→ find(d_nextFormulaeNode.cbegin(), d_nextFormulaeNode.↪→ cend(), *iterFormulae);

18 if (iterFindFormulae == d_nextFormulaeNode.cend())19 {20 isEqual = false;21 break;22 }23 }2425 if (isEqual)26 {27 return true;28 }29 }3031 return false;32 }

Metod prove i dalje predstavlja osnovu algoritma, s tim da je ovdeznatno promenjen u odnosu na [2] kako bi se prilagodio algoritmu 1. Nje-gova implementacija je data sa

1 bool Tableaux::prove(deque<SignedFormula>&& d_formulae, deque<↪→ FunctionSymbol>&& d_constants, int tabs) const

2 {3 if (!d_formulae.empty())4 {5 // Writing the current state of tableaux to the standard

↪→ output

17

6 cout << string(tabs, '\t');7 cout << d_formulae << ", " << d_constants << endl;89 SignedFormula rule;

10 BaseSignedFormula::TableauxType tType;1112 if (checkIfExistsComplementaryPairOfLiterals(d_formulae))13 {14 // close the branch15 return true;16 }17 else if (checkIfExistsNonGammaRule(d_formulae, rule, tType

↪→ ))18 {19 if (tType == BaseSignedFormula::TT_ALPHA || tType ==

↪→ BaseSignedFormula::TT_BETA)20 {21 switch (rule->getFormula()->getType())22 {23 case BaseFormula::T_NOT:24 return notRules(move(d_formulae), move(d_constants

↪→ ), rule, tabs);25 case BaseFormula::T_AND:26 return andRules(move(d_formulae), move(d_constants

↪→ ), rule, tabs);27 case BaseFormula::T_OR:28 return orRules(move(d_formulae), move(d_constants)

↪→ , rule, tabs);29 case BaseFormula::T_IMP:30 return impRules(move(d_formulae), move(d_constants

↪→ ), rule, tabs);31 default:32 throw "Not applicable: Unknown formula type for

↪→ signed formula type ALPHA/BETA";33 }34 }35 else if (tType == BaseSignedFormula::TT_DELTA)36 {37 switch (rule->getFormula()->getType())38 {39 case BaseFormula::T_FORALL:40 {41 if (rule->getSign() == false)42 {43 return forallRules(move(d_formulae), move(

↪→ d_constants), rule, tabs);44 }45 else46 {47 throw "Not applicable: Unknown sign for signed

18

↪→ formula type DELTA";48 }49 }50 case BaseFormula::T_EXISTS:51 {52 if (rule->getSign() == true)53 {54 return existsRules(move(d_formulae), move(

↪→ d_constants), rule, tabs);55 }56 else57 {58 throw "Not applicable: Unknown sign for signed

↪→ formula type DELTA";59 }60 }61 default:62 throw "Not applicable: Unknown formula type for

↪→ signed formula type DELTA";63 }64 }6566 throw "Not applicable: unknown type of signed formula";67 }68 else69 {70 bool isOpenedBranch =

↪→ checkIfShouldBranchBeOpenForGammaRule(d_formulae,↪→ d_constants);

71 if (isOpenedBranch)72 {73 // mark the branch as open74 cout << string(tabs, '\t') << "O" << endl;75 return false;76 }77 else78 {79 return prove(move(d_formulae), move(d_constants), tabs

↪→ );80 }81 }82 }83 else84 {85 d_formulae.push_back(_root);86 deque<FunctionSymbol> d_firstConstants;87 _root->getFormula()->getConstants(d_firstConstants);88 if (d_firstConstants.size() == 0)89 {90 FunctionSymbol initConstant = getUniqueConstantSymbol();

19

91 d_firstConstants.push_back(initConstant);92 }93 return prove(move(d_formulae), move(d_firstConstants),

↪→ tabs);94 }95 }

I dalje postoje metodi za svaku formulu, s tim da je sada metodatomRules u potpunosti rasterećen i zapravo može biti potpuno uklonjen.Metodi notRules, andRules, orRules i impRules su modifikovani tolikoda vode računa da li će ubacivati formulu u dek ili ne (tj. da li već postojiili ne), kao i da uzimaju vektor _nodes u obzir, te nećemo prikazivatinjihove implementacije.

Novinu predstavljaju metodi forallRules i existsRules koji vrše in-stancijacije δ-formula i time završavaju pokrivanje celokupnog algoritma1. Njihove implementacije se gotovo podudaraju i date su sa

1 bool Tableaux::forallRules(deque<SignedFormula> && d_formulae,↪→ deque<FunctionSymbol> && d_constants, const↪→ SignedFormula & f, int tabs) const

2 {3 // Called only if it's a delta type SignedFormula, but let's

↪→ check anyway4 if (!(f->getSign() == false && f->getFormula()->getType() ==

↪→ BaseFormula::T_FORALL))5 {6 throw "Method forallRules not applicable!";7 }89 // Instantiate the formula with a new constant symbol

10 FunctionSymbol newConstant = getUniqueConstantSymbol(↪→ d_formulae);

11 Forall * pForall = (Forall *)f->getFormula().get();12 Formula instFormula = f->getFormula()->instantiate(pForall->

↪→ getVariable(), make_shared<FunctionTerm>(newConstant));1314 // Remove the formula from the deque and add the

↪→ instantiated formula15 deque<SignedFormula>::const_iterator iterSignedFormula =

↪→ find(d_formulae.cbegin(), d_formulae.cend(), f);16 if (iterSignedFormula != d_formulae.cend())17 {18 d_formulae.erase(iterSignedFormula);19 }20 d_formulae.push_back(make_shared<BaseSignedFormula>(

↪→ instFormula, f->getSign()));2122 // Add the new constant to the constants deque23 d_constants.push_back(newConstant);2425 return prove(move(d_formulae), move(d_constants), tabs);

20

26 }2728 bool Tableaux::existsRules(deque<SignedFormula> && d_formulae,

↪→ deque<FunctionSymbol> && d_constants, const↪→ SignedFormula & f, int tabs) const

29 {30 // Called only if it's a delta type SignedFormula, but let's

↪→ check anyway31 if (!(f->getSign() == true && f->getFormula()->getType() ==

↪→ BaseFormula::T_EXISTS))32 {33 throw "Method existsRules not applicable!";34 }3536 // Instantiate the formula with a new constant symbol37 FunctionSymbol newConstant = getUniqueConstantSymbol(

↪→ d_formulae);38 Exists * pExists = (Exists *)f->getFormula().get();39 Formula instFormula = f->getFormula()->instantiate(pExists->

↪→ getVariable(), make_shared<FunctionTerm>(newConstant));4041 // Remove the formula from the deque and add the

↪→ instantiated formula42 deque<SignedFormula>::const_iterator iterSignedFormula =

↪→ find(d_formulae.cbegin(), d_formulae.cend(), f);43 if (iterSignedFormula != d_formulae.cend())44 {45 d_formulae.erase(iterSignedFormula);46 }47 d_formulae.push_back(make_shared<BaseSignedFormula>(

↪→ instFormula, f->getSign()));4849 // Add the new constant to the constants deque50 d_constants.push_back(newConstant);5152 return prove(move(d_formulae), move(d_constants), tabs);53 }

4.3 Primeri rada programaU nastavku dajemo tri primera rada programa nad trima nasumično

odabranim formulama. Ispis na standardni izlaz je sličan kao u imple-mentaciji za iskaznu logiku, s tom razlikom da je uključen ispis konstanti.

21

1 ![X]:(a(X) => b(X)) => (?[X]:(a(X)) => ?[X]:(b(X)));23 { F (?[X] : (a(X) => b(X)) => (?[X] : a(X) => ?[X] : b(X))) }, {

↪→ uc0 }4 { T (?[X] : (a(X) => b(X))), F (?[X] : a(X) => ?[X] : b(X)) }, {

↪→ uc0 }5 { F (?[X] : a(X) => ?[X] : b(X)), T (a(uc2) => b(uc2)) }, { uc0,

↪→ uc2 }6 { T (a(uc2) => b(uc2)), T (?[X] : a(X)), F (?[X] : b(X)) }, { uc0

↪→ , uc2 }7 { T (?[X] : a(X)), F (?[X] : b(X)), F (a(uc2)) }, { uc0,

↪→ uc2 }8 { F (?[X] : b(X)), F (a(uc2)), T (a(uc5)) }, { uc0, uc2,

↪→ uc5 }9 { F (?[X] : b(X)), F (a(uc2)), T (a(uc5)), F (b(uc0)), F

↪→ (b(uc5)) }, { u10 c0, uc2, uc5 }11 X12 { T (?[X] : a(X)), F (?[X] : b(X)), T (b(uc2)) }, { uc0,

↪→ uc2, uc5 }13 { F (?[X] : b(X)), T (b(uc2)), T (a(uc8)) }, { uc0, uc2,

↪→ uc5, uc8 }14 { F (?[X] : b(X)), T (b(uc2)), T (a(uc8)), F (b(uc0)), F

↪→ (b(uc2)), F (b(15 uc5)), F (b(uc8)) }, { uc0, uc2, uc5, uc8 }16 X17 Your formula is TAUTOLOGY

Slika 4: Tablo formule ∀X(a(X) ⇒ b(X)) ⇒ (∃X(a(X)) ⇒ ∃X(b(X))).

22

1 ![X]:![Y]:![Z]:(p(X, X) & (p(X, Z) => (p(X, Y) | p(Y, Z)))) => ?[↪→ Y]:![Z]:p(Y, Z)

2 ;34 { F (?[X] : ?[Y] : ?[Z] : (p(X,X) & (p(X,Z) => p(X,Y) | p(Y,Z)))

↪→ => ?[Y] : ?[Z]5 : p(Y,Z)) }, { uc0 }6 { T (?[X] : ?[Y] : ?[Z] : (p(X,X) & (p(X,Z) => p(X,Y) | p(Y,Z))))

↪→ , F (?[Y] : ?[Z7 ] : p(Y,Z)) }, { uc0 }8 { F (?[Y] : ?[Z] : p(Y,Z)), T (?[Y] : ?[Z] : (p(uc2,uc2) & (p(uc2

↪→ ,Z) => p(uc2,Y)9 | p(Y,Z)))) }, { uc0, uc2 }

10 { F (?[Y] : ?[Z] : p(Y,Z)), T (?[Z] : (p(uc2,uc2) & (p(uc2,Z) =>↪→ p(uc2,uc4) | p(

11 uc4,Z)))) }, { uc0, uc2, uc4 }12 { F (?[Y] : ?[Z] : p(Y,Z)), T (p(uc2,uc2) & (p(uc2,uc6) => p(uc2,

↪→ uc4) | p(uc4,uc13 6))) }, { uc0, uc2, uc4, uc6 }14 { F (?[Y] : ?[Z] : p(Y,Z)), T (p(uc2,uc2)), T (p(uc2,uc6) => p(

↪→ uc2,uc4) | p(uc4,15 uc6)) }, { uc0, uc2, uc4, uc6 }16 { F (?[Y] : ?[Z] : p(Y,Z)), T (p(uc2,uc2)), F (p(uc2,uc6)

↪→ ) }, { uc0, uc217 , uc4, uc6 }18 { F (?[Y] : ?[Z] : p(Y,Z)), T (p(uc2,uc2)), F (p(uc2,uc6)

↪→ ), F (?[Z] : p(19 uc0,Z)), F (?[Z] : p(uc2,Z)), F (?[Z] : p(uc4,Z)), F (?[Z] : p(

↪→ uc6,Z)) }, { uc0,20 uc2, uc4, uc6 }21 { F (?[Y] : ?[Z] : p(Y,Z)), T (p(uc2,uc2)), F (p(uc2,uc6)

↪→ ), F (?[Z] : p(22 uc0,Z)), F (?[Z] : p(uc2,Z)), F (?[Z] : p(uc4,Z)), F (?[Z] : p(

↪→ uc6,Z)), F (p(uc023 ,uc0)), F (p(uc0,uc2)), F (p(uc0,uc4)), F (p(uc0,uc6)), F (p(uc2,

↪→ uc0)), F (p(uc224 ,uc2)), F (p(uc2,uc4)), F (p(uc4,uc0)), F (p(uc4,uc2)), F (p(uc4,

↪→ uc4)), F (p(uc425 ,uc6)), F (p(uc6,uc0)), F (p(uc6,uc2)), F (p(uc6,uc4)), F (p(uc6,

↪→ uc6)) }, { uc0,26 uc2, uc4, uc6 }27 X

Slika 5: Tablo formule ∀X∀Y ∀Z(p(X,X)∧ (p(X,Z) ⇒ (p(X,Y )∨p(Y, Z)))) ⇒∃Y ∀X(p(Y, Z)).

23

1 { F (?[Y] : ?[Z] : p(Y,Z)), T (p(uc2,uc2)), T (p(uc2,uc4)↪→ | p(uc4,uc6))

2 }, { uc0, uc2, uc4, uc6 }3 { F (?[Y] : ?[Z] : p(Y,Z)), T (p(uc2,uc2)), T (p(

↪→ uc2,uc4)) }, {4 uc0, uc2, uc4, uc6 }5 { F (?[Y] : ?[Z] : p(Y,Z)), T (p(uc2,uc2)), T (p(

↪→ uc2,uc4)), F (?6 [Z] : p(uc0,Z)), F (?[Z] : p(uc2,Z)), F (?[Z] : p(uc4,Z)), F (?[Z

↪→ ] : p(uc6,Z)) }7 , { uc0, uc2, uc4, uc6 }8 { F (?[Y] : ?[Z] : p(Y,Z)), T (p(uc2,uc2)), T (p(

↪→ uc2,uc4)), F (?9 [Z] : p(uc0,Z)), F (?[Z] : p(uc2,Z)), F (?[Z] : p(uc4,Z)), F (?[Z

↪→ ] : p(uc6,Z)),10 F (p(uc0,uc0)), F (p(uc0,uc2)), F (p(uc0,uc4)), F (p(uc0,uc6)), F

↪→ (p(uc2,uc0)),11 F (p(uc2,uc2)), F (p(uc2,uc4)), F (p(uc2,uc6)), F (p(uc4,uc0)), F

↪→ (p(uc4,uc2)),12 F (p(uc4,uc4)), F (p(uc4,uc6)), F (p(uc6,uc0)), F (p(uc6,uc2)), F

↪→ (p(uc6,uc4)),13 F (p(uc6,uc6)) }, { uc0, uc2, uc4, uc6 }14 X15 { F (?[Y] : ?[Z] : p(Y,Z)), T (p(uc2,uc2)), T (p(

↪→ uc4,uc6)) }, {16 uc0, uc2, uc4, uc6 }17 { F (?[Y] : ?[Z] : p(Y,Z)), T (p(uc2,uc2)), T (p(

↪→ uc4,uc6)), F (?18 [Z] : p(uc0,Z)), F (?[Z] : p(uc2,Z)), F (?[Z] : p(uc4,Z)), F (?[Z

↪→ ] : p(uc6,Z)) }19 , { uc0, uc2, uc4, uc6 }20 { F (?[Y] : ?[Z] : p(Y,Z)), T (p(uc2,uc2)), T (p(

↪→ uc4,uc6)), F (?21 [Z] : p(uc0,Z)), F (?[Z] : p(uc2,Z)), F (?[Z] : p(uc4,Z)), F (?[Z

↪→ ] : p(uc6,Z)),22 F (p(uc0,uc0)), F (p(uc0,uc2)), F (p(uc0,uc4)), F (p(uc0,uc6)), F

↪→ (p(uc2,uc0)),23 F (p(uc2,uc2)), F (p(uc2,uc4)), F (p(uc2,uc6)), F (p(uc4,uc0)), F

↪→ (p(uc4,uc2)),24 F (p(uc4,uc4)), F (p(uc4,uc6)), F (p(uc6,uc0)), F (p(uc6,uc2)), F

↪→ (p(uc6,uc4)),25 F (p(uc6,uc6)) }, { uc0, uc2, uc4, uc6 }26 X27 X28 Your formula is TAUTOLOGY

24

1 ![X]:(p(X) => ~p(X));23 { F (?[X] : (p(X) => ~p(X))) }, { uc0 }4 { F (?[X] : (p(X) => ~p(X))), F (p(uc0) => ~p(uc0)) }, { uc0 }5 { F (?[X] : (p(X) => ~p(X))), T (p(uc0)), F (~p(uc0)) }, { uc0 }6 { F (?[X] : (p(X) => ~p(X))), T (p(uc0)) }, { uc0 }7 { F (?[X] : (p(X) => ~p(X))), T (p(uc0)), F (p(uc0) => ~p(uc0))

↪→ }, { uc0 }8 { F (?[X] : (p(X) => ~p(X))), T (p(uc0)), F (~p(uc0)) }, { uc0 }9 { F (?[X] : (p(X) => ~p(X))), T (p(uc0)) }, { uc0 }

10 O11 Your formula is NOT A TAUTOLOGY

Slika 6: Tablo formule ∀X(p(X) ⇒ ¬p(X)).

5 ZaključakRazlika između iskazne logike i logike prvog reda ima mnogo. Me-

tod tabloa je jedan metod za dokazivanje tautologičnosti formula koji jeprimenljiv na obe logike, uz odgovarajuće modifikacije. U ovom raduje predstavljen jedan način automatizacije ovog metoda kroz programskijezik C++.

Ipak, kao što je već bilo reči u radu, načina za implementiranje ovogmetoda ima dosta i svaki donosi sa sobom određene osobine. U ovomradu je predstavljen jedan takav način, pri čemu nije bilo reči o njegovojoptimizaciji. U skladu sa time, jedna moguća dalja analiza bi podrazume-vala da se kôd dalje optimizuje. Neka druga bi podrazumevala smišljanjealternativnih implementacija.

Ipak, za ispitivanje tautologičnosti formula logike prvog reda, metodtabloa predstavlja sjajan metod u kojem se dobija celokupan dokaz da jeformula tautologija, odnosno, način da se pokaže njena porecivost ukolikoto nije. Zbog toga ovaj metod može da bude poželjniji od metoda koji tone pokazuju na tako pogodan način.

Literatura[1] N. Ajzenhamer. Analytic tableaux fol (izvorni kôd). https://github.

com/theikeofficial/Analytic-Tableaux-FOL.[2] N. Ajzenhamer. Metod tabloa za iskaznu logiku i njegova implemen-

tacija u programskom jeziku c++. 2017.[3] M. Ben-Ari. Mathematical Logic for Computer Science. Springer Pu-

blishing Company, Incorporated, 3rd edition, 2012.[4] P. Janičić. Matematička logika u računarstvu. Matematički fakultet,

2008.[5] R. M. Smullyan. First-Order Logic. Springer Berlin Heidelberg, 1968.

25