Expert Systems and Rule-Based Inference Engines in AI

An Expert System is a specialized knowledge-based computer program designed to solve complex domain-specific problems at the level of a human human expert. Pioneered during the 1970s and 1980s (e.g., DENDRAL for chemical spectroscopy and MYCIN for infectious blood diseases), expert systems proved that commercial artificial intelligence could provide immense financial and operational value through automated symbolic reasoning.

Architecture of a Classical Expert System

Unlike standard software where domain knowledge and program control are tangled together in procedural code, an expert system strictly separates domain facts from reasoning logic:

• Knowledge Base (KB): Contains domain-specific rules (IF-THEN production rules) and declarative facts acquired from human domain specialists.
• Working Memory: Represents the current dynamic case state — facts established so far for a specific case or patient.
• Inference Engine: The brain of the system; carries out reasoning by matching working memory facts against production rules.
• Explanation Facility (Justifier): Explains how a conclusion was reached or why a specific question is being asked.
• Knowledge Acquisition Facility: Tools helping human knowledge engineers transcribe expert knowledge into rules.

Forward Chaining vs Backward Chaining Reasoning

Conflict Resolution Strategies

When multiple production rules have their conditions satisfied simultaneously in working memory (the Conflict Set), the inference engine must select which rule to fire first:

• Refractoriness: A rule will not fire twice on the exact same data to prevent infinite loops.
• Recency: Prefers rules matching facts most recently added to working memory.
• Specificity: Prefers rules with more specific conditions (e.g., a rule checking 4 symptoms fires before a general rule checking 1 symptom).
• Rule Priority: Explicit numerical priority assigned by the human knowledge engineer.

The RETE Algorithm (Forgy, 1979)

In large systems with tens of thousands of rules, naively checking every rule against working memory at every cycle takes ( O(R cdot F^C) ) time — catastrophically slow. Charles Forgy invented the RETE Algorithm, which compiles production rules into a directed acyclic pattern-matching network:

• Alpha Nodes: Perform simple 1-input intra-element condition checks.
• Beta Nodes: Perform 2-input inter-element joins across multiple patterns.
• State Preservation: Nodes memorize past matches across cycles, evaluating only the delta changes in working memory.

class Rule:
    def __init__(self, name, conditions, conclusion):
        self.name = name
        self.conditions = set(conditions)
        self.conclusion = conclusion

class ForwardChainingEngine:
    def __init__(self, rules):
        self.rules = rules
        self.working_memory = set()
        self.fired_rules = set()

    def add_fact(self, fact):
        self.working_memory.add(fact)

    def run(self):
        print("Starting Forward Chaining Inference...")
        while True:
            rule_fired = False
            for rule in self.rules:
                if rule.name in self.fired_rules:
                    continue
                # If all rule conditions exist in working memory
                if rule.conditions.issubset(self.working_memory):
                    print(f" -> [FIRE] Rule '{rule.name}' triggered! Added fact: {rule.conclusion}")
                    self.working_memory.add(rule.conclusion)
                    self.fired_rules.add(rule.name)
                    rule_fired = True
                    break  # Cycle restart for conflict resolution
            if not rule_fired:
                break
        print(f"Final Working Memory Facts: {sorted(list(self.working_memory))}")

# Define Medical Diagnostic Rules
rules = [
    Rule("R1_Fever_Cough", ["fever", "cough"], "respiratory_infection"),
    Rule("R2_Fatigue_LossSmell", ["respiratory_infection", "loss_of_smell"], "suspected_covid19"),
    Rule("R3_Wheezing", ["cough", "shortness_of_breath"], "suspected_asthma"),
    Rule("R4_Emergency", ["suspected_covid19", "low_oxygen"], "urgent_hospital_admission")
]

engine = ForwardChainingEngine(rules)
# Patient enters clinic with initial symptoms
engine.add_fact("fever")
engine.add_fact("cough")
engine.add_fact("loss_of_smell")
engine.add_fact("low_oxygen")

engine.run()