# ====== Mini Inference Engine — Forward Chaining ======
# Fakta ditulis sebagai string, aturan berbentuk (kondisi AND, kesimpulan)

rules = [
    ("demam and batuk", "flu"),
    ("flu and nyeri_otot", "influenza"),
    ("flu and sesak", "covid_suspect"),
    ("influenza and istirahat_kurang", "butuh_istirahat")
]

facts = {"demam", "batuk", "nyeri_otot"}  # ganti sesuai kasus Anda

print("Fakta awal:", facts)

new_fact = True
while new_fact:
    new_fact = False
    for cond, concl in rules:
        conds = [c.strip() for c in cond.split("and")]
        if all(c in facts for c in conds) and concl not in facts:
            facts.add(concl)
            new_fact = True
            print("Inferred:", concl)

print("\nFakta akhir:", facts)

Ubah fakta/aturan, amati rantai inferensi. Coba tambah aturan yang memerlukan 3 kondisi sekaligus.

# ====== Mini Inference Engine — Backward Chaining (DFS) ======
# Tujuan (goal) ditanya: apakah bisa dibuktikan dari fakta + aturan?

from functools import lru_cache

rules = [
    ("demam and batuk", "flu"),
    ("flu and nyeri_otot", "influenza"),
    ("flu and sesak", "covid_suspect"),
]

facts = {"demam", "batuk", "nyeri_otot"}

# index rules berdasarkan kesimpulan
index = {}
for cond, concl in rules:
    index.setdefault(concl, []).append(cond)

@lru_cache(None)
def prove(goal):
    # jika goal sudah fakta dasar
    if goal in facts:
        return True
    # coba pakai aturan yang menghasilkan goal
    for cond in index.get(goal, []):
        conds = [c.strip() for c in cond.split("and")]
        if all(prove(c) for c in conds):
            return True
    return False

for g in ["flu", "influenza", "covid_suspect", "istirahat"]:
    print(f"{g}:", prove(g))

Ubah daftar goal untuk melihat mana yang bisa dibuktikan. Perhatikan perbedaan alur dibanding forward chaining.

# ====== (Opsional) Logika Predikat Sederhana: Fakta & Aturan Impikasi ======
# Bentuk fakta: parent(A,B). Aturan: parent(X,Y) and parent(Y,Z) -> grandparent(X,Z)
# Kita pakai unifikasi sangat sederhana berbasis string.

from collections import defaultdict

facts = set([
    ("parent", "andi", "budi"),
    ("parent", "budi", "citra"),
])

rules = [
    (("parent", "X", "Y"), ("parent", "Y", "Z"), ("grandparent", "X", "Z")),
]

# util: cek apakah token variabel (huruf besar berarti variabel)
var = lambda t: t and t[0].isupper()

def unify(pat, fact, env=None):
    env = dict(env or {})
    for a,b in zip(pat, fact):
        if var(a):
            if a in env and env[a] != b:
                return None
            env[a] = b
        elif a != b:
            return None
    return env

# forward chaining 1-langkah
new = True
while new:
    new = False
    for (p1,p2,head) in rules:
        for f1 in list(facts):
            if f1[0] != p1[0]:
                continue
            env1 = unify(p1, f1)
            if env1 is None:
                continue
            for f2 in list(facts):
                if f2[0] != p2[0]:
                    continue
                env2 = unify(tuple(env1.get(x,x) for x in p2), f2, env1)
                if env2 is None:
                    continue
                concl = tuple(env2.get(x,x) for x in head)
                if concl not in facts:
                    facts.add(concl)
                    new = True
                    print("Inferred:", concl)

print("\nSemua fakta:")
for f in facts:
    print(f)

Contoh ini memperlihatkan variabel (X,Y,Z) dan unifikasi sederhana untuk memperoleh fakta baru (grandparent).

# ====== Kuis 6 (cek mandiri) ======
qs=[
  ("Knowledge Representation menyimpan?",{"a":"Data mentah","b":"Fakta dan aturan logis","c":"Bobot neuron","d":"Gambar"},"b"),
  ("Forward chaining dimulai dari?",{"a":"Tujuan","b":"Fakta awal","c":"Hipotesis","d":"Acak"},"b"),
  ("Modus Ponens menyatakan...",{"a":"Jika P→Q dan Q maka P","b":"Jika P dan P→Q maka Q","c":"Jika ¬Q maka ¬P","d":"Jika P maka ¬Q"},"b"),
]
print('Kunci jawaban:')
for i,(_,__,ans) in enumerate(qs,1):
    print(f'Q{i}: {ans}')