% Facts
man(john).
man(bob).
man(charles).
woman(sarah).

weapon(knife).
weapon(gun).

motive(john, victim).     % john had motive
motive(sarah, victim).

owns(john, knife).
owns(bob, gun).
owns(sarah, gun).

% Rules
killer(X) :- 
    motive(X, victim), 
    owns(X, Weapon), 
    weapon(Weapon),
    man(X).

% Query: ?- killer(Who).
% Answer: Who = john

# Simple Prolog-like forward chainer in Python
knowledge_base = {
    "man": ["john", "bob", "charles"],
    "woman": ["sarah"],
    "motive": [("john", "victim"), ("sarah", "victim")],
    "owns": [("john", "knife"), ("bob", "gun"), ("sarah", "gun")],
    "weapon": ["knife", "gun"]
}

def is_killer(person):
    if person not in [p for p in knowledge_base["man"] + knowledge_base["woman"]]:
        return False
    has_motive = any(m[0] == person and m[1] == "victim" for m in knowledge_base["motive"])
    has_weapon = any(o[0] == person and o[1] in knowledge_base["weapon"] for o in knowledge_base["owns"])
    return has_motive and has_weapon and person in knowledge_base["man"]

print([p for p in ["john","bob","sarah"] if is_killer(p)])  # Output: ['john']

def unify(e1, e2, subst=None):
    if subst is None:
        subst = {}
    if e1 == e2:
        return subst
    if is_variable(e1):
        return unify_var(e1, e2, subst)
    if is_variable(e2):
        return unify_var(e2, e1, subst)
    if is_compound(e1) and is_compound(e2):
        if functor(e1) != functor(e2) or arity(e1) != arity(e2):
            return None
        for a1, a2 in zip(args(e1), args(e2)):
            subst = unify(a1, a2, subst)
            if subst is None:
                return None
        return subst
    return None

def unify_var(var, x, subst):
    if var in subst:
        return unify(subst[var], x, subst)
    elif x in subst:
        return unify(var, subst[x], subst)
    elif occurs_check(var, x):
        return None
    else:
        subst[var] = x
        return subst

# Forward Chaining in Python
rules = [
    (["fever", "cough"], "flu"),
    (["fever", "rash"], "measles"),
    (["flu", "tired"], "needs_rest"),
    (["measles"], "contagious")
]

facts = ["fever", "cough", "tired"]

def forward_chain(rules, facts):
    new_facts = True
    while new_facts:
        new_facts = False
        for antecedents, consequent in rules:
            if all(a in facts for a in antecedents) and consequent not in facts:
                facts.append(consequent)
                new_facts = True
                print(f"Inferred: {consequent}")
    return facts

print(forward_chain(rules, facts))
# Output: Inferred flu → needs_rest

# Simple Backward Chaining
def backward_chain(goal, rules, known):
    if goal in known:
        print(f"{goal} is known")
        return True
    for ants, cons in rules:
        if cons == goal:
            print(f"To prove {goal}, prove: {ants}")
            if all(backward_chain(a, rules, known) for a in ants):
                return True
    return False

known = ["fever", "cough"]
print(backward_chain("needs_rest", rules, known))

Bird(Tweety)
Bird(x) : Flies(x) / Flies(x)     ← "birds fly by default"
¬Abnormal(Tweety)
→ Flies(Tweety)

# Simple default reasoning
default_rules = {
    "adult": "pays_tax",
    "bird": "flies"
}
exceptions = {"student", "penguin"}

def default_reason(person, property):
    base = None
    if "adult" in person and "pays_tax" == property:
        base = "adult"
    if "bird" in person and "flies" == property:
        base = "bird"

    if base and not any(exc in person for exc in exceptions):
        return True
    return False

john = {"adult", "employed"}
tweety = {"bird"}
penguin = {"bird", "penguin"}

print(default_reason(john, "pays_tax"))   # True
print(default_reason(tweety, "flies"))    # True
print(default_reason(penguin, "flies"))   # False