Expert Systems

1A KB plus an engine, not a trained score

An expert system is a program that answers a case by running an inference procedure over a knowledge base a person wrote. The clinic desk does not fit a fever-to-refer model on past visits. It stores rules such as 'if fever and a cough lasting three days, refer', and an engine that matches those rules against today's symptoms. The answer is a derived conclusion, in the sense of the last two logic lessons, not a score.

That split — authored KB, separate engine — is the definition. A long Python script with the same ifs inlined into the user interface is an ordinary program. A neural net that predicts 'refer' from a table of past visits is a learned model. Both can be useful. Neither is this architecture. The hybrid lesson is where those two meet a rule layer; this lesson stays inside the classical box.

Coding lab. Forward chaining rule engine runs in the app, with checks on your output.

2The four boxes

Four pieces recur. The knowledge base holds the lasting rules and facts of the domain — 'fever plus a three-day cough means refer'. Working memory holds this case: the symptoms entered so far, and the conclusions the engine has already added. The inference engine is the matcher — typically forward or backward chaining from the last lesson — that compares working memory with the KB and fires. The user interface asks the next missing symptom and, when asked, shows which rule just fired.

The engine does not contain clinic knowledge. The KB does not contain the match loop. That separation is what lets a shell, later in this lesson, ship an engine with no rules in it, and what lets a knowledge engineer swap a rule without rewriting the matcher.

Figure. The engine sits between the user and two stores: the lasting KB and this-case working memory. Edges are the match and the I/O, not a data-flow animation. Labels are short on purpose.

3Three roles around the KB

Three people, or three hats, sit around the clinic desk. The domain expert is the campus doctor who already knows when to refer. The knowledge engineer interviews that doctor, writes the rules, and keeps them consistent. The end user is the desk volunteer who answers 'fever?' and reads 'refer' — they do not edit the KB.

The hybrid lesson's bottleneck is this interview. Experts disagree, they forget the exception they used last Tuesday, and the written rule is a frozen picture of a moving clinic. This lesson only needs the cast: if one person is doctor, engineer and volunteer, the architecture can still run, and the failure modes of acquisition are still theirs. Do not retell MYCIN's evaluation here; that measurement lives on the other page.

4Heuristics and meta-knowledge

A domain heuristic is a rule of thumb written as a rule: 'if the fever started after an all-nighter and there is no cough, ask about sleep before referring'. It can be wrong, and it is still knowledge — the doctor uses it, so the KB may store it, tagged as a heuristic rather than as a hard constraint. The last search lessons used heuristic in a different sense (an h(n)). Here the word is the expert's shortcut, not an admissible estimate.

Meta-knowledge is knowledge about the knowledge: which rule to try first, when to stop asking questions, when a conflict between two rules should prefer the more specific one. 'Try infection rules before lifestyle rules' is not a clinic fact; it is a fact about the KB. Shells expose a conflict-resolution strategy — recency, specificity, a declared priority — so that meta-knowledge has a place to live that is not another inlined if.

5A shell is an empty engine

A shell is the inference engine, the working-memory store, the I/O, and the conflict strategy — with no clinic rules in it. CLIPS, Jess, and the 1980s commercial tools are shells in this sense. You load a KB; you have an expert system. You load a different KB; you have a different expert system on the same engine. The shell is reusable precisely because the last concepts kept the engine ignorant of the domain.

Building from scratch means writing the matcher yourself. That is justified when the inference is not chaining — a special constraint solver, a temporal engine — and it is wasted effort when the clinic rules are ordinary definite clauses. The hybrid lesson's modern picture (a learned proposer behind a validator) is a different architecture again: the validator is a KB-shaped gate, not a shell waiting for a MYCIN-sized rule base. Use this lesson's names for the classical machine; use that lesson's names for the split with learning.