YAPAY ZEKA ve UZMAN SİSTEMLER

YAPAY ZEKA ve UZMAN SİSTEMLER Ders Notu - 7 Birinci Derece Lojik

Temel kavramlar 0-tertip yüklem veya önerme hesabı (propositional calculus) veya önermeler mantığı Her cümle, önerme simgesi denen bir simge ile ifade edilir: Ali iyi öğrencidir Fatma çok iyi öğrencidir Ahmet’in babası Mehmet’tir Bu cümleleri uygun olarak A,F,M ile ifade edebiliriz A,F,M- önerme simgeleridir ve gerçek değerler (doğru veya yanlış) alıyorlar 0- tertip yüklemin ifade gücü zayıftır.

Önermeler mantığının artı ve eksi yönleri Önermeler mantığı tanımlayıcıdır (declarative)Önermeler mantığı düzenseldir (compositional): B1,1 P1,2‘nin anlamı B1,1ve P1,2’ ‘nin anlamlarından alınıyor Önermeler mantığının anlamı bağlamdan bağımsızdır (context-independent)(doğal dilde anlam bağlama bağlıdır) Önermeler mantığının ifade gücü doğal dilden farklı olarak çok sınırlıdır Örneğin, bunu söylemek mümkün değil: “kuyular, komşu karelerde rüzgarlara neden oluyor“; bunun için her kare için bir cümle yazmak zorundayız

Birinci derece (tertip) lojik (mantık) –(First Order Logic-FOP) Önermeler mantığı dünyanın olgulardan oluştuğunu varsayıyor Birinci tertip mantık ise doğal dilde olduğu gibi dünyanın nesnelerden, ilişkilerden,işlevlerden oluştuğunu varsaymaktadır:Nesneler (isim ve isim birleşmeleri): insanlar, atlar, sayılar, renkler, oyunlar,savaşlar… İlişkiler (fiil ve fiil birleşmeleri): kırmızıdır, kardeşidir, … ‘dan büyüktür, … aralığındadır, … İşlevler (verilmiş nesne için tek bir “değer” veren ilişki) : en iyisi, üçüncüsü, babası…

Birinci Tertip mantık -Örnek Nesneler: kişi, taç, kişi kral, sol bacaklar İlişkiler: Kardeşidir Başındadır işlevler : Sol bacağıdır

Birinci Tertip Mantık-Temel unsurlar Sabitler (nesnelere uygun)(Constants): KralJohn,2,… Yüklemler (ilişkilere uygun)(Predicates)Kardeş İşlevler (işlevlere uygun) Sqrt, SolBacağıdır,... Değişkenler x, y, a, b,... Bağlayıcılar, , , ,  Eşitlik = Niceleyiciler (Quantifiers), 

Değişken, terim, cümle Değişken-değeri değişe bilen simge; küçük harflerle yazılıyor Terim-nesneyi ifade eden mantıksal ifadedir; sabit-basit terimdir, işlev-karmaşık terimdir Terim = işlev(terim1,...,terimn) veyasabit veya değişken Bölünmez cümle = yüklem(terim1,...,terimn) veyaterim1 = terim2 Karmaşık cümle- bölünmez cümlelerden oluşuyor (bağlayıcılar, niceleyiciler ve değişkenler kullanmakla) Örnek:Kardeşidir(John,Richard) ^ Kardeşidir(Richard,John)~Kardeşidir(Solbacağı(Richard),John) ~Kral (Richard) => Kral (John)

Yüklemler (predicate) N dereceli yüklem, yüklem adından ve n argümandan (terim) oluşmaktadır. “Ali iyi öğrencidir“ “iyi-öğrenci (ali), “öğrencidir (ali, iyi)”, öğrenci(ali, iyi)“ olarak, “Fatma çok iyi öğrencidir”ise “öğrenci(fatma, çok iyi)" gibi ifade edile bilir Genel olarak “öğrenci(X, Y)“ gibi yazmak mümkündür “Ahmet‘in babası Mehmet’tir" cümlesi babasıdır(ahmet, mehmet)" veya sadece “baba(ahmet, mehmet)" gibi ifade edile biler. “Ahmet‘in babası ve Ali’nin babası arkadaştırlar" arkadaş(baba(ahmet), baba(ali)).

