Editing Symbolic Ai

<div style="background-color: #4B0082; color: #FFFFFF; padding: 20px; border-radius: 8px; margin-bottom: 15px;">
{{BloomIntro}}
Symbolic AI and expert systems represent the original paradigm of artificial intelligence — one based on explicit rules, logic, and knowledge representations, as opposed to the statistical pattern learning of modern neural networks. Expert systems encode human domain expertise as formal rules and use inference engines to reason from those rules to conclusions. While largely superseded by machine learning in raw performance on perceptual tasks, symbolic AI remains essential for interpretability, formal verification, planning, knowledge representation, and hybrid neuro-symbolic approaches that combine the strengths of both paradigms.
</div>

__TOC__

<div style="background-color: #000080; color: #FFFFFF; padding: 20px; border-radius: 8px; margin-bottom: 15px;">
== <span style="color: #FFFFFF;">Remembering</span> ==
* '''Symbolic AI''' — An approach to AI based on explicit representations of knowledge using symbols, rules, and logic, and manipulation of those representations according to formal rules.
* '''Expert system''' — A computer system that emulates the decision-making ability of a human expert in a specific domain, using a knowledge base and inference engine.
* '''Knowledge base''' — The repository of domain knowledge in an expert system, encoded as facts and rules.
* '''Inference engine''' — The component of an expert system that applies logical rules to the knowledge base to deduce new facts or make decisions.
* '''Rule-based system''' — A system where behavior is defined by IF-THEN production rules: IF [condition] THEN [action/conclusion].
* '''Forward chaining''' — A data-driven inference strategy: start from known facts, apply rules to derive new facts, repeat until the goal is reached.
* '''Backward chaining''' — A goal-driven inference strategy: start from the desired conclusion and work backward to find conditions that would prove it.
* '''Ontology''' — A formal representation of concepts, their properties, and relationships within a domain.
* '''Prolog''' — A logic programming language widely used for symbolic AI, based on Horn clauses and resolution.
* '''LISP''' — A programming language historically central to AI; known for symbolic computation and list processing.
* '''First-order logic (FOL)''' — A formal system for representing statements about objects and their relationships using predicates, quantifiers, and logical connectives.
* '''Fuzzy logic''' — An extension of classical logic that allows truth values between 0 and 1, enabling reasoning under uncertainty.
* '''STRIPS''' — Stanford Research Institute Problem Solver; a foundational AI planning formalism defining actions as preconditions and effects.
* '''Frame''' — A data structure representing a stereotypical situation (like a schema or class); used in knowledge representation.
* '''Semantic network''' — A graph-based knowledge representation where nodes are concepts and edges are labeled relationships.
</div>

<div style="background-color: #006400; color: #FFFFFF; padding: 20px; border-radius: 8px; margin-bottom: 15px;">
== <span style="color: #FFFFFF;">Understanding</span> ==
The fundamental premise of symbolic AI is that '''intelligence can be achieved by manipulating symbols according to explicit rules'''. This stands in contrast to connectionist AI (neural networks), which achieves intelligence by learning statistical patterns from data. Both paradigms have profound strengths and weaknesses.

'''Expert systems''' were the dominant commercial AI technology of the 1980s. A medical expert system like MYCIN (1970s) encoded hundreds of rules like:
<syntaxhighlight lang="text">
IF the infection is primary-bacteremia
AND the site of the culture is one of the sterile sites
AND the suspected portal of entry is gastrointestinal tract
THEN there is suggestive evidence (0.7) that the organism is Bacteroides
</syntaxhighlight>

Note the confidence factor (0.7) — even early expert systems handled uncertainty through certainty factors, a precursor to probabilistic reasoning.

'''The knowledge acquisition bottleneck''' is symbolic AI's central challenge. Encoding human expertise requires enormous time from domain experts and knowledge engineers. As the domain grows more complex, the rule base becomes unwieldy — rules interact in unexpected ways, and maintaining consistency becomes difficult. This "brittleness" contributed to the 1980s AI winter.

'''Why symbolic AI still matters''':
* '''Interpretability''': Rule-based systems can explain every decision — "the loan was denied because condition X was not met, per rule 42." Neural networks cannot match this.
* '''Formal guarantees''': Logic-based systems can be formally verified. Safety-critical systems (avionics, medical devices) often require this.
* '''Compositionality''': Symbolic systems can reason about new combinations of known concepts without training data for those combinations.
* '''Data efficiency''': Expert knowledge encoded directly requires no training data for the rules themselves.

Modern '''neuro-symbolic AI''' combines learned neural representations with symbolic reasoning — getting the pattern recognition of neural networks and the reasoning transparency of symbolic systems.
</div>

<div style="background-color: #8B0000; color: #FFFFFF; padding: 20px; border-radius: 8px; margin-bottom: 15px;">
== <span style="color: #FFFFFF;">Applying</span> ==
'''Building a rule-based expert system in Python:'''

