TUGAS

WORKSHOP KECERDASAN BUATAN

JOBSHEET 3
SISTEM PAKAR

Disusun Untuk Memenuhi Tugas

Matakuliah Praktikum Workshop Kecerdasan Buatan

Dosen Pengajar: Ahmad Wilda Y, S.T, M.T

Disusun oleh:

Kelompok 5
Kelas 3D-JTD

Marcelino Dwantara A 13
Muhammad Affifansyah 14
Muhammad Fabian Abigail 15

PROGRAM STUDI JARINGAN TELEKOMUNIKASI

DIGITAL JURUSAN TEKNIK ELEKTRO
POLITEKNIK NEGERI MALANG
2021

1
 JOBSHEET 3

SISTEM PAKAR : Forward Chaining dan Backward Chaining

Tujuan

Setelah mengikuti Lab ini diharapkan mahasiswa mampu:

 Memahami konsep knowledge base inference engine

 Implementasi sederhana konsep mesin inferensi backward dan forward chaining
menggunakan bahasa python

Ringkasan Materi
1. SISTEM PAKAR
Sistem pakar adalah aplikasi yang mampu memberikan pengetahuan dan pengalaman
seorang pakar manusia. Sistem pakar dirancang untuk memberikan jawaban yang masuk akal
ketika diberikan serangkaian kondisi tentang masalah yang dihadapi. Misalnya, seorang
insinyur desain mungkin ahli dalam merancang suku cadang mobil menggunakan CAD -
mereka tahu kemampuan bahan yang tersedia dan alternatifnya.
Sistem pakar diimplementasikan sebagai program komputer yang menggunakan
teknologi kecerdasan buatan (AI) untuk mensimulasikan penilaian dan perilaku manusia atau
organisasi yang memiliki pengetahuan dan pengalaman ahli di bidang tertentu. Sebuah
program komputer berisi basis pengetahuan dan seperangkat algoritma atau aturan yang
menyimpulkan fakta baru dari pengetahuan dan dari data yang masuk. Dalam
penyusunannya, sistem pakar mengkombinasikan kaidah-kaidah penarikan kesimpulan atau
inference rules dengan basis pengetahuan tertentu yang diberikan oleh satu atau lebih pakar
dalam bidang tertentu. Kombinasi dari kedua hal tersebut disimpan dalam komputer, yang
selanjutnya digunakan dalam proses pengambilan keputusan untuk penyelesaian masalah
tertentu.
Sistem pakar merupakan sistem yang berusaha mengadopsi pengetahuan manusia ke
komputer yang dirancang untuk memodelkan kemampuan menyelesaikan masalah seperti
layaknya seorang pakar. Derajat pemecahan masalah didasarkan pada kualitas data dan

2
aturan yang diperoleh dari pakar manusia. Sistem pakar dirancang untuk bekerja pada tingkat
pakar manusia. Sistem Pakar terdiri dari tiga bagian: basis pengetahuan, mesin inferensi,
antarmuka pengguna. Basis pengetahuan terdiri dari fakta dan aturan. Mesin inferensi dapat
menggunakan pohon keputusan atau sistem heuristik yang lebih maju yang dapat menangani
ketidakpastian. Antarmuka pengguna bisa berbasis menu atau mungkin antarmuka bahasa
alami yang lebih maju.
Chaining:
Chaining adalah pembelajaran dari serangkaian perilaku tindakan kompleks yang
lengkap. Setiap tautan dalam rantai berfungsi sebagai isyarat untuk respons berikutnya dalam
rantai.
Aplikasi Sistem Pakar:
A. Klasifikasi - mengidentifikasi objek berdasarkan karakteristik yang dinyatakan
B. Sistem Diagnosis - menyimpulkan malfungsi atau penyakit dari data yang dapat
diamati
C. Pemantauan - membandingkan data dari sistem yang terus diamati untuk
menentukan perilaku
D. Kontrol Proses - mengontrol proses fisik berdasarkan pemantauan
1.1. Rules (Aturan-aturan)
Rule adalah aturan-aturan yang mengkombinasikan fakta. Umumnya dituliskan dalam
bentuk logika preposisi maupun dalam format jika-maka.

AB # jika A maka B

Rule di atas, menjelaskan bahwa jika A benar maka B benar. A dan B adalah suatu predikat
yang bisa bernilai benar atau salah. Kecuali fakta awal atau initial fact, yang pasti bernilai
benar. Atau fakta yang menjadi hasil deduksi dari suatu rule, juga akan bernilai benar.
Misalkan;
A: mamalia(kucing) # kucing adalah mamalia
B: hewan(kucing) # kucing adalah hewan
Maka, rule di atas akan berbunyi jika kucing adalah mamalia maka kucing adalah hewan.
Sehingga, dikenal tabel kebenaran sebagai berikut.

3
 Gambar 1 Tabel Kebenaran

1.2. Forward Chaining

Forward Chaining adalah metode pencarian / penarikan kesimpulan yang berdasarkan pada
data atau fakta yang ada menuju ke kesimpulan, penelusuran dimulai dari fakta yang ada
lalu bergerak maju melalui premis-premis untuk menuju ke kesimpulan / bottom up
reasoning.
1.3. Implementasi Sederhana Forward Chaining
Misakan kita memiliki rule sebagai berikut:
mammal(A) ==> vertebrate(A) Jika A mamalia, maka A vertebrata
vertebrate(A) ==> animal(A). Jika A vertebrata, maka A hewan
vertebrate(A) & flying(A) ==> bird(A). Jika A vertebrata dan A terbang maka burung

Dengan fakta sebagai berikut:

vertebrate("duck"). Bebek adalah vertebrata
flying("duck"). Bebek adalah terbang
mammal("cat"). Kucing adalah mamalia

Dalam kode program, fakta di atas dapat ditulis:

facts = [["vertebrate","duck"],["flying","duck"],["mammal","cat"]]

Sedangkan rule di atas dapat direpresentasikan secara sederhana menggunakan if-else

4
for A1 in facts:
if A1[0] == "mammal":
assert_fact(["vertebrate",A1[1]])
if A1[0] == "vertebrate":
assert_fact(["animal",A1[1]])
if A1[0] == "vertebrate" and ["flying",A1[1]] in facts:
assert_fact(["bird",A1[1]])

Program rule di atas akan melakukan menambahkan fakta hasil inferensi ke dalam daftar
fakta. Maka list fakta menjadi

[['vertebrate', 'duck'], ['flying', 'duck'], ['mammal', 'cat'], ['animal', 'duck'], ['bird', 'duck'],
['vertebrate', 'cat'], ['animal', 'cat']]

Terdapat tambahan ke dalam list fakta hasil inferensi rule :

['animal', 'duck'], ['bird', 'duck'], ['vertebrate', 'cat'], ['animal',
'cat']]

Listing kode program selengkapnya adalah sebagai berikut:

global facts
global is_changed

is_changed = True
facts = [["vertebrate","duck"],["flying","duck"],["mammal","cat"]]

def assert_fact(fact):
global facts
global is_changed
if not fact in facts:
facts += [fact]
is_changed = True

while is_changed:

5
 is_changed = False
for A1 in facts:
if A1[0] == "mammal":
assert_fact(["vertebrate",A1[1]])
if A1[0] == "vertebrate":
assert_fact(["animal",A1[1]])
if A1[0] == "vertebrate" and ["flying",A1[1]] in facts:
assert_fact(["bird",A1[1]])

print(facts)

1.4. Backward Chaining

Backward chaining adalah salah metode inferensi yang bekerja dari goal terlebih dahulu
kemudian mundur mengikuti rule yang diperlukan. Biasanya digunakan dalam pembuktian
teorema otomatis, mesin inferensi, membantu pembuktian kebenaran, serta aplikasi
kecerdasan buatan lainnya.
Backward chaining dimulai dari goal atau hipotesis kemudian mundur dari konsekuensi
kepada anteseden untuk melihat apakah ada data yang mendukung konsekuensi tersebut.
Mesin inferensi backward chaining membangkitkan rule-rule inferensi hingga menemukan
rule yang memiliki konsekuensi sesuai dengan goal yang diinginkan. Jika anteseden dari
aturan itu diketahui benar maka akan ditambahkan ke daftar goal.
.
1.5. Implementasi Sederhana Backward Chaining
Misakan kita memiliki rule sebagai berikut

6
Algoritma backward chaining biasa juga diistilahkan dengan algoritma FOL-BC-Ask.

1.6. Implementasi Backward Chaining

Input
Input program adalah sebuah file. Baris pertama merupakan jumlah query(n). Selanjutnya
diikuti oleh query, dimana satu query perbaris. Setiap query tersebut nantinya akan
ditentukan apakah query tersebut dapat dibuktikan dari knowledge base atau tidak.
Baris selanjutnya adalah jumlah klausa yang akan dimasukkan ke dalam knowledge base (m).
Dibawahnya kemudian diikuti sebanyak m baris klausa yang akan menjadi knowledge base.
Klausa tersebut ada dua tipe:
(1) first order logic, contoh: A(x,y) => B(x,y)

7
 (2) atomic, contoh: I(Amy)
contoh input:
input.txt
1
B(John,Bob)
13
A(x,y) => B(x,y)
G(x,y) => B(x,y)
C(c,d) => A(c,d)
B(x,y) => G(x,y)
F(y) => G(x,y)
G(x,y) ^ F(y) => H(x,y)
I(z) => F(z)
F(z) => I(z)
C(Jie,Joe)
C(Melissa,Mary)
G(John,Bob)
I(Amy)
F(Bob)

Kode program
Kode program main dimulai dari pembacaan input file yang sesuai dengan format di atas.
Kemudian diambil query dengan menghilangkan karakter spasi. Selanjutnya knowledge base
diambil dan dirubah sesuai standar yang ditentukan.
fn="input.txt"
queries = []
knowledge_base = []
f1=open(fn, "r")
input = f1.readlines()
input = [x.strip() for x in input]

for i in range(1, int(input[0]) + 1):

8
 queries.append(input[i].replace(" ", ""))
for i in range(int(input[0]) + 2, int(input[int(input[0]) + 1]) +
int(input[0]) + 2):
knowledge_base.append(input[i].replace(" ", ""))
knowledge_base = standardize_variables(knowledge_base)

kb = {}
list_of_predicates = []
add_to_kb(knowledge_base)

fileOut = open("output.txt", "w")

for query in queries:
result = fol_bc_ask(query, {})
if result != None:
print("True", result)
fileOut.write("TRUE" + "\n")
else:
print("False", result)
fileOut.write("FALSE" + "\n")

fileOut.close()
f1.close

Standarisasi variable knowledge base dilakukan dengan method berikut.

def standardize_variables(knowledge_base):
label = 0
result_knowledge_base = []
for rule in knowledge_base:
variable_names = {}
lhs = rule.partition('=>')[0]
rhs = rule.partition('=>')[2]
premise = []
for x in lhs.split('^'):
premise.append(x)
result_premise = ""
for term in premise:
args = []
result_term = "" + term.partition('(')[0]

9
 temp = term.partition('(')[-1].rpartition(')')[0]
result_item = ""
for item in temp.split(','):
args.append(item)
if variable(item):
if item not in variable_names:
variable_names[item] = "x" + repr(label)
item = "x" + repr(label)
label = label + 1
else:
item = variable_names[item]
result_item = result_item + item + ","
result_item = result_item[:len(result_item) - 1]
result_term = result_term + '(' + result_item + ')' + '^'
result_premise = result_premise + result_term
result_premise = result_premise[:len(result_premise) - 1]

conclusion = []
for x in rhs.split('^'):
conclusion.append(x)
if conclusion != ['']:
result_premise = result_premise + "=>"
for term in conclusion:
args = []
result_term = "" + term.partition('(')[0]
temp = term.partition('(')[-1].rpartition(')')[0]
result_item = ""
for item in temp.split(','):
args.append(item)
if variable(item):
if item not in variable_names:
variable_names[item] = "x" + repr(label)
item = "x" + repr(label)
label = label + 1
else:
item = variable_names[item]
result_item = result_item + item + ","
result_item = result_item[:len(result_item) - 1]

10
 result_term = result_term + '(' + result_item + ')' + '^'
result_premise = result_premise + result_term
result_premise = result_premise[:len(result_premise) - 1]

result_knowledge_base.append(result_premise)
return result_knowledge_base

Proses penambahan knowledge base, dilakukan pemisahan antara premis dan konklusinya
def add_to_kb(knowledge_base):
global kb
global list_of_predicates

for sentence in knowledge_base:

if '=>' not in sentence:
predicate = sentence.partition('(')[0]
if predicate not in list_of_predicates:
conc = []
prem = []
conc.append("=>" + sentence)
kb[predicate] = {'conc': conc, 'prem': prem}
list_of_predicates.append(predicate)
else:
conc = kb[predicate]['conc']
prem = kb[predicate]['prem']
conc.append("=>" + sentence)
kb[predicate] = {'conc': conc, 'prem': prem}
else:
clauses = sentence.partition('=>')
list_of_premises = clauses[0].split('^')
conclusion = clauses[2]

# for conclusion
predicate = conclusion.partition('(')[0]
if predicate not in list_of_predicates:
conc = []
prem = []
conc.append(sentence)
kb[predicate] = {'conc': conc, 'prem': prem}

11
 list_of_predicates.append(predicate)
else:
conc = kb[predicate]['conc']
prem = kb[predicate]['prem']
conc.append(sentence)
kb[predicate] = {'conc': conc, 'prem': prem}

# for list_of_premises
for premise in list_of_premises:
predicate = premise.partition('(')[0]
if predicate not in list_of_predicates:
conc = []
prem = []
prem.append(sentence)
kb[predicate] = {'conc': conc, 'prem': prem}
list_of_predicates.append(predicate)
else:
conc = kb[predicate]['conc']
prem = kb[predicate]['prem']
prem.append(sentence)
kb[predicate] = {'conc': conc, 'prem': prem}

Algoritma backward chaining biasa juga diistilahkan dengan algoritma FOL-BC-Ask (fists order
logic – backward chaining - ask
def fol_bc_ask(query, theta):
global kb
global list_of_predicates
global list_of_explored_rules

print("Backward Chaining")
list_of_rules = fetch_rules(query)
for rule in list_of_rules:
print("taken RULE", rule)
list_of_explored_rules = []
list_of_explored_rules.append(query)
print("\t",query, "added to list_of_explored_rules")
lhs = rule.partition('=>')[0]

12
 rhs = rule.partition('=>')[2]
print("lhs: ", lhs, " rhs: ", rhs)
print("theta in rule", theta)
theta1 = unify(rhs, query, theta)
if theta1 != None:
list_of_premises = lhs.split('^')
print("list_of_premises: ", list_of_premises)
theta2 = fol_bc_and(theta1, list_of_premises)
if theta2 != None:
return theta2

print("None of the rules worked out", query)

return None

Output
Jika berjalan normal, output program akan menampilkan TRUE.

Listing Kode program lengkap Backward Chaining

from copy import deepcopy

kb = {}
list_of_predicates = []
list_of_explored_rules = []

def fetch_rules(goal):
global kb
global list_of_predicates

print("fetch_rules for goal:- ", goal)

list_of_rules = []
predicate = goal.partition('(')[0]
print("\t", predicate, kb[predicate]['conc'])
list_of_rules = list_of_rules + kb[predicate]['conc']
return list_of_rules

def subst(theta, first):

13
 print("\tsubst: ", theta, first)
predicate = first.partition('(')[0]
list = (first.partition('(')[-1].rpartition(')')[0]).split(',')
print("\t", list)
for i in range(len(list)):
if variable(list[i]):
if list[i] in theta:
list[i] = theta[list[i]]
print("\t", predicate + '(' + ','.join(list) + ')')
return predicate + '(' + ','.join(list) + ')'

def variable(x):
if not isinstance(x, str):
return False
else:
if x.islower():
return True
else:
return False

def compound(x):
if not isinstance(x, str):
return False
else:
if '(' in x and ')' in x:
return True
else:
return False

def list(x):
if not isinstance(x, str):
return True
else:
return False

14
def unify_var(var, x, theta):
print("IN unify_var", var, x, theta)
if var in theta:
print("var in theta", var, theta)
return unify(theta[var], x, theta)
elif x in theta:
print("x in theta", x, theta)
return unify(var, theta[x], theta)
else:
theta[var] = x
print("not in theta", theta[var])
return theta

def check_theta(theta):
for entry in theta:
if variable(theta[entry]):
if theta[entry] in theta:
print("in check_theta. theta changed")
theta[entry] = theta[theta[entry]]
return theta

def unify(x, y, theta):

print("\tunify", x, y, theta)
if theta == None:
print("\tin theta is None")
return None
elif x == y:
print("\tin x=y")
return check_theta(theta)
elif variable(x) is True:
print("\tin variable(x)")
return unify_var(x, y, theta)
elif variable(y) is True:
print("\tin variable(y)")
return unify_var(y, x, theta)

15
 elif compound(x) and compound(y):
print("\tin compound")
x_args = []
temp = x.partition('(')[-1].rpartition(')')[0]
for item in temp.split(','):
x_args.append(item)
y_args = []
temp = y.partition('(')[-1].rpartition(')')[0]
for item in temp.split(','):
y_args.append(item)
x_op = x.partition('(')[0]
y_op = y.partition('(')[0]
return unify(x_args, y_args, unify(x_op, y_op, theta))
elif list(x) and list(y):
print("\tin list")
return unify(x[1:], y[1:], unify(x[0], y[0], theta))
else:
print("\tin else")
return None

def fol_bc_ask(query, theta):

global kb
global list_of_predicates
global list_of_explored_rules

print("Backward Chaining")
list_of_rules = fetch_rules(query)
for rule in list_of_rules:
print("taken RULE", rule)
list_of_explored_rules = []
list_of_explored_rules.append(query)
print("\t",query, "added to list_of_explored_rules")
lhs = rule.partition('=>')[0]
rhs = rule.partition('=>')[2]
print("lhs: ", lhs, " rhs: ", rhs)
print("theta in rule", theta)
theta1 = unify(rhs, query, theta)

16
 if theta1 != None:
list_of_premises = lhs.split('^')
print("list_of_premises: ", list_of_premises)
theta2 = fol_bc_and(theta1, list_of_premises)
if theta2 != None:
return theta2

print("None of the rules worked out", query)

return None

def fol_bc_and(theta, list_of_premises):

global kb
global list_of_predicates

print("\tand: ", list_of_premises)

print("\ttheta: ", theta)
if theta == None:
return None
else:
if list_of_premises != []:
temp_list = []
for each_premise in list_of_premises:
temp = subst(theta, each_premise)
temp_list.append(temp)
list_of_premises = temp_list
first_premise = list_of_premises[0]
rest_premise = list_of_premises[1:]
subs = list_of_premises[0]
if subs != '()':
if subs in list_of_explored_rules:
print(subs, " already in list_of_explored_rules")
return None
else:
print(subs, " added to list_of_explored_rules")
list_of_explored_rules.append(subs)
theta = fol_bc_or_sub(subs, {}, rest_premise)
else:
return theta

17
 return theta

def fol_bc_or_sub(query, theta, rest):

global kb
global list_of_predicates

print("\tOR sub")
list_of_rules = fetch_rules(query)
print("\tLIST_OF_RULES", list_of_rules)
for rule in list_of_rules:
print("\tRULE", rule)
lhs = rule.partition('=>')[0]
rhs = rule.partition('=>')[2]
print("\n\tlhs: ", lhs, " rhs: ", rhs)
print("\ntheta in rule", theta)
theta1 = unify(rhs, query, deepcopy(theta))
if theta1 != None:
list_of_premises = lhs.split('^')
print("\tlist_of_premises: ", list_of_premises)
theta2 = fol_bc_and(theta1, list_of_premises)
theta3 = fol_bc_and(theta2, rest)
if theta3 != None:
return theta3

print("\tNone of the rules worked out", query)

return None

def add_to_kb(knowledge_base):
global kb
global list_of_predicates

for sentence in knowledge_base:

if '=>' not in sentence:
predicate = sentence.partition('(')[0]
if predicate not in list_of_predicates:
conc = []

18
 prem = []
conc.append("=>" + sentence)
kb[predicate] = {'conc': conc, 'prem': prem}
list_of_predicates.append(predicate)
else:
conc = kb[predicate]['conc']
prem = kb[predicate]['prem']
conc.append("=>" + sentence)
kb[predicate] = {'conc': conc, 'prem': prem}
else:
clauses = sentence.partition('=>')
list_of_premises = clauses[0].split('^')
conclusion = clauses[2]

# for conclusion
predicate = conclusion.partition('(')[0]
if predicate not in list_of_predicates:
conc = []
prem = []
conc.append(sentence)
kb[predicate] = {'conc': conc, 'prem': prem}
list_of_predicates.append(predicate)
else:
conc = kb[predicate]['conc']
prem = kb[predicate]['prem']
conc.append(sentence)
kb[predicate] = {'conc': conc, 'prem': prem}

# for list_of_premises
for premise in list_of_premises:
predicate = premise.partition('(')[0]
if predicate not in list_of_predicates:
conc = []
prem = []
prem.append(sentence)
kb[predicate] = {'conc': conc, 'prem': prem}
list_of_predicates.append(predicate)
else:

19
 conc = kb[predicate]['conc']
prem = kb[predicate]['prem']
prem.append(sentence)
kb[predicate] = {'conc': conc, 'prem': prem}

def variable(x):
if not isinstance(x, str):
return False
else:
if x.islower():
return True
else:
return False

def standardize_variables(knowledge_base):
label = 0
result_knowledge_base = []
for rule in knowledge_base:
variable_names = {}
lhs = rule.partition('=>')[0]
rhs = rule.partition('=>')[2]
premise = []
for x in lhs.split('^'):
premise.append(x)
result_premise = ""
for term in premise:
args = []
result_term = "" + term.partition('(')[0]
temp = term.partition('(')[-1].rpartition(')')[0]
result_item = ""
for item in temp.split(','):
args.append(item)
if variable(item):
if item not in variable_names:
variable_names[item] = "x" + repr(label)
item = "x" + repr(label)
label = label + 1

20
 else:
item = variable_names[item]
result_item = result_item + item + ","
result_item = result_item[:len(result_item) - 1]
result_term = result_term + '(' + result_item + ')' + '^'
result_premise = result_premise + result_term
result_premise = result_premise[:len(result_premise) - 1]

conclusion = []
for x in rhs.split('^'):
conclusion.append(x)
if conclusion != ['']:
result_premise = result_premise + "=>"
for term in conclusion:
args = []
result_term = "" + term.partition('(')[0]
temp = term.partition('(')[-1].rpartition(')')[0]
result_item = ""
for item in temp.split(','):
args.append(item)
if variable(item):
if item not in variable_names:
variable_names[item] = "x" + repr(label)
item = "x" + repr(label)
label = label + 1
else:
item = variable_names[item]
result_item = result_item + item + ","
result_item = result_item[:len(result_item) - 1]
result_term = result_term + '(' + result_item + ')' + '^'
result_premise = result_premise + result_term
result_premise = result_premise[:len(result_premise) - 1]

result_knowledge_base.append(result_premise)
return result_knowledge_base

#Main

21
fn="input.txt"
queries = []
knowledge_base = []
f1=open(fn, "r")
input = f1.readlines()
input = [x.strip() for x in input]

for i in range(1, int(input[0]) + 1):

queries.append(input[i].replace(" ", ""))
for i in range(int(input[0]) + 2, int(input[int(input[0]) + 1]) +
int(input[0]) + 2):
knowledge_base.append(input[i].replace(" ", ""))
knowledge_base = standardize_variables(knowledge_base)

kb = {}
list_of_predicates = []
add_to_kb(knowledge_base)

fileOut = open("output.txt", "w")

for query in queries:
result = fol_bc_ask(query, {})
if result != None:
print("True", result)
fileOut.write("TRUE" + "\n")
else:
print("False", result)
fileOut.write("FALSE" + "\n")

fileOut.close()
f1.close

4. RINGKASAN
1. Sistem pakar adalah alat kecerdasan buatan (AI) yang merekam keahlian para pakar dan
memberikan saran kepada (biasanya) non-ahli dalam domain tertentu.
2. Sistem pakar, program komputer yang menggunakan metode kecerdasan buatan untuk
memecahkan masalah dalam domain khusus yang biasanya umumnya keahlian manusia.

22
3. Forward chaining adalah strategi implementasi yang populer untuk sistem pakar, bisnis,
dan sistem aturan produksi.
4. Backward chaining adalah algoritma yang bekerja mundur dari tujuan, chaining melalui
aturan untuk menemukan fakta yang diketahui yang mendukung bukti.

PRAKTIKUM
1. Tulisan kode program diatas menggunakan python
a. Forward Chaining
b. Backward Chaining
2. Tambahkan parameter waktu
3. Berikanlah penjelasan melalui komentar pada listing program tersebut
JAWABAN
1. A. Forward Chaining
global facts
global is_changed

is_changed = True
facts = [["vertebrate","duck"],
["flying","duck"],
["mammal","cat"]
]

def assert_fact(fact):
global facts
global is_changed
if not fact in facts:
facts += [fact]
is_changed = True

while is_changed:
is_changed = False
for A1 in facts:
print("A1[0] ", A1[0])
if A1[0] == "mammal":

23
 assert_fact(["vertebrate", A1[1]])
if A1[0] == "vertebrate":
assert_fact(["animal", A1[1]])
if A1[0] == "vertebrate" and ["flying", A1[1]] in facts:
assert_fact(["bird", A1[1]])

print(facts)
Output Program :
A. Jika pengecekan [‘animal’, ‘cat’]

B. Jika pengecekan [‘Bird’, ‘cat’]

B. Dijawab minggu depan

from copy import deepcopy

# deklarasi Variabel untuk knowledge Base

kb = {}
# deklarasi Pembuatan list dari predikat yang berupa array
list_of_predicates = []
# deklarasi Pembuatan lis rule yang berupa array
list_of_explored_rules = []

# definisi fungsi untuk penerapan tujuan pada rules => goal

def fetch_rules(goal):
# Deklarasi kb dan list predikat secara global pada fungsi fetch_rules
# sehingga variabel ini dapat digunakan di blok program manapun pada fungsi fetch_rules
global kb

24
 global list_of_predicates

# Printing goal dari pencarian

print("fetch_rules for goal:- ", goal)
# pembuatan list rule berupa array
list_of_rules = []
predicate = goal.partition('(')[0]
print("\t", predicate, kb[predicate]['conc'])
list_of_rules = list_of_rules + kb[predicate]['conc']
return list_of_rules

def subst(theta, first):

print("\tsubst: ", theta, first)
predicate = first.partition('(')[0]
list = (first.partition('(')[-1].rpartition(')')[0]).split(',')
print("\t", list)
for i in range(len(list)):
if variable(list[i]):
if list[i] in theta:
list[i] = theta[list[i]]
print("\t", predicate + '(' + ','.join(list) + ')')
return predicate + '(' + ','.join(list) + ')'

def variable(x):
if not isinstance(x, str):
return False
else:
if x.islower():
return True
else:
return False

25
def compound(x):
if not isinstance(x, str):
return False
else:
if '(' in x and ')' in x:
return True
else:
return False

def list(x):
if not isinstance(x, str):
return True
else:
return False

def unify_var(var, x, theta):

print("IN unify_var", var, x, theta)
if var in theta:
print("var in theta", var, theta)
return unify(theta[var], x, theta)
elif x in theta:
print("x in theta", x, theta)
return unify(var, theta[x], theta)
else:
theta[var] = x
print("not in theta", theta[var])
return theta

def check_theta(theta):
for entry in theta:
if variable(theta[entry]):
if theta[entry] in theta:
print("in check_theta. theta changed")
theta[entry] = theta[theta[entry]]
26
 return theta

def unify(x, y, theta):

print("\tunify", x, y, theta)
if theta == None:
print("\tin theta is None")
return None
elif x == y:
print("\tin x=y")
return check_theta(theta)
elif variable(x) is True:
print("\tin variable(x)")
return unify_var(x, y, theta)
elif variable(y) is True:
print("\tin variable(y)")
return unify_var(y, x, theta)
elif compound(x) and compound(y):
print("\tin compound")
x_args = []
temp = x.partition('(')[-1].rpartition(')')[0]
for item in temp.split(','):
x_args.append(item)
y_args = []
temp = y.partition('(')[-1].rpartition(')')[0]
for item in temp.split(','):
y_args.append(item)
x_op = x.partition('(')[0]
y_op = y.partition('(')[0]
return unify(x_args, y_args, unify(x_op, y_op, theta))
elif list(x) and list(y):
print("\tin list")
return unify(x[1:], y[1:], unify(x[0], y[0], theta))
else:
print("\tin else")
return None
27
#
def fol_bc_ask(query, theta):
# Pendeklerasian secara global dari kb, variabel list dari predikat-predikat
# dan list dari rule, agar dapat di gunakan dimanapun
global kb
global list_of_predicates
global list_of_explored_rules

# Printing tulisan "Backward Chaining"

print("Backward Chaining")
# Pembuatan rules berdasarkan rules yang sudah ada
# dimana rules berada pada file yang berbeda yaitu "input.txt"
# dan menjadi 1 file dengan tujuan
list_of_rules = fetch_rules(query)
# Dilakukan pengecekan apakah rule yang diterapkan pada tujuan
# apakah terdapat pada rules
for rule in list_of_rules:
print("taken RULE", rule)
list_of_explored_rules = []
list_of_explored_rules.append(query)
print("\t", query, "added to list_of_explored_rules")
lhs = rule.partition('=>')[0]
rhs = rule.partition('=>')[2]
print("lhs: ", lhs, " rhs: ", rhs)
print("theta in rule", theta)
theta1 = unify(rhs, query, theta)
if theta1 != None:
list_of_premises = lhs.split('^')
print("list_of_premises: ", list_of_premises)
theta2 = fol_bc_and(theta1, list_of_premises)
if theta2 != None:
return theta2

print("None of the rules worked out", query)

28
 return None

def fol_bc_and(theta, list_of_premises):

global kb
global list_of_predicates

print("\tand: ", list_of_premises)

print("\ttheta: ", theta)
if theta == None:
return None
else:
if list_of_premises != []:
temp_list = []
for each_premise in list_of_premises:
temp = subst(theta, each_premise)
temp_list.append(temp)
list_of_premises = temp_list
first_premise = list_of_premises[0]
rest_premise = list_of_premises[1:]
subs = list_of_premises[0]
if subs != '()':
if subs in list_of_explored_rules:
print(subs, " already in list_of_explored_rules")
return None
else:
print(subs, " added to list_of_explored_rules")
list_of_explored_rules.append(subs)
theta = fol_bc_or_sub(subs, {}, rest_premise)
else:
return theta
return theta

def fol_bc_or_sub(query, theta, rest) -> object:

global kb
29
 global list_of_predicates

print("\tOR sub")
list_of_rules = fetch_rules(query)
print("\tLIST_OF_RULES", list_of_rules)
for rule in list_of_rules:
print("\tRULE", rule)
lhs = rule.partition('=>')[0]
rhs = rule.partition('=>')[2]
print("\n\tlhs: ", lhs, " rhs: ", rhs)
print("\ntheta in rule", theta)
theta1 = unify(rhs, query, deepcopy(theta))
if theta1 != None:
list_of_premises = lhs.split('^')
print("\tlist_of_premises: ", list_of_premises)
theta2 = fol_bc_and(theta1, list_of_premises)
theta3 = fol_bc_and(theta2, rest)
if theta3 != None:
return theta3

print("\tNone of the rules worked out", query)

return None

def add_to_kb(knowledge_base):
global kb
global list_of_predicates

for sentence in knowledge_base:

if '=>' not in sentence:
predicate = sentence.partition('(')[0]
if predicate not in list_of_predicates:
conc = []
prem = []
conc.append("=>" + sentence)
kb[predicate] = {'conc': conc, 'prem': prem}
30
 list_of_predicates.append(predicate)
else:
conc = kb[predicate]['conc']
prem = kb[predicate]['prem']
conc.append("=>" + sentence)
kb[predicate] = {'conc': conc, 'prem': prem}
else:
clauses = sentence.partition('=>')
list_of_premises = clauses[0].split('^')
conclusion = clauses[2]

# for conclusion
predicate = conclusion.partition('(')[0]
if predicate not in list_of_predicates:
conc = []
prem = []
conc.append(sentence)
kb[predicate] = {'conc': conc, 'prem': prem}
list_of_predicates.append(predicate)
else:
conc = kb[predicate]['conc']
prem = kb[predicate]['prem']
conc.append(sentence)
kb[predicate] = {'conc': conc, 'prem': prem}

# for list_of_premises
for premise in list_of_premises:
predicate = premise.partition('(')[0]
if predicate not in list_of_predicates:
conc = []
prem = []
prem.append(sentence)
kb[predicate] = {'conc': conc, 'prem': prem}
list_of_predicates.append(predicate)
else:
31
 conc = kb[predicate]['conc']
prem = kb[predicate]['prem']
prem.append(sentence)
kb[predicate] = {'conc': conc, 'prem': prem}

def variable(x):
if not isinstance(x, str):
return False
else:
if x.islower():
return True
else:
return False

def standardize_variables(knowledge_base):
label = 0
result_knowledge_base = []
for rule in knowledge_base:
variable_names = {}
lhs = rule.partition('=>')[0]
rhs = rule.partition('=>')[2]
premise = []
for x in lhs.split('^'):
premise.append(x)
result_premise = ""
for term in premise:
args = []
result_term = "" + term.partition('(')[0]
temp = term.partition('(')[-1].rpartition(')')[0]
result_item = ""
for item in temp.split(','):
args.append(item)
if variable(item):
if item not in variable_names:
variable_names[item] = "x" + repr(label)
32
 item = "x" + repr(label)
label = label + 1
else:
item = variable_names[item]
result_item = result_item + item + ","
result_item = result_item[:len(result_item) - 1]
result_term = result_term + '(' + result_item + ')' + '^'
result_premise = result_premise + result_term
result_premise = result_premise[:len(result_premise) - 1]

conclusion = []
for x in rhs.split('^'):
conclusion.append(x)
if conclusion != ['']:
result_premise = result_premise + "=>"
for term in conclusion:
args = []
result_term = "" + term.partition('(')[0]
temp = term.partition('(')[-1].rpartition(')')[0]
result_item = ""
for item in temp.split(','):
args.append(item)
if variable(item):
if item not in variable_names:
variable_names[item] = "x" + repr(label)
item = "x" + repr(label)
label = label + 1
else:
item = variable_names[item]
result_item = result_item + item + ","
result_item = result_item[:len(result_item) - 1]
result_term = result_term + '(' + result_item + ')' + '^'
result_premise = result_premise + result_term
result_premise = result_premise[:len(result_premise) - 1]

33
 result_knowledge_base.append(result_premise)
return result_knowledge_base

# Main
fn = "input.txt"
queries = []
knowledge_base = []
f1 = open(fn, "r")
input = f1.readlines()
input = [x.strip() for x in input]

for i in range(1, int(input[0]) + 1):

queries.append(input[i].replace(" ", ""))
for i in range(int(input[0]) + 2, int(input[int(input[0]) + 1]) +
int(input[0]) + 2):
knowledge_base.append(input[i].replace(" ", ""))
knowledge_base = standardize_variables(knowledge_base)

kb = {}
list_of_predicates = []
add_to_kb(knowledge_base)

fileOut = open("output.txt", "w")

for query in queries:
result = fol_bc_ask(query, {})
if result != None:
print("True", result)
fileOut.write("TRUE" + "\n")
else:
print("False", result)
fileOut.write("FALSE" + "\n")

fileOut.close()
f1.close

34
 output program :

2. Backward Chaining
from copy import deepcopy

# deklarasi Variabel untuk knowledge Base

kb = {}
# deklarasi Pembuatan list dari predikat yang berupa array
list_of_predicates = []
# deklarasi Pembuatan lis rule yang berupa array
list_of_explored_rules = []

import timeit
awal_time = timeit.default_timer()
akhir_time = timeit.default_timer()
total = akhir_time-awal_time
print("Waktu Eksekusi Program :"+str( total) ," Detik "+ "\n")

# definisi fungsi untuk penerapan tujuan pada rules => goal

def fetch_rules(goal):
# Deklarasi kb dan list predikat secara global pada fungsi fetch_rules
# sehingga variabel ini dapat digunakan di blok program manapun pada fungsi fetch_rules
global kb
global list_of_predicates

# Printing goal dari pencarian

print("fetch_rules for goal:- ", goal)
# pembuatan list rule berupa array
list_of_rules = []
predicate = goal.partition('(')[0]
print("\t", predicate, kb[predicate]['conc'])

35
 list_of_rules = list_of_rules + kb[predicate]['conc']
return list_of_rules

def subst(theta, first):

print("\tsubst: ", theta, first)
predicate = first.partition('(')[0]
list = (first.partition('(')[-1].rpartition(')')[0]).split(',')
print("\t", list)
for i in range(len(list)):
if variable(list[i]):
if list[i] in theta:
list[i] = theta[list[i]]
print("\t", predicate + '(' + ','.join(list) + ')')
return predicate + '(' + ','.join(list) + ')'

def variable(x):
if not isinstance(x, str):
return False
else:
if x.islower():
return True
else:
return False

def compound(x):
if not isinstance(x, str):
return False
else:
if '(' in x and ')' in x:
return True
else:
return False

36
def list(x):
if not isinstance(x, str):
return True
else:
return False

def unify_var(var, x, theta):

print("IN unify_var", var, x, theta)
if var in theta:
print("var in theta", var, theta)
return unify(theta[var], x, theta)
elif x in theta:
print("x in theta", x, theta)
return unify(var, theta[x], theta)
else:
theta[var] = x
print("not in theta", theta[var])
return theta

def check_theta(theta):
for entry in theta:
if variable(theta[entry]):
if theta[entry] in theta:
print("in check_theta. theta changed")
theta[entry] = theta[theta[entry]]
return theta

def unify(x, y, theta):

print("\tunify", x, y, theta)
if theta == None:
print("\tin theta is None")
return None
elif x == y:
print("\tin x=y")
return check_theta(theta)
37
 elif variable(x) is True:
print("\tin variable(x)")
return unify_var(x, y, theta)
elif variable(y) is True:
print("\tin variable(y)")
return unify_var(y, x, theta)
elif compound(x) and compound(y):
print("\tin compound")
x_args = []
temp = x.partition('(')[-1].rpartition(')')[0]
for item in temp.split(','):
x_args.append(item)
y_args = []
temp = y.partition('(')[-1].rpartition(')')[0]
for item in temp.split(','):
y_args.append(item)
x_op = x.partition('(')[0]
y_op = y.partition('(')[0]
return unify(x_args, y_args, unify(x_op, y_op, theta))
elif list(x) and list(y):
print("\tin list")
return unify(x[1:], y[1:], unify(x[0], y[0], theta))
else:
print("\tin else")
return None

def fol_bc_ask(query, theta):

# Pendeklerasian secara global dari kb, variabel list dari predikat-predikat
# dan list dari rule, agar dapat di gunakan dimanapun
global kb
global list_of_predicates
global list_of_explored_rules

38
 # Printing tulisan "Backward Chaining"
print("Backward Chaining")

# Pembuatan rules berdasarkan rules yang sudah ada

# dimana rules berada pada file yang berbeda yaitu "input.txt"
# dan menjadi 1 file dengan tujuan
list_of_rules = fetch_rules(query)
# Dilakukan pengecekan apakah rule yang diterapkan pada tujuan
# apakah terdapat pada rules
for rule in list_of_rules:
print("taken RULE", rule)
list_of_explored_rules = []
list_of_explored_rules.append(query)
print("\t", query, "added to list_of_explored_rules")
lhs = rule.partition('=>')[0]
rhs = rule.partition('=>')[2]
print("lhs: ", lhs, " rhs: ", rhs)
print("theta in rule", theta)
theta1 = unify(rhs, query, theta)
if theta1 != None:
list_of_premises = lhs.split('^')
print("list_of_premises: ", list_of_premises)
theta2 = fol_bc_and(theta1, list_of_premises)
if theta2 != None:
return theta2

print("None of the rules worked out", query)

return None

def fol_bc_and(theta, list_of_premises):

global kb
global list_of_predicates

print("\tand: ", list_of_premises)

print("\ttheta: ", theta)
39
 if theta == None:
return None
else:
if list_of_premises != []:
temp_list = []
for each_premise in list_of_premises:
temp = subst(theta, each_premise)
temp_list.append(temp)
list_of_premises = temp_list
first_premise = list_of_premises[0]
rest_premise = list_of_premises[1:]
subs = list_of_premises[0]
if subs != '()':
if subs in list_of_explored_rules:
print(subs, " already in list_of_explored_rules")
return None
else:
print(subs, " added to list_of_explored_rules")
list_of_explored_rules.append(subs)
theta = fol_bc_or_sub(subs, {}, rest_premise)
else:
return theta
return theta

def fol_bc_or_sub(query, theta, rest) -> object:

global kb
global list_of_predicates

print("\tOR sub")
list_of_rules = fetch_rules(query)
print("\tLIST_OF_RULES", list_of_rules)
for rule in list_of_rules:
print("\tRULE", rule)
lhs = rule.partition('=>')[0]
rhs = rule.partition('=>')[2]
40
 print("\n\tlhs: ", lhs, " rhs: ", rhs)
print("\ntheta in rule", theta)
theta1 = unify(rhs, query, deepcopy(theta))
if theta1 != None:
list_of_premises = lhs.split('^')
print("\tlist_of_premises: ", list_of_premises)
theta2 = fol_bc_and(theta1, list_of_premises)
theta3 = fol_bc_and(theta2, rest)
if theta3 != None:
return theta3

print("\tNone of the rules worked out", query)

return None

def add_to_kb(knowledge_base):
global kb
global list_of_predicates

for sentence in knowledge_base:

if '=>' not in sentence:
predicate = sentence.partition('(')[0]
if predicate not in list_of_predicates:
conc = []
prem = []
conc.append("=>" + sentence)
kb[predicate] = {'conc': conc, 'prem': prem}
list_of_predicates.append(predicate)
else:
conc = kb[predicate]['conc']
prem = kb[predicate]['prem']
conc.append("=>" + sentence)
kb[predicate] = {'conc': conc, 'prem': prem}
else:
clauses = sentence.partition('=>')
list_of_premises = clauses[0].split('^')
41
 conclusion = clauses[2]

# for conclusion
predicate = conclusion.partition('(')[0]
if predicate not in list_of_predicates:
conc = []
prem = []
conc.append(sentence)
kb[predicate] = {'conc': conc, 'prem': prem}
list_of_predicates.append(predicate)
else:
conc = kb[predicate]['conc']
prem = kb[predicate]['prem']
conc.append(sentence)
kb[predicate] = {'conc': conc, 'prem': prem}

# for list_of_premises
for premise in list_of_premises:
predicate = premise.partition('(')[0]
if predicate not in list_of_predicates:
conc = []
prem = []
prem.append(sentence)
kb[predicate] = {'conc': conc, 'prem': prem}
list_of_predicates.append(predicate)
else:
conc = kb[predicate]['conc']
prem = kb[predicate]['prem']
prem.append(sentence)
kb[predicate] = {'conc': conc, 'prem': prem}

def variable(x):
if not isinstance(x, str):
return False
else:
42
 if x.islower():
return True
else:
return False

def standardize_variables(knowledge_base):
label = 0
result_knowledge_base = []
for rule in knowledge_base:
variable_names = {}
lhs = rule.partition('=>')[0]
rhs = rule.partition('=>')[2]
premise = []
for x in lhs.split('^'):
premise.append(x)
result_premise = ""
for term in premise:
args = []
result_term = "" + term.partition('(')[0]
temp = term.partition('(')[-1].rpartition(')')[0]
result_item = ""
for item in temp.split(','):
args.append(item)
if variable(item):
if item not in variable_names:
variable_names[item] = "x" + repr(label)
item = "x" + repr(label)
label = label + 1
else:
item = variable_names[item]
result_item = result_item + item + ","
result_item = result_item[:len(result_item) - 1]
result_term = result_term + '(' + result_item + ')' + '^'
result_premise = result_premise + result_term
result_premise = result_premise[:len(result_premise) - 1]
43
 conclusion = []
for x in rhs.split('^'):
conclusion.append(x)
if conclusion != ['']:
result_premise = result_premise + "=>"
for term in conclusion:
args = []
result_term = "" + term.partition('(')[0]
temp = term.partition('(')[-1].rpartition(')')[0]
result_item = ""
for item in temp.split(','):
args.append(item)
if variable(item):
if item not in variable_names:
variable_names[item] = "x" + repr(label)
item = "x" + repr(label)
label = label + 1
else:
item = variable_names[item]
result_item = result_item + item + ","
result_item = result_item[:len(result_item) - 1]
result_term = result_term + '(' + result_item + ')' + '^'
result_premise = result_premise + result_term
result_premise = result_premise[:len(result_premise) - 1]

result_knowledge_base.append(result_premise)
return result_knowledge_base

# Main
fn = "input.txt"
queries = []
knowledge_base = []
f1 = open(fn, "r")
input = f1.readlines()
44
input = [x.strip() for x in input]

for i in range(1, int(input[0]) + 1):

queries.append(input[i].replace(" ", ""))
for i in range(int(input[0]) + 2, int(input[int(input[0]) + 1]) +
int(input[0]) + 2):
knowledge_base.append(input[i].replace(" ", ""))
knowledge_base = standardize_variables(knowledge_base)

kb = {}
list_of_predicates = []
add_to_kb(knowledge_base)

fileOut = open("output.txt", "w")

for query in queries:
result = fol_bc_ask(query, {})
if result != None:
print("True", result)
fileOut.write("TRUE" + "\n")

else:
print("False", result)
fileOut.write("FALSE" + "\n")

fileOut.close()
f1.close

output program :

3. A. Forward Chaining
# This is a sample Python script.
# Press Shift+F10 to execute it or replace it with your code.
# Press Double Shift to search everywhere for classes, files, tool windows, actions, and settings.
45
def print_hi(name):
# Use a breakpoint in the code line below to debug your script.
print(f'Hi, {name}') # Press Ctrl+F8 to toggle the breakpoint.
# Press the green button in the gutter to run the script.
if _name_ == '_main_':
print_hi('PyCharm')
# See PyCharm help at https://www.jetbrains.com/help/pycharm/

#Program Forward Chaining

#mendefinisikan variabel fakta
global facts #varibael fact yang dapat dipanggil di fungsi manapun
global is_changed #variabel premis yang terbentuk dari hubungan antar fakta

is_changed = True # Menginisial variabel is_changed dengan nilai yang benar

#Menginputkan Fakta atau data
facts = [["vertebrate","duck"],
["flying","duck"],
["mammal","cat"]]

# mendefinisika fungsi assert fact

# langkah menengah untuk mencapai final
# solusi dan kembalikan nilai boolean
# mencari beberapa premis sesuai fakta
# (Benar jika premis memungkinkan, jika tidak Salah).
def assert_fact(fact): #mendefinisikan assert_fact yang akan berisi fact atau fakta baru
global facts #facts adalah variabel kumpulan fakta yang bisa dipanggil di funsi manapun
global is_changed #is_changed adalah kumpulan varibel premis yang terbentuk dari hubungan
antar fakta
if not fact in facts: #jika fakta atau fact tidak ada di facts
facts += [fact] #maka tambahkan fakta atau fact di facts
is_changed = True #Menginisial variabel is_changed dengan nilai yang benar

while is_changed: #ketika variabel is_changed:

is_changed = False #dalam inisial salah, maka

46
 #seleksi penambahan premis baru sesuai fakta
for A1 in facts: #untuk A1(variabel didalam fact) dimana fact=(A1[0],A1[1]), ada di
facts
if A1[0] == "mammal": #maka jika A1[0]="mammal", maka
assert_fact(["vertebrate", A1[1]]) #assert_fact atau premis atau fakta baru berubah menjadi
[vertebrate,A1[1]]
if A1[0] == "vertebrate": #jika A1[0]="vertebrate", maka
assert_fact(["animal", A1[1]]) #assert_fact atau premis atau fakta baru berubah menjadi
[animal,A1[1]]
if A1[0] == "vertebrate" and ["flying", A1[1]] in facts: #jika A1[0]="vertebrate" dan terdapat
fakta ["flying", A1[1]] di Facts, maka :
assert_fact(["bird", A1[1]]) #assert_fact atau premis atau fakta baru berubah menjadi
[bird,A1[1]]

#mencetak kumpulan fakta

print(facts)

#pengecekkan fakta
check_fact=(['animal','cat']) #penambahan fakta baru #input data baru bisa diubah ubah tinggal
mau check data yang mana
if check_fact in facts: #seleksi fakta baru dan lama, jika check_fact di facts:
print(str(check_fact)+' is true') #maka cetak fakta baru is true
else: #selain itu ( jika check_fact tidak ada di facts:)
print(str(check_fact)+'is false') #maka cetak fakta baru is false
B. Backward Chaining
from copy import deepcopy

# deklarasi Variabel untuk knowledge Base

kb = {}
# deklarasi Pembuatan list dari predikat yang berupa array
list_of_predicates = []
# deklarasi Pembuatan lis rule yang berupa array
list_of_explored_rules = []

# definisi fungsi untuk penerapan tujuan pada rules => goal

def fetch_rules(goal):
# Deklarasi kb dan list predikat secara global pada fungsi fetch_rules
47
 # sehingga variabel ini dapat digunakan di blok program manapun pada fungsi fetch_rules
global kb
global list_of_predicates

# Printing goal dari pencarian

print("fetch_rules for goal:- ", goal)
# pembuatan list rule berupa array
list_of_rules = []
predicate = goal.partition('(')[0]
print("\t", predicate, kb[predicate]['conc'])
list_of_rules = list_of_rules + kb[predicate]['conc']
return list_of_rules

def subst(theta, first):

print("\tsubst: ", theta, first)
predicate = first.partition('(')[0]
list = (first.partition('(')[-1].rpartition(')')[0]).split(',')
print("\t", list)
for i in range(len(list)):
if variable(list[i]):
if list[i] in theta:
list[i] = theta[list[i]]
print("\t", predicate + '(' + ','.join(list) + ')')
return predicate + '(' + ','.join(list) + ')'

def variable(x):
if not isinstance(x, str):
return False
else:
if x.islower():
return True
else:
return False
48
def compound(x):
if not isinstance(x, str):
return False
else:
if '(' in x and ')' in x:
return True
else:
return False

def list(x):
if not isinstance(x, str):
return True
else:
return False

def unify_var(var, x, theta):

print("IN unify_var", var, x, theta)
if var in theta:
print("var in theta", var, theta)
return unify(theta[var], x, theta)
elif x in theta:
print("x in theta", x, theta)
return unify(var, theta[x], theta)
else:
theta[var] = x
print("not in theta", theta[var])
return theta

def check_theta(theta):
for entry in theta:
if variable(theta[entry]):
if theta[entry] in theta:
print("in check_theta. theta changed")
theta[entry] = theta[theta[entry]]
49
 return theta

def unify(x, y, theta):

print("\tunify", x, y, theta)
if theta == None:
print("\tin theta is None")
return None
elif x == y:
print("\tin x=y")
return check_theta(theta)
elif variable(x) is True:
print("\tin variable(x)")
return unify_var(x, y, theta)
elif variable(y) is True:
print("\tin variable(y)")
return unify_var(y, x, theta)
elif compound(x) and compound(y):
print("\tin compound")
x_args = []
temp = x.partition('(')[-1].rpartition(')')[0]
for item in temp.split(','):
x_args.append(item)
y_args = []
temp = y.partition('(')[-1].rpartition(')')[0]
for item in temp.split(','):
y_args.append(item)
x_op = x.partition('(')[0]
y_op = y.partition('(')[0]
return unify(x_args, y_args, unify(x_op, y_op, theta))
elif list(x) and list(y):
print("\tin list")
return unify(x[1:], y[1:], unify(x[0], y[0], theta))
else:
print("\tin else")
return None
50
#
def fol_bc_ask(query, theta):
# Pendeklerasian secara global dari kb, variabel list dari predikat-predikat
# dan list dari rule, agar dapat di gunakan dimanapun
global kb
global list_of_predicates
global list_of_explored_rules

# Printing tulisan "Backward Chaining"

print("Backward Chaining")
# Pembuatan rules berdasarkan rules yang sudah ada
# dimana rules berada pada file yang berbeda yaitu "input.txt"
# dan menjadi 1 file dengan tujuan
list_of_rules = fetch_rules(query)
# Dilakukan pengecekan apakah rule yang diterapkan pada tujuan
# apakah terdapat pada rules
for rule in list_of_rules:
print("taken RULE", rule)
list_of_explored_rules = []
list_of_explored_rules.append(query)
print("\t", query, "added to list_of_explored_rules")
lhs = rule.partition('=>')[0]
rhs = rule.partition('=>')[2]
print("lhs: ", lhs, " rhs: ", rhs)
print("theta in rule", theta)
theta1 = unify(rhs, query, theta)
if theta1 != None:
list_of_premises = lhs.split('^')
print("list_of_premises: ", list_of_premises)
theta2 = fol_bc_and(theta1, list_of_premises)
if theta2 != None:
return theta2

print("None of the rules worked out", query)

51
 return None

def fol_bc_and(theta, list_of_premises):

global kb
global list_of_predicates

print("\tand: ", list_of_premises)

print("\ttheta: ", theta)
if theta == None:
return None
else:
if list_of_premises != []:
temp_list = []
for each_premise in list_of_premises:
temp = subst(theta, each_premise)
temp_list.append(temp)
list_of_premises = temp_list
first_premise = list_of_premises[0]
rest_premise = list_of_premises[1:]
subs = list_of_premises[0]
if subs != '()':
if subs in list_of_explored_rules:
print(subs, " already in list_of_explored_rules")
return None
else:
print(subs, " added to list_of_explored_rules")
list_of_explored_rules.append(subs)
theta = fol_bc_or_sub(subs, {}, rest_premise)
else:
return theta
return theta

def fol_bc_or_sub(query, theta, rest) -> object:

global kb
global list_of_predicates
52
 print("\tOR sub")
list_of_rules = fetch_rules(query)
print("\tLIST_OF_RULES", list_of_rules)
for rule in list_of_rules:
print("\tRULE", rule)
lhs = rule.partition('=>')[0]
rhs = rule.partition('=>')[2]
print("\n\tlhs: ", lhs, " rhs: ", rhs)
print("\ntheta in rule", theta)
theta1 = unify(rhs, query, deepcopy(theta))
if theta1 != None:
list_of_premises = lhs.split('^')
print("\tlist_of_premises: ", list_of_premises)
theta2 = fol_bc_and(theta1, list_of_premises)
theta3 = fol_bc_and(theta2, rest)
if theta3 != None:
return theta3

print("\tNone of the rules worked out", query)

return None

def add_to_kb(knowledge_base):
global kb
global list_of_predicates

for sentence in knowledge_base:

if '=>' not in sentence:
predicate = sentence.partition('(')[0]
if predicate not in list_of_predicates:
conc = []
prem = []
conc.append("=>" + sentence)
kb[predicate] = {'conc': conc, 'prem': prem}
list_of_predicates.append(predicate)
53
 else:
conc = kb[predicate]['conc']
prem = kb[predicate]['prem']
conc.append("=>" + sentence)
kb[predicate] = {'conc': conc, 'prem': prem}
else:
clauses = sentence.partition('=>')
list_of_premises = clauses[0].split('^')
conclusion = clauses[2]

# for conclusion
predicate = conclusion.partition('(')[0]
if predicate not in list_of_predicates:
conc = []
prem = []
conc.append(sentence)
kb[predicate] = {'conc': conc, 'prem': prem}
list_of_predicates.append(predicate)
else:
conc = kb[predicate]['conc']
prem = kb[predicate]['prem']
conc.append(sentence)
kb[predicate] = {'conc': conc, 'prem': prem}

# for list_of_premises
for premise in list_of_premises:
predicate = premise.partition('(')[0]
if predicate not in list_of_predicates:
conc = []
prem = []
prem.append(sentence)
kb[predicate] = {'conc': conc, 'prem': prem}
list_of_predicates.append(predicate)
else:
conc = kb[predicate]['conc']
54
 prem = kb[predicate]['prem']
prem.append(sentence)
kb[predicate] = {'conc': conc, 'prem': prem}

def variable(x):
if not isinstance(x, str):
return False
else:
if x.islower():
return True
else:
return False

def standardize_variables(knowledge_base):
label = 0
result_knowledge_base = []
for rule in knowledge_base:
variable_names = {}
lhs = rule.partition('=>')[0]
rhs = rule.partition('=>')[2]
premise = []
for x in lhs.split('^'):
premise.append(x)
result_premise = ""
for term in premise:
args = []
result_term = "" + term.partition('(')[0]
temp = term.partition('(')[-1].rpartition(')')[0]
result_item = ""
for item in temp.split(','):
args.append(item)
if variable(item):
if item not in variable_names:
variable_names[item] = "x" + repr(label)
55
 item = "x" + repr(label)
label = label + 1
else:
item = variable_names[item]
result_item = result_item + item + ","
result_item = result_item[:len(result_item) - 1]
result_term = result_term + '(' + result_item + ')' + '^'
result_premise = result_premise + result_term
result_premise = result_premise[:len(result_premise) - 1]

conclusion = []
for x in rhs.split('^'):
conclusion.append(x)
if conclusion != ['']:
result_premise = result_premise + "=>"
for term in conclusion:
args = []
result_term = "" + term.partition('(')[0]
temp = term.partition('(')[-1].rpartition(')')[0]
result_item = ""
for item in temp.split(','):
args.append(item)
if variable(item):
if item not in variable_names:
variable_names[item] = "x" + repr(label)
item = "x" + repr(label)
label = label + 1
else:
item = variable_names[item]
result_item = result_item + item + ","
result_item = result_item[:len(result_item) - 1]
result_term = result_term + '(' + result_item + ')' + '^'
result_premise = result_premise + result_term
result_premise = result_premise[:len(result_premise) - 1]

56
 result_knowledge_base.append(result_premise)
return result_knowledge_base

# Main
fn = "input.txt"
queries = []
knowledge_base = []
f1 = open(fn, "r")
input = f1.readlines()
input = [x.strip() for x in input]

for i in range(1, int(input[0]) + 1):

queries.append(input[i].replace(" ", ""))
for i in range(int(input[0]) + 2, int(input[int(input[0]) + 1]) +
int(input[0]) + 2):
knowledge_base.append(input[i].replace(" ", ""))
knowledge_base = standardize_variables(knowledge_base)

kb = {}
list_of_predicates = []
add_to_kb(knowledge_base)

fileOut = open("output.txt", "w")

for query in queries:
result = fol_bc_ask(query, {})
if result != None:
print("True", result)
fileOut.write("TRUE" + "\n")
else:
print("False", result)
fileOut.write("FALSE" + "\n")

fileOut.close()
f1.close

57
PERTANYAAN
1. Jelaskan aturan-aturan dan fakta yang berlaku pada kasus tersebut!
2. Manakah yang lebih cepat pemrosesan antara Backward Chaining dan Forward Chaining?
3. Jelaskan alasan pertanyaan 2!

JAWABAN
1. Dalam program forward chaining aturan aturan kasus tersebut dituliskan pada program sebagai
berikut :
for A1 in facts: #untuk A1(variabel didalam fact) dimana fact=(A1[0],A1[1]), ada di
facts
if A1[0] == "mammal": #maka jika A1[0]="mammal", maka
assert_fact(["vertebrate", A1[1]]) #assert_fact atau premis atau fakta baru berubah menjadi
[vertebrate,A1[1]]
if A1[0] == "vertebrate": #jika A1[0]="vertebrate", maka
assert_fact(["animal", A1[1]]) #assert_fact atau premis atau fakta baru berubah menjadi
[animal,A1[1]]
if A1[0] == "vertebrate" and ["flying", A1[1]] in facts: #jika A1[0]="vertebrate" dan terdapat
fakta ["flying", A1[1]] di Facts, maka :
assert_fact(["bird", A1[1]]) #assert_fact atau premis atau fakta baru berubah menjadi
[bird,A1[1]]
Sedangkan faktanya dituliskan dengan program :
facts = [["vertebrate","duck"],
["flying","duck"],
["mammal","cat"]]
Maka dari program tersebut diketahui fakta bahwa :
1. Duck adalah vetebrata
2. Ciri-ciri Duck adalah Flying (terbang)
3. Kucing adalah mamal
Dengan aturan
1. Jika Mammal maka termasuk Vetebrata
2. Jika Vetebrata maka termasuk Animal
3. Jika Vetebrata dan dapat Flying maka termasuk Bird
2. Yang lebih cepat adalah Forward Chaining
3. Lebih cepat Forward Chaining karena hanya menguji 1 kali kebenaran hipotesis terhadap fakta.
Sedangkan Backward Chaining dapat memungkinkan pengujian lebih dari 1 kali karena penalaran
dimulai dari hipotesis terlebih dahulu, dan untuk menguji kebenaran hipotesis tersebut dicari harus
dicari fakta-fakta yang ada dalam basis pengetahuan.
Sehingga pada Backward Chaining menyebabkan langkah yang ditempuh untuk menempuh tujuan
58
 lebih panjang.

TUGAS
1. Tambahkan beberapa rule dan fakta awal untuk program di atas. Misalkan tambahkan
fakta :
A. Gajah adalah mamalia.
B. Mamalia adalah menyusui
2. Buat kode Python dengan aturan-aturan dan fakta berikut:
JAWABAN
1. Faktanya awal :
facts = [["vertebrate","duck"],
["flying","duck"],
["mammal","cat"],
["mammal","elephant"]]
Aturan :
for A1 in facts: #untuk A1(variabel didalam fact) dimana fact=(A1[0],A1[1]), ada di facts
if A1[0] == "mammal": #maka jika A1[0]="mammal", maka
assert_fact(["vertebrate", A1[1]]) #assert_fact atau premis atau fakta baru berubah menjadi
[vertebrate,A1[1]]
assert_fact(["menyusui", A1[1]]) #assert_fact atau premis atau fakta baru berubah menjadi
[menyusui,A1[1]]
if A1[0] == "vertebrate": #jika A1[0]="vertebrate", maka
assert_fact(["animal", A1[1]]) #assert_fact atau premis atau fakta baru berubah menjadi
[animal,A1[1]]
if A1[0] == "vertebrate" and ["flying", A1[1]] in facts: #jika A1[0]="vertebrate" dan terdapat fakta
["flying", A1[1]] di Facts, maka :
assert_fact(["bird", A1[1]]) #assert_fact atau premis atau fakta baru berubah menjadi
[bird,A1[1]]
# assert_fact atau premis atau fakta baru berubah menjadi [bird,A1[1]]
2. Maka kode programnya sebagai berikut :
# This is a sample Python script.
# Press Shift+F10 to execute it or replace it with your code.
# Press Double Shift to search everywhere for classes, files, tool windows, actions, and settings.
def print_hi(name):
# Use a breakpoint in the code line below to debug your script.
print(f'Hi, {name}') # Press Ctrl+F8 to toggle the breakpoint.
# Press the green button in the gutter to run the script.

59
if name == '_main_':
print_hi('PyCharm')
# See PyCharm help at https://www.jetbrains.com/help/pycharm/

#Program Forward Chaining

#mendefinisikan variabel fakta
global facts #varibael fact yang dapat dipanggil di fungsi manapun
global is_changed #variabel premis yang terbentuk dari hubungan antar fakta

is_changed = True # Menginisial variabel is_changed dengan nilai yang benar

#Menginputkan Fakta atau data
facts = [["vertebrate","duck"],
["flying","duck"],
["mammal","cat"],
["mammal","elephant"]]

# mendefinisika fungsi assert fact

# langkah menengah untuk mencapai final
# solusi dan kembalikan nilai boolean
# mencari beberapa premis sesuai fakta
# (Benar jika premis memungkinkan, jika tidak Salah).
def assert_fact(fact): #mendefinisikan assert_fact yang akan berisi fact atau fakta baru
global facts #facts adalah variabel kumpulan fakta yang bisa dipanggil di funsi manapun
global is_changed #is_changed adalah kumpulan varibel premis yang terbentuk dari hubungan
antar fakta
if not fact in facts: #jika fakta atau fact tidak ada di facts
facts += [fact] #maka tambahkan fakta atau fact di facts
is_changed = True #Menginisial variabel is_changed dengan nilai yang benar

while is_changed: #ketika variabel is_changed:

is_changed = False #dalam inisial salah, maka
#seleksi penambahan premis baru sesuai fakta
for A1 in facts: #untuk A1(variabel didalam fact) dimana fact=(A1[0],A1[1]), ada di facts
if A1[0] == "mammal": #maka jika A1[0]="mammal", maka

60
 assert_fact(["vertebrate", A1[1]]) #assert_fact atau premis atau fakta baru berubah menjadi
[vertebrate,A1[1]]
assert_fact(["menyusui", A1[1]]) #assert_fact atau premis atau fakta baru berubah menjadi
[menyusui,A1[1]]
if A1[0] == "vertebrate": #jika A1[0]="vertebrate", maka
assert_fact(["animal", A1[1]]) #assert_fact atau premis atau fakta baru berubah menjadi
[animal,A1[1]]
if A1[0] == "vertebrate" and ["flying", A1[1]] in facts: #jika A1[0]="vertebrate" dan terdapat fakta
["flying", A1[1]] di Facts, maka :
assert_fact(["bird", A1[1]]) #assert_fact atau premis atau fakta baru berubah menjadi
[bird,A1[1]]
# assert_fact atau premis atau fakta baru berubah menjadi [bird,A1[1]]

#mencetak kumpulan fakta

print(facts)

#pengecekkan fakta
check_fact=(['animal','cat']) #penambahan fakta baru #input data baru bisa diubah ubah tinggal
mau check data yang mana
if check_fact in facts: #seleksi fakta baru dan lama, jika check_fact di facts:
print(str(check_fact)+' is true') #maka cetak fakta baru is true
else: #selain itu ( jika check_fact tidak ada di facts:)
print(str(check_fact)+'is false') #maka cetak fakta baru is false
Output Program :
Hi, PyCharm
[['vertebrate', 'duck'], ['flying', 'duck'], ['mammal', 'cat'], ['mammal', 'elephant'], ['animal', 'duck'], ['bird',
'duck'], ['vertebrate', 'cat'], ['menyusui', 'cat'], ['vertebrate', 'elephant'], ['menyusui', 'elephant'],
['animal', 'cat'], ['animal', 'elephant']]
['animal', 'cat'] is true

Process finished with exit code 0

61