Niceleyiciler Değişkenlerin kullanımı ifadenin gücünü arttırıyor. Değişkenler niceleyicilerle birlikte kullanılabilir. Niceleyici değişkenin ifadedeki rolünü gösterir. Yüklemler mantığında iki tür niceleyici kullanılmaktadır: Genel (universal)  (“tümü için") Mevcutluk (existential)  (“öyle biri mevcuttur"). Birinci tertip yüklemler hesabı veya yüklemler mantığı (First order predicate calculus veya first order predicate logic-FOPL) niceleyicili değişkenlerin kullanımına izin veriyor. Ama FOPL’da yüklemler veya fonksiyonlar kullanılamaz.

Niceleyiciler için dönüştürme kuralları

Niceleyiciler-örnekler x ySeviyor(x,y) -“Öyle bir insan var ki, o dünyada herkesi seviyor” xySeviyor(x,y)-Her kişinin sevdiği bir insan var yxSeviyor(x,y)- öyle bir insan var ki, o herkes tarafından seviliyor (dikkat edin: bu cümlede y, x’ den önce kullanılmıştır) Bir niceleyiciyi diğer tür niceleyici ile ifade etmek mümkündür xBayılıyor(x,Dondurma) x Bayılıyor(x,Dondurma) x Bayılıyor(x,Brokoli) xBayılıyor(x,Brokoli)

Niceleyiciler –örnek (devamı) F(x, y)- “x, y’den daha hızlıdır” anlamını veriyor. X ve Y, uçaklar kümesine aittir. xyF(x, y): “her bir x uçağı için aşağıdaki doğrudur: x, her hangi y uçağından daha hızlıdır". Daha basit dilde, “her bir uçak her bir uçaktan (kendisi de dahil olmakla!) hızlıdır". xyF(x, y): “her bir x uçağı için aşağıdaki doğrudur:bazı y ve bazı x uçakları için x y’den daha hızlıdır". Daha basit dilde: “Her bir uçak bazı uçaklardan hızlıdır". xy F(x, y): “öyle bir x uçağı var ki, her bir y uçağı için, x y’den hızlıdır”. Daha basit dilde: “bazı uçaklar her bir uçaktan daha hızlıdır". xyF(x, y): “bazı x uçağı için öyle bir y uçağı var ki, x y’den hızlıdır“. Daha basit dilde: “bazı uçaklar bazı uçaklardan hızlıdırlar”

Niceleyici kullanımına örnekler p,c Ebeveyn(p,c)=>Evlat(c,p) g,c Dede(g,c)  p Ebeveyn(g,p)  Ebeveyn(p,c) s Rüzgar(s) => r Komşu(r,s)  Kuyu (r) “Haftanın her Pazartesi ve Çarşamba günleri ben Ahmetlerin evine öğlen yemeğine gidiyorum” X ((haftanın_günü(X,pazartesi) v haftanın_günü(X,çarşamba))=>(gitmek(ben,ev_ahmet) yemek(ben,öğlen_yemeği)))) Birisinin annesi o kişinin kadın ebeveynidirm,c Anne(c) = m (Kadın(m) Ebeveyn(m,c) Anne(c ) C’nin annesi m- bir kişi

FOL için Çıkarsama Kuralları • PL için çıkarsama kuralları FOL’a da uygulanabilir (Modus Ponens, And-Introduction, And-Elimination, vb) • Quantifierlarla kullanmak için yeni(sound) çıkarsama kuralları : • Universal Elimination • Existential Introduction • Existential Elimination • Generalized Modus Ponens (GMP) • Çözümleme (Resolution) • Clause form (FOL’de CNF) • Unification (tutarlı değişken ikamesi) • Refutation resolution (çelişki ile ispat)

Universal Elimination (x) P(x) |-- P(c). • Eğer (x) P(x) doğru ise, x’ in domenindeki herhangi bir c sabiti için P(c) de doğrudur, mesela, (x) P(x) |= P(c). • x’in her olayını x kapsamında aynı temel (ground) terimle yer değiştir (bir sabit ya da bir temel fonksiyon). • Örnek: (x) yer(Ziggy, x) |-- yer(Ziggy, Dondurma) Existential Introduction P(c) |-- (x) P(x) • Eğer P(c) doğruysa, (x) P(x) de doğrudur, mesela, P(c) |= (x) P(x) • Verilen sabit sembolün tüm örneklerini aynı yeni değişken sembolüyle yer değiştir. • Örnekyer(Ziggy, Dondurma) |-- (x) yer(Ziggy, x)

Existential Elimination • (x) P(x)’den P(c)’yi çıkarsa, mesela., (x) P(x) |= P(c), c yeni bir sabit semboldür, • Tüm bildiğimiz bunu doğru yapan bir sabitin olması zorunluluğudur, böylece bu sabitin yerini alacak yepyeni birini ortaya çıkarabiliriz, tam olarak bu sabitin neye işaret ettiğini bilmediğimiz halde. • Örnek: (x) yer(Ziggy, x) |= yer(Ziggy, İlaç)

Universal quantifier’lar olduğunda işler daha karmaşık olur (x)(y) yer(x, y) |= (x)yer(x, İlaç) ??? (x)(y) yer(x, y) |= yer(Ziggy, İlaç) ??? • y için yeni yemek_sk(x) fonksiyonunu takdim ederiz çünkü y, x’e bağlıdır (x)(y) yer(x, y) |-- (x)yer(x, yemek_sk(x)) (x)(y) yer(x, y) |-- yer(Ziggy, yemek_sk(Ziggy)) • Tam olarak yemek_sk(.) fonksiyonunun ne yaptığı bilinmez sadece x’i argümanı olarak alır • Existential elimination işlemi “Skolemization”olarak adlandırılır, ve yeni, tek sabit(örneğin İlaç) ve fonksiyon (örneğin yemek_sk(.)) skolem sabiti ve skolem fonksiyonun olarak adlandırılır

Generalized Modus Ponens (GMP) • And-Introduction, Universal-Elimination, ve Modus Ponens’i birleştirir • Ör: P(c), Q(c), (x)(P(x) ^ Q(x)) => R(x) |-- R(c) P(c), Q(c) |-- P(c) ^ Q(c) (and-introduction) (x)(P(x) ^ Q(x)) => R(x) |-- (P(c) ^ Q(c)) => R(c) (universal-elimination) P(c) ^ Q(c), (P(c) ^ Q(c)) => R(c) |-- R(c) (modus ponens) • Quantifyedilen bir değişkenin tüm olayları aynı sabite instantiate edilmelidir. P(a), Q(c), (x)(P(x) ^ Q(x)) => R(x) |-- R(c) Çünkü x’in tüm olayları a’ya ya da c’ye instantiate edilmelidir, bu modus ponensi uygulanabilir yapmaz.

FOL için Çözümleme • Çözümleme kuralı iki clauseüzerinde işlem yapar • Bir clause literallerin disjunction’ ıdır (açık quantifier’sız) • KB’de clause’lar arasındaki ilişkiler conjunction’dır • FOL için Çözümleme Kuralı: • clause C1: (l_1, l_2, ... l_i, ... l_n) ve clause C2: (l’_1, l’_2, ... l’_j, ... l’_m) • Eğer l_i ve l’_j iki zıt literalse(mesela, P ve ~P) ve x1, ... Xk ların değişken, y1, ... Yk ların terimler olduğu q = {x1/y1, ... Xk/yk} değişken bindingleriyle argüman listeleri aynı yapılabiliyorsa (unified) o zaman çözücü olarak adlandırılan yeni bir clause türet subst((l_1, l_2, ... l_n, l’_1, l’_2, ... l’_m), q) subst(ifade, q) fonksiyonu orijinal ifadeye q ‘da tüm değişken bindinglerini uygulayarak yeni bir ifade geri gönderir

Aşağıdaki Soruları Cevaplamaya İhtiyaç Duyarız • FOL cümlelerini clause formuna nasıl dönüştürürüz (özellikle quantifierları nasıl kaldırırız) • İki argüman listesini nasıl unify ederiz, mesela, en genel unifierlarını (mgu) qnasıl buluruz • KB’deki hangi iki clause’ın bir sonraki aşamada (tüm çözümlenebilir clause çiftleri arasında) çözümleneceğine nasıl karar veririz ve ispatın tamamlandığına nasıl karar veririz

FOL cümlelerini clause forma dönüştürme • Clauselar FOL cümlelerinin quantifier serbest CNF’leridir • Temel fikirler • Quantifierları nasıl idare ederiz • Önde bulunan negatif quantifierlarda dikkat (açık ya da kapalı) ~x P(x) gerçektenx ~P(x) dir (x P(x)) => (y Q(y)) ~(x P(x)) v (y Q(y)) x ~P(x) v y Q(y) • Doğru existential quantifierları Skolemization ile elimine et • Doğru universally quantify edilmiş değişkenlere quantifiersızmış gibi davran • CNF’ye nasıl dönüştürülür (PL’ye benzer fakat quantifierlarla çalışmak gerekir)

Dönüşüm Prosedürü Adım 1: tüm “=>” ve “<=>” operatörlerini kaldır (P => Q ~P v Q ve P <=> Q P => Q ^ Q => P kullan) Adım2: tüm negatif işaretleri her bir yükleme taşı (de Morgan kuralını kullan) Adım3: tüm existential quantifiers y kaldır durum 1: y herhangi bir universally quantified değişkenin kapsamında değil, o zaman y’nin tüm olaylarını bir skolem sabitiyle yer değiştir durum 2:y universally quantified değişkenlerinin x1, ... xi, kapsamında ise, o zaman y’nin tüm olaylarını bir skolem fonksiyonla yer değiştir Adım4: tüm universal quantifiers x kaldır (kalan tüm değişkenler universally quantified dır) Adım5: cümleleri CNF’ye çevir(distribution kuralınıvb. kullan) Adım6: tüm disjunctionları ayırmak için parantez kullan, sonra tüm v ve ^ leri düşür

Dönüşüm örneği x (P(x) ^ Q(x) => R(x))y gül(y) ^ sarı(y) x ~(P(x) ^ Q(x)) v R(x) (adım 1) gül(c) ^ sarı(c) x ~P(x) v ~Q(x) v R(x) (adım 2) (c bir skolem sabitidir) ~P(x) v ~Q(x) v R(x) (adım 4) (gül(c)), (sarı(c)) (~P(x), ~Q(x), R(x)) (adım 6) x [insan(x) => y (insan(y) ^ baba(y, x))] x [~insan(x) v y (insan(y) ^ baba(y, x))] (adım 1) x [~insan(x) v (insan(f_sk(x)) ^ baba(f_sk(x), x))] (adım 3) ~insan(x) v (insan(f_sk(x)) ^ baba(f_sk(x), x)) (adım 4) (~insan(x) vinsan(f_sk(x)) ^ (~insan(x) v baba(f_sk(x), x)) (adım 5) (~insan(x),insan(f_sk(x)), (~insan(x), baba(f_sk(x), x)) (adım 6) (f_sk(.) bir skolem fonksiyondur)

İki clause’ın Birleşmesi (Unification ) Temel fikir: x P(x) => Q(x), P(a) |-- Q(a) (~P(x), Q(x)), (P(a)) {x/a} x değişkenin a’ya sınırlanır Q(a) Amaç iki zıt literallerin (iki clause’da) argüman listelerinin aynı yapılabileceği değişken bindinglerinin bir kümesini bulmaktır. Sadece değişkenler diğerlerine bağlanabilir. a ve b birleştirilemez (genelde farklı sabitler farklı nesnelere işaret eder) a ve f(x) birleştirilemez (f’in ters fonksiyonu bilinmezse) f(x) ve g(y) birleştirilemez (genelde fonksiyon sembolleri f ve g farklı fonksiyonları gösterir ve onların kesin tanımları farklı yorumlar altında farklıdır)

x, y’de herhangi bir yerde görünürse y’ye bağlanamaz • Aynı fonksiyonun iki terimini birleştirmek için onların argüman listelerini birleştir (unification recursiftir) Ör: f(x) ve f(g(b)) yi birleştirmek için , x ve g(b) yi birleştirmeye ihtiyaç duyarız

Argüman listesi çoklu terim içerirse her bir terim çiftini birleştir Ör. (x, f(x), ...) (a, y, ...) i birleştirmek için • x ve a yı birleştir (q = {x/a}) • q’ı iki listede kalan terimlere uygula, (f(a), ...) ve (y, ...) • f(a) ve y ‘yi y/f(a) bindingiyle birleştir • Yeni y/f(a) bindingini q ‘ya uygula • y/f(a)’yi yeni q ‘ya ekle

Unification Örnekleri • parents(x, father(x), mother(Bill)) and parents(Bill, father(Bill), y) • unify x and Bill: q = {x/Bill} • unify father(Bill) and father(Bill): q = {x/Bill} • unify mother(Bill) and y: q = {x/Bill}, /mother(Bill)} • parents(x, father(x), mother(Bill)) and parents(Bill, father(y), z) • unify x and Bill: q = {x/Bill} • unify father(Bill) and father(y): q = {x/Bill, y/Bill} • unify mother(Bill) and z: q = {x/Bill, y/Bill, z/mother(Bill)} • parents(x, father(x), mother(Jane)) and parents(Bill, father(y), mother(y)) • unify x and Bill: q = {x/Bill} • unify father(Bill) and father(y): q = {x/Bill, y/Bill} • unify mother(Jane) and mother(Bill): Failure because Jane and Bill are different constants

Daha Fazla Unification Örnekleri • P(x, g(x), h(b)) and P(f(u, a), v, u)) • unify x and f(u, a): q = {x/ f(u, a)}; remaining lists: (g(f(u, a)), h(b)) and (v, u) • unify g(f(u, a)) and v: q = {x/f(u, a), v/g(f(u, a))}; remaining lists: (h(b)) and (u) • unify h(b) and u: q = {x/f(h(b), a), v/g(f(h(b), a)), u/h(b)}; • P(f(x, a), g(x, b)) and P(y, g(y, b)) • unify f(x, a) and y: q = {y/f(x, a)} remaining lists: (g(x, b)) and (g(f(x, a), b)) • unify x and f(x, a): failure because x is in f(x, a)

Unification Algoritması procedure unify(p, q, q) /* p and q are two lists of terms and |p| = |q| */ if p = empty thenreturn q; /* success */ let r = first(p) and s = first(q); if r = s then return unify(rest(p), rest(q), q); if r is a variable then temp = unify-var(r, s); else if s is a variable then temp = unify-var(s, r); else if both r and s are functions of the same function name then temp = unify(arglist(r), arglist(s), empty); elsereturn “failure”; if temp = “failure” then return “failure”; /* p and q are not unifiable */ elseq = subst(q, temp) temp; /* apply tmp to old q then insert it into q */ return unify(subst(rest(p), tmp), subst(rest(q), tmp), q); end{unify} procedure unify-var(x, y) if x appears anywhere in y then return “failure”; else return (x/y) end{unify-var}

FOL’de Çözümleme • KB’de tüm cümleleri (aksiyomlar, tanımlar, ve bilinen gerçekler) ve hedef cümleyi (ispatlanacak teorem) clause forma dönüştür • İki clause C1 ve C2 çözümlenemez ancak ve ancak C1’de r ve C2 ‘de s iki zıt literalse ve onların argüman listeleri arglist_r ve arglist_s mgu = q ile birleştirilebilirse. • Sonraçözümleyici cümleyi türet : subst((C1 – {r}, C2 – {s}), q) (substitution C1 ve C2’deki tüm literallere uygulanır, diğer herhangi clauselara uygulanmaz) • Örnek (P(x, f(a)), P(x, f(y)), Q(y)) (~P(z, f(a)), ~Q(z)) q = {x/z} (P(z, f(y)), Q(y), ~Q(z))

Çözümleme örneği • Şunu ispatlayın w P(w) => Q(w), y Q(y) => S(y), z R(z) => S(z), x P(x) v R(x) |= u S(u) • Bu cümleleri clauselara çevir (u S(u) S(a)’ya skolemize olur) • Çözümlemeyi uygula (~P(w), Q(w)) (~Q(y), S(y)) (~R(z), S(z)) (P(x), R(x)) (~P(y), S(y)) {w/y} (S(x), R(x)) {y/x} (S(a)) {x/a, z/a} • Problemler • S(a) teoremi aktif olarak ispata katılmaz • Eğer teorem birden fazla clausea sahipse ispatın (tutarlı değişken bindingi le) tamamlanıp tamamlanmadığına karar vermek zordur Bir çözümleme ispat ağacı

Çözümleme Çürütme (Resolution Refutation): daha iyi bir ispat stratejisi • Tutarlı aksiyomlar kümesi KB ve hedef Q cümlesi verilsin. KB |= Q ispatla . • Çelişki ile ispat: KB’ye ~Q ekle ve yanlışı ispatlamaya çalış. çünkü (KB |= Q) <=> (KB ^ ~Q |= Yanlış, ya da KB ^ ~Q tutarsızdır) • “yanlışı”clause formda nasıl temsil ederiz • P(x) ^ ~P(y) tutarsızdır • Onları clause formuna dönüştür ve çözünürlüğü uygula (P(x)) (~P(y)) {x/y} () boş bir durum • Boş bir clause yanlışı temsil eder (tutarsızlık/çelişki) • KB ^ ~Q den çözünürlükle boş bir clause türetebilirsek KB |= Q

Çözümleme çürütmeyle şunu ispatlayın w P(w) => Q(w), y Q(y) => S(y), z R(z) => S(z), x P(x) v R(x) |= uS(u) • Bu cümleleri clauselara dönüştür (~ u S(u), ~S(u)’ya dönüşür) (~P(w), Q(w)) (~Q(y), S(y)) (~R(z), S(z)) (P(x), R(x)) (~S(u)) (~R(z)) {u/z} (~Q(y)) {u/y} (~P(w)) {y/w} (P(x)) {z/x} () {x/w}

Çözümleme Çürütme Prosedürü procedure resolution(KB, Q) /* KB is a set of consistent, true FOL sentences, Q is a goal sentence. It returns success if KB |-- Q, and failure otherwise */ KB = clause(union(KB, {~Q})) /* convert KB and ~Q to clause form */ while null clause is not in KB do pick 2 sentences, S1 and S2, in KB that contain a pair of opposite literals whose argument lists are unifiable if none can be found then return "failure" resolvent = resolution-rule(S1, S2) KB = union(KB, {resolvent}) return "success " end{resolution}

Kontrol Stratejileri • Herhangi bir zamanda çözünebilir çoklu clause çifti vardır. Bu yüzden ispatın her adımında böyle bir çift seçmek için sistematik bir yola ihtiyacımız vardır • Null clause’a sebep olabilir • İmkan dahilinde iyi çıkarsama sırasını kaybetmeden • Bir çözümleme teorem ispatlayıcısını kontrolde kullanışlı olan birçok genel (domen bağımsız) strateji vardır. • İsimler... • Breadth first • Set of support • Unit resolution • Input Resolution • Ordered resolution • Subsumption

Otomatik Teorem İspat Örneği: Curiosity kediyi öldürdü mü • Jack bir köpeğe sahiptir. Her bir köpek sahibi bir hayvan dostudur. Hiçbir hayvan dostu hayvan öldürmez, Jack veya Curiosity, Tuna isimli bir kediyi öldürdü. Curiosity kediyi öldürdü mü? • Bunlar aşağıdaki gibi temsil edilebilir : A. (x) Köpek(x) ^ Sahiptir(Jack,x) B. (x) ((y) Köpek(y) ^ Sahiptir(x, y)) => HayvanDostu(x) C. (x) HayvanDostu(x) => (y) Hayvan(y) => ~Öldürür(x,y) D. Öldürür(Jack,Tuna) v Öldürür(Curiosity,Tuna) E. Kedi(Tuna) F. (x) Kedi(x) => Hayvan(x) Q. Öldürür(Curiosity, Tuna)

Clause forma dönüştür A1. Köpek(D)) /* D bir skolem sabitidir */ A2. (Sahiptir(Jack,D)) B. (~Köpek(y), ~Sahiptir(x, y), HayvanDostu(x)) C. (~ HayvanDostu(x), ~Hayvan(y), ~Öldürür(x,y)) D. (Öldürür(Jack,Tuna), Öldürür(Curiosity,Tuna)) E. Kedi(Tuna) F. (~Kedi(x), Hayvan(x)) • Sorgunun olumsuzunu ekle: Q: (~Öldürür(Curiosity, Tuna))

Çözümleme çürütme ispatı R1: Q, D, {}, (Öldürür(Jack, Tuna)) R2: R1, C, {x/Jack, y/Tuna}, (~HayvanDostu(Jack), ~Hayvan(Tuna)) R3: R2, B, {x/Jack}, (~Dog(y), ~Sahiptir(Jack, y), ~Hayvan(Tuna)) R4: R3, A1, {y/D}, (~Sahiptir(Jack, D), ~Hayvan(Tuna)) R5: R4, A2, {}, (~Hayvan(Tuna)) R6: R5, F, {x/Tuna}, (~Kedi(Tuna)) R7: R6, E, {} ()

Horn Clauselar • Bir Horn clause en fazla bir pozitif literalli clause’dur : (~P1(x), ~P2(x), ..., ~Pn(x) v Q(x)), şuna eşittir x P1(x) ^ P2(x) ... ^ Pn(x) => Q(x) ya da Q(x) <= P1(x), P2(x), ... , Pn(x) (prolog formatında) • Eğer hiç negatif literal yoksa (mesela, Q(a) <=): gerçekler • Eğer hiç pozitif literal yoksa (<= P1(x), P2(x), ... , Pn(x)): sorgu • Eğer hiç literal yoksa (<=): null clause • Çoğu bilgi Horn clauselarla temsil edilebilir • Anlaşılması daha basittir (uzantı formunu korur) • İşlemi FOL’dan daha basittir • Horn clauses FOL’da temsil edilebilir cümleler kümesinin bir alt kümesini temsil eder (örneğin, kesin olmayan sonuçları temsil edemez mesela, Q(x) v R(x) <= P(x)).

Prolog • Horn clause’lara bağlı bir lojik programlama dili

İleri zincirleme (Forward chaining) • Başlangıç verileri, kabullenmeler (Kural bütününün EĞER kısmı) sonuca ulaşıncaya kadar devam ettirilir. Örneğin bir tıbbi teşhiste hastası hakkında hiçbir fikre sahip olmayan doktor daha önceden tutulmuş raporlara bakarak veya birtakım bilgileri kendisi edinmeye çalışarak teşhis koyma aşamasına ulaşmaya çalışacaktır. İleri doğru zincir yapısı başlangıçta tanımın eksiksiz yapılması durumunda kullanılır • İspat yeni gerçek P(a) <=ile başlar (sık sık duruma özel veri) • Bunu Q(x) <= P(x)kuralıyla türetilmiş yeni gerçeğe çöz Q(a) <= • Daha sonra ilave Q(a) <= vb ile çıkarsamalar başlar. İşlem, amaçlanan teorem ispatı (eğer varsa ) üretildiğinde ya da yeni cümle üretilemediğinde sona erer. • Uzantı (Implication) kuralları daima modus ponens şeklinde kullanılır (öncüllerden (terim)sonuçlara), mesela, implication oku yönünde • Gerçekten hedefe doğru ileri zincirleme çıkarsama prosedürüdür (veri sürmeli).

B F A C D J E G H Örnek: İleri Zincirleme • R1: If A then B • R2: If B and C then D • R3: If B and E then F • R4: If D then G • R5: If F then G • R6: If G and H then I • R7: If G then J or and I

F C D J G Örnek: İleri Zincirleme A WM: A E H E  B H  I

F C D J G Örnek: İleri Zincirleme WM: A E H • R1: If A then B • R2: If B and C then D • R3: If B and E then F • R4: If D then G • R5: If F then G • R6: If G and H then I • R7: If G then J A  E  B  H  WM: A E H B B’yi WM’ye ekle I

C D J G Örnek: İleri Zincirleme WM: A E H B • R1: If A then B • R2: If B and C then D • R3: If B and E then F • R4: If D then G • R5: If F then G • R6: If G and H then I • R7: If G then J A E B  F  H  F’yi WM’ye ekle WM: A E H BF I

C D J Örnek: İleri Zincirleme WM: A E H B F • R1: If A then B • R2: If B and C then D • R3: If B and E then F • R4: If D then G • R5: If F then G • R6: If G and H then I • R7: If G then J A E  B F  G  H  G’yi WM’ye ekle WM: A E H BFG I

C D J Örnek: İleri Zincirleme WM: A E H BF G • R1: If A then B • R2: If B and C then D • R3: If B and E then F • R4: If D then G • R5: If F then G • R6: If G and H then I • R7: If G then J A E  B F G  H I’yı WM’ye ekle WM: A E H BFGI I 

C D Örnek: İleri Zincirleme WM: A E H BF G I • R1: If A then B • R2: If B and C then D • R3: If B and E then F • R4: If D then G • R5: If F then G • R6: If G and H then I • R7: If G then J A E  B F G  H  J’yi WM’ye ekle WM: A E H BFGI J J  I

J G Çatışma kümesi WM: B C E H A • R1: If A then B • R2: If B and C then D • R3: If B and E then F • R4: If D then G • R5: If F then G • R6: If G and H then I • R7: If G then J E B C D F H  I

Çatışma çözümlemesi • Hani kuralı çıkarma: • Kurallara ağırlık ilave et ve en yüksek ağırlıklı kuralı seç. • Her gerçeğe ağırlık ata ve en yüksek ağırlıklı gerçeğe uyan kuralı seç. • Gerçekleri WM’de (working memory) kalma sürelerine göre sırala ve en sonkini seç. • En fazla gerçeğe ihtiyaç duyan kuralları seç..

YAPAY ZEKA ve UZMAN SİSTEMLER