<syntaxhighlight lang="python">
class ExpertSystem:
    """Simple forward-chaining expert system for loan assessment."""

    def __init__(self):
        self.facts = {}
        self.conclusions = []

    def assert_fact(self, key, value):
        self.facts[key] = value

    def run(self):
        """Apply all rules and collect conclusions."""

        # Rule 1: Credit score classification
        if self.facts.get('credit_score', 0) >= 750:
            self.assert_fact('credit_rating', 'excellent')
        elif self.facts.get('credit_score', 0) >= 650:
            self.assert_fact('credit_rating', 'good')
        else:
            self.assert_fact('credit_rating', 'poor')

        # Rule 2: Debt-to-income ratio
        dti = self.facts.get('monthly_debt', 0) / max(self.facts.get('monthly_income', 1), 1)
        self.assert_fact('dti_ratio', dti)

        if dti <= 0.36:
            self.assert_fact('dti_status', 'acceptable')
        else:
            self.assert_fact('dti_status', 'high')

        # Rule 3: Employment stability
        if self.facts.get('employment_years', 0) >= 2:
            self.assert_fact('employment_status', 'stable')
        else:
            self.assert_fact('employment_status', 'unstable')

        # Rule 4: Final decision (requires ALL conditions)
        if (self.facts.get('credit_rating') in ['excellent', 'good'] and
                self.facts.get('dti_status') == 'acceptable' and
                self.facts.get('employment_status') == 'stable'):
            return 'APPROVED', self._explain()
        else:
            return 'DENIED', self._explain()

    def _explain(self):
        return {k: v for k, v in self.facts.items()}

# Usage
system = ExpertSystem()
system.assert_fact('credit_score', 720)
system.assert_fact('monthly_debt', 800)
system.assert_fact('monthly_income', 3500)
system.assert_fact('employment_years', 3)
decision, explanation = system.run()
print(f"Decision: {decision}")
print(f"Reasoning: {explanation}")
</syntaxhighlight>

; Symbolic AI tools and languages
: '''Prolog''' → Logic programming, backward chaining; used in NLP parsing, planning
: '''Clips''' → C Language Integrated Production System; forward-chaining rule engine
: '''Drools''' → Java-based business rule management system; widely used in enterprise
: '''OWL/RDF''' → Web Ontology Language; semantic web knowledge representation
: '''SPARQL''' → Query language for RDF knowledge graphs
: '''Planning Domain Definition Language (PDDL)''' → Standard for AI planning problems
</div>

<div style="background-color: #8B4500; color: #FFFFFF; padding: 20px; border-radius: 8px; margin-bottom: 15px;">
== <span style="color: #FFFFFF;">Analyzing</span> ==
{| class="wikitable"
|+ Symbolic AI vs. Neural AI Comparison
! Property !! Symbolic AI !! Neural AI (ML)
|-
| Data requirements || Low (rules are hand-coded) || High (needs training data)
|-
| Interpretability || Full (every rule inspectable) || Low (black box)
|-
| Robustness to noise || Poor (strict rule matching) || High (learned tolerance)
|-
| Generalization || Poor (combinatorial explosion) || High (pattern generalization)
|-
| Formal verification || Possible || Very difficult
|-
| Domain expertise required || Very high (knowledge engineers) || Moderate (ML engineers + data)
|-
| Handling uncertainty || Limited (fuzzy logic, certainty factors) || Natural (probabilistic outputs)
|}

'''Failure modes:'''
* '''Knowledge acquisition bottleneck''' — Encoding an expert's knowledge into rules is enormously time-consuming. Even experts cannot always articulate their reasoning explicitly.
* '''Brittleness''' — Rules fail on inputs not explicitly anticipated. A medical rule might fail on a patient with an atypical presentation. Neural networks generalize; rule systems cannot.
* '''Rule conflict''' — As rule bases grow, rules can produce contradictory conclusions. Conflict resolution strategies (priority, specificity, recency) add complexity.
* '''Maintenance burden''' — As the domain evolves, the rule base must be updated. In fast-moving domains, this becomes unsustainable.
* '''Closed-world assumption''' — Classical symbolic systems assume anything not known is false. This breaks in open-world settings.
</div>

<div style="background-color: #483D8B; color: #FFFFFF; padding: 20px; border-radius: 8px; margin-bottom: 15px;">
== <span style="color: #FFFFFF;">Evaluating</span> ==
Evaluating symbolic AI systems requires different approaches than evaluating ML models:

'''Completeness''': Does the rule base cover all scenarios in the domain? Measure by presenting the system with diverse domain scenarios and checking for "no conclusion reached" failures.

'''Consistency''': Are there rules that could produce contradictory conclusions for the same input? Formal verification tools can check this exhaustively.

'''Coverage vs. precision''': Measure recall (what fraction of correct conclusions does the system reach?) vs. precision (what fraction of the system's conclusions are correct?).

'''Explanation quality''': Do the explanations generated by the system match the reasoning a domain expert would use? Evaluate with expert review.

Expert practitioners combine symbolic evaluation with ablation — systematically removing or disabling individual rules and measuring the impact on overall system performance, identifying which rules carry the most diagnostic weight.
</div>

<div style="background-color: #2F4F4F; color: #FFFFFF; padding: 20px; border-radius: 8px; margin-bottom: 15px;">
== <span style="color: #FFFFFF;">Creating</span> ==
Designing a production expert system or neuro-symbolic hybrid:

'''1. Pure symbolic system design process'''
<syntaxhighlight lang="text">
Domain scoping: define input variables, output decisions, domain boundaries
    ↓
Knowledge elicitation: structured interviews with domain experts
    ↓
Rule extraction: convert expertise to IF-THEN form; assign certainty factors
    ↓
Knowledge base encoding: implement in Drools, CLIPS, or Prolog
    ↓
Validation: test with domain experts using known cases
    ↓
Conflict resolution: identify and resolve contradictory rules
    ↓
Deployment with explanation logging
</div>