--- title: Reasoning Systems and Default Logic module: Logic and Planning moduleNumber: 3 lessonNumber: 12 order: 312 summary: > Having represented the world, this part is about reasoning with it at scale. Semantic networks give a graphical notation with fast inheritance; description logics keep subsumption and classification tractable by design. Then we confront the fact that most useful rules hold only by default: circumscription and default logic give a logical account of nonmonotonic reasoning, and truth maintenance systems retract conclusions cleanly when the beliefs beneath them change. topics: [Logic] sources: - book: AIMA ref: "Ch. 12 — Knowledge Representation; §12.5 Reasoning Systems for Categories" - book: AIMA ref: "§12.6 Reasoning with Default Information" --- This builds on [Knowledge Representation](/artificial-intelligence/logic-and-planning/knowledge-representation), which built the content of a knowledge base: an upper ontology, categories and composed objects, events reified through the event calculus, and belief modeled in modal logic. Here we turn to the machinery that makes such a base practical. ## Reasoning systems for categories Categories are the primary building blocks of large-scale knowledge bases, and two families of systems are built specifically to organize and reason with them. **Semantic networks** give a graphical notation and fast inheritance algorithms; **description logics** give a formal language for defining and combining categories, with efficient tests for subset and superset relations. ### Semantic networks A semantic network displays objects and categories as nodes and relations as labeled links. A $MemberOf$ link from $Mary$ to $FemalePersons$ encodes $Mary \in FemalePersons$; a $SisterOf$ link between $Mary$ and $John$ encodes $SisterOf(Mary, John)$; $SubsetOf$ links chain categories upward. Despite an old rivalry between "logic" and "semantic networks," a semantic net with well-defined semantics simply _is_ a form of logic — a more convenient human interface over the same objects, relations, and quantification. $$ % caption: A semantic network with four objects (John, Mary, 1, 2) and four % categories. A single-boxed Legs link asserts a property of every member; the % double-boxed HasMother link asserts a relation that holds for each member % individually. John's own Legs link (value 1) overrides the inherited default 2. \begin{tikzpicture}[>=stealth, font=\footnotesize, cat/.style={draw, ellipse, minimum width=16mm, minimum height=8mm, font=\scriptsize, align=center}, obj/.style={draw, minimum width=11mm, minimum height=6mm, font=\scriptsize}, lbl/.style={font=\scriptsize, text=black, inner sep=1.5pt}] \definecolor{acc}{HTML}{2348F2} \node[cat] (mam) at (0,3.2) {Mammals}; \node[cat] (per) at (0,1.7) {Persons}; \node[cat] (fem) at (-2.5,0.2) {Female\\Persons}; \node[cat] (mal) at (2.5,0.2) {Male\\Persons}; \node[obj] (mary) at (-2.5,-1.6) {Mary}; \node[obj] (john) at (2.5,-1.6) {John}; \node[obj] (two) at (2.6,1.7) {2}; \node[obj] (one) at (4.2,-1.6) {1}; % property links \draw[->] (per) -- (mam) node[lbl, midway, right] {SubsetOf}; \draw[->] (fem) -- (per) node[lbl, midway, above, sloped] {SubsetOf}; \draw[->] (mal) -- (per) node[lbl, midway, above, sloped] {SubsetOf}; \draw[->] (mary) -- (fem) node[lbl, midway, left] {MemberOf}; \draw[->] (john) -- (mal) node[lbl, midway, right] {MemberOf}; \draw[->] (mary) -- (john) node[lbl, midway, below] {SisterOf}; % single-boxed Legs (property of every member) \draw[double, ->, acc] (per) -- (two) node[lbl, midway, above, text=acc] {Legs}; \draw[->, acc] (john) -- (one) node[lbl, midway, below, text=acc] {Legs}; \end{tikzpicture} $$ Inheritance runs by following $MemberOf$ up to a category, then $SubsetOf$ links upward until a boxed property link is found. Mary has two legs because $Persons$ has a $Legs$ link with value 2 and $Mary \in FemalePersons \subset Persons$. The simplicity and transparency of this inference — you can see exactly which links the procedure will traverse — is the main attraction over general theorem proving. Two complications matter. Links are binary, so an $n$-ary assertion like $Fly(Shankar, NewYork, NewDelhi, Yesterday)$ cannot be drawn directly; the fix is to reify the proposition as an event object with $Agent$, $Origin$, $Destination$, and $During$ links — the same reification move from earlier, now forced by the notation. And **multiple inheritance**, where an object belongs to two categories offering conflicting values, can make the inheritance algorithm find two answers; some object-oriented languages ban it outright, but semantic networks usually allow it and defer the conflict to default reasoning. ### Description logics **Description logics** formalize what a semantic network _means_ while keeping taxonomic structure central. They are notations designed to make it easy to describe and combine category definitions. The two principal inference tasks are: > **Definition (Subsumption and classification).** **Subsumption** decides whether > one category is a subset of another by comparing their definitions. **Classification** > decides whether a given object belongs to a category. Some systems also test > **consistency** — whether a category's membership criteria are logically > satisfiable at all. A description-logic language such as CLASSIC builds concepts from an algebra of operators on predicates — something first-order logic cannot do. Bachelors are unmarried adult males: $$ Bachelor = And(Unmarried, Adult, Male) $$ Concepts combine with constructors like $All(role, concept)$ (every filler of a role is in a concept), $AtLeast(n, role)$ and $AtMost(n, role)$ (cardinality bounds, the clean version of the "exactly two legs" problem), and $Fills(role, individual)$. Men with at least three unemployed, married sons who all married doctors, and at most two daughters who are all physics-or-math professors: $$ And(Man,\; AtLeast(3, Son),\; AtMost(2, Daughter),\; All(Son, And(Unemployed, Married, All(Spouse, Doctor))),\; \ldots) $$ The point of description logics is tractability. A problem is posed by describing it and asking which of several solution categories subsumes it, and the design goal is that subsumption testing run in time polynomial in the size of the descriptions. The cost is that keeping subsumption tractable usually means giving up general _negation_ and _disjunction_, which force a first-order system into exponential case analysis. So either hard problems cannot be stated, or they need exponentially large descriptions — but the tractability results at least tell a designer which constructs are expensive. The subsumption relation over concepts forms a lattice, and classification finds where a new concept fits into it. $$ % caption: A subsumption lattice. Each upward edge means the lower concept is % subsumed by (is a subset of) the upper; classifying a new concept means % inserting it at the right place, below everything that subsumes it and above % everything it subsumes. \begin{tikzpicture}[>=stealth, font=\footnotesize, c/.style={draw, minimum width=20mm, minimum height=7mm, font=\scriptsize}] \definecolor{acc}{HTML}{2348F2} \node[c, draw=acc, text=acc] (thing) at (0,3.2) {Thing}; \node[c] (person) at (-2.6,1.8) {Person}; \node[c] (adult) at (2.6,1.8) {Adult}; \node[c] (male) at (0,1.8) {Male}; \node[c] (aman) at (1.3,0.4) {AdultMale}; \node[c] (bach) at (-1.3,-1.0) {Bachelor}; \draw[->, black] (person) -- (thing); \draw[->, black] (male) -- (thing); \draw[->, black] (adult) -- (thing); \draw[->, black] (aman) -- (adult); \draw[->, black] (aman) -- (male); \draw[->, black] (bach) -- (person); \draw[->, black] (bach) -- (aman); \end{tikzpicture} $$ The edge from $Bachelor$ up to $AdultMale$ in the lattice is not drawn by hand — a classifier derives it by comparing definitions. Take $$ Bachelor = And(Unmarried, Adult, Male) \qquad AdultMale = And(Adult, Male) $$ Subsumption between conjunctions has a syntactic test: $And(A_1, \ldots, A_m)$ is subsumed by $And(B_1, \ldots, B_n)$ exactly when every conjunct $B_j$ on the right is subsumed by some conjunct on the left. To ask whether $Bachelor$ is subsumed by $AdultMale$, check each conjunct of $AdultMale$ against the conjuncts of $Bachelor$. The right side's $Adult$ matches $Bachelor$'s $Adult$; the right side's $Male$ matches $Bachelor$'s $Male$. Both conjuncts on the right are covered, so $Bachelor \sqsubseteq AdultMale$ — every bachelor is an adult male. The reverse fails: $AdultMale$'s definition has no conjunct subsumed by $Bachelor$'s $Unmarried$, so a married adult male is an adult male but not a bachelor, and $AdultMale \not\sqsubseteq Bachelor$. The subsumption is strict, which is why the lattice draws $Bachelor$ strictly below $AdultMale$. Classification runs the same test to place an individual. Suppose the knowledge base holds $George \in And(Man, Unmarried, Adult)$, where $Man = And(Male, Adult)$ has already been reduced. Flattening the conjunction gives $And(Male, Adult, Unmarried)$, which by the same conjunct-matching test is subsumed by $And(Unmarried, Adult, Male) = Bachelor$. The classifier therefore concludes $George \in Bachelor$ without any rule mentioning George — the membership falls out of the definitions. Adding the fact $Married(George)$ later makes $George \in Unmarried$ unsatisfiable, and a consistency check flags the contradiction rather than silently deriving a false membership. Description logics matured into **OWL**, the Web Ontology Language of the Semantic Web, where machine-readable ontologies annotate Web resources and a reasoner classifies and checks them. That is the industrial descendant of the taxonomic tradition running back through semantic networks. ## Reasoning with default information The semantic-net example already leaked a non-classical idea: the assertion "all persons have two legs" had only _default_ status, overridden for John. In a strictly logical knowledge base that would be a flat contradiction. Handling it properly means giving up **monotonicity** — the property, from [propositional logic](/artificial-intelligence/logic-and-planning/propositional-logic), that adding sentences never retracts a conclusion. Commonsense reasoning is routinely **nonmonotonic**: seeing a parked car you believe it has four wheels though only three are visible, and you retract that only if new evidence (the owner carrying a wheel, the car jacked up) arrives. Two ideas are the setting for this. The **closed-world assumption** takes any proposition not entailed by the knowledge base to be false — useful, but crude. Later we prefer the graded alternative of [probability](/artificial-intelligence/uncertainty/probability-and-bayes), where a belief has a degree rather than a bare default; this section is the logical route to the same problem. ### Circumscription and default logic **Circumscription** is a sharper closed-world assumption: name particular predicates that are assumed "as false as possible" — false for every object except those known to make them true. To encode "birds fly by default," introduce an abnormality predicate and write: $$ Bird(x) \land \lnot Abnormal_1(x) \;\Rightarrow\; Flies(x) $$ Circumscribing $Abnormal_1$ lets a reasoner assume $\lnot Abnormal_1(x)$ unless told otherwise, so $Flies(Tweety)$ follows from $Bird(Tweety)$ — but is withdrawn the moment $Abnormal_1(Tweety)$ is asserted. Circumscription is a **model preference** logic: a sentence is entailed with default status if it holds in all _preferred_ models (here, those with the fewest abnormal objects), rather than in all models. The classic example is the **Nixon diamond**: Nixon is a Quaker (so a pacifist by default) and a Republican (so not a pacifist by default). $$ % caption: The Nixon diamond. Nixon inherits pacifism from Quaker and % non-pacifism from Republican; the two default paths conflict, and a plain % circumscriptive reasoner has two preferred models, staying agnostic about % Pacifist(Nixon). \begin{tikzpicture}[>=stealth, font=\footnotesize, c/.style={draw, minimum width=18mm, minimum height=7mm, font=\scriptsize}] \definecolor{acc}{HTML}{2348F2} \definecolor{red}{HTML}{C0392B} \node[c] (quaker) at (-2.6,1.6) {Quaker}; \node[c] (repub) at (2.6,1.6) {Republican}; \node[c, draw=acc, text=acc] (nixon) at (0,-2.3) {Nixon}; \node[c] (pac) at (-2.6,-1.0) {Paci\/f\/ist}; \node[c] (npac) at (2.6,-1.0) {not Paci\/f\/ist}; \draw[->, black] (nixon) to[out=150, in=-90] (quaker); \draw[->, black] (nixon) to[out=30, in=-90] (repub); \draw[->, acc] (quaker) -- (pac) node[midway, left, font=\scriptsize, text=black] {default}; \draw[->, red] (repub) -- (npac) node[midway, right, font=\scriptsize, text=black] {default}; \draw[<->, black, dashed] (pac) -- (npac) node[midway, above, font=\scriptsize] {con\/f\/lict}; \end{tikzpicture} $$ A plain reasoner has two preferred models and stays agnostic about whether Nixon is a pacifist. **Prioritized circumscription** breaks the tie by minimizing one abnormality predicate ahead of another, letting religious defaults, say, take precedence over political ones. **Default logic** takes a different route, with **default rules** of the form $P : J_1, \ldots, J_n / C$: given prerequisite $P$, and if each justification $J_i$ is _consistent_ with the knowledge base, conclude $C$. "Birds fly" is $Bird(x) : Flies(x) / Flies(x)$. The Nixon diamond becomes two default rules, one concluding $Pacifist(x)$ and one $\lnot Pacifist(x)$. The meaning of a set of default rules is given by its **extensions** — maximal consistent sets of conclusions, each a coherent way of applying the defaults. The Nixon diamond has two extensions, one where he is a pacifist and one where he is not. Open problems remain. If "cars have four wheels" is a default, what exactly does it mean to hold it in a knowledge base, and what is a good set of default rules — if we cannot decide rule by rule whether one belongs, we have a nonmodularity problem. And using default beliefs to make decisions, weighing the strength of a belief against the cost of a wrong action, is the hardest issue, pushing toward embedding default reasoning inside probability or utility theory. ### Truth maintenance systems Many conclusions in a knowledge base have only default status and will sometimes turn out wrong, so they must be retractable. Retracting is not as simple as deleting. Suppose the base contains $P$, and $P \Rightarrow Q$ was used to add $Q$. Naively retracting everything inferred from $P$ removes $Q$ — but $Q$ may have _other_ justifications ($R$ and $R \Rightarrow Q$), so it should survive. A **truth maintenance system** (TMS) manages exactly these dependencies. This is **belief revision**: revising the base to reflect new information about a fixed world. The naive approach numbers sentences $P_1, \ldots, P_n$ by insertion order; to retract $P_i$, undo everything back to just before it and reassert the rest. Correct, but retracting $P_i$ costs $n - i$ reassertions and re-derivations — impractical when facts pour in. A **JTMS** (justification-based TMS) is smarter: annotate each sentence with a **justification**, the set of sentences it was inferred from. If $P \Rightarrow Q$ is present and $\textsc{Tell}(P)$ fires, $Q$ is added with justification $\{P, P \Rightarrow Q\}$. On $\textsc{Retract}(P)$, the JTMS deletes exactly those sentences for which $P$ is in _every_ justification. If $Q$ also had justification $\{R, R \Rightarrow Q\}$, it survives. Rather than deleting a sentence that loses all justifications, the JTMS marks it **out** (and **in** when a justification is restored), so inference chains are kept and need not be rederived. $$ % caption: A JTMS dependency network. $Q$ has two independent justifications, so % retracting $P$ (which removes the left one) leaves $Q$ in via the right one; a % node goes out only when it loses every justification. \begin{tikzpicture}[>=stealth, font=\footnotesize, f/.style={draw, minimum width=13mm, minimum height=7mm, font=\scriptsize}, j/.style={draw, circle, minimum size=5mm, inner sep=0pt, font=\scriptsize}] \definecolor{acc}{HTML}{2348F2} \definecolor{red}{HTML}{C0392B} \node[f, draw=red, text=red] (p) at (0,2.4) {P}; \node[f] (pq) at (0,0.9) {P$\Rightarrow$Q}; \node[f] (r) at (5.2,2.4) {R}; \node[f] (rq) at (5.2,0.9) {R$\Rightarrow$Q}; \node[j] (j1) at (1.6,1.65) {and}; \node[j] (j2) at (3.6,1.65) {and}; \node[f, draw=acc, text=acc] (q) at (2.6,-0.7) {Q (in)}; \draw[->, red] (p) -- (j1); \draw[->, black] (pq) -- (j1); \draw[->, black] (r) -- (j2); \draw[->, black] (rq) -- (j2); \draw[->, black] (j1) -- (q); \draw[->, acc] (j2) -- (q); \node[red, font=\scriptsize, anchor=west] at (0.2,2.9) {retracted}; \node[acc, font=\scriptsize, anchor=west] at (3.4,-0.7) {survives via R}; \end{tikzpicture} $$ A concrete trace shows what "in every justification" means. Put five sentences in the base and let the JTMS record the justification set of each derived one: | Sentence | Justification set | Status | | --- | --- | --- | | $Rains$ | $\{\}$ (premise) | in | | $Sprinkler$ | $\{\}$ (premise) | in | | $Rains \Rightarrow WetGrass$ | $\{\}$ (premise) | in | | $Sprinkler \Rightarrow WetGrass$ | $\{\}$ (premise) | in | | $WetGrass$ | $\{Rains,\, Rains \Rightarrow WetGrass\}$ | in | Firing $Sprinkler \Rightarrow WetGrass$ adds a _second_ justification for the same node, so $WetGrass$ now carries two: $$ J_1 = \{Rains,\; Rains \Rightarrow WetGrass\} \qquad J_2 = \{Sprinkler,\; Sprinkler \Rightarrow WetGrass\} $$ Now call $\textsc{Retract}(Rains)$. The JTMS deletes only sentences with $Rains$ in _every_ justification. $WetGrass$ fails that test: $Rains \in J_1$ but $Rains \notin J_2$, so $J_2$ still supports it and $WetGrass$ stays **in**, its label narrowed to $\{J_2\}$. Retract $Sprinkler$ as well and $J_2$ dies too; with no justification left, $WetGrass$ is marked **out** rather than erased, so if either premise returns the node flips back **in** with no re-derivation of the implication chains. Compare the naive insertion-order scheme, which on $\textsc{Retract}(Rains)$ would blindly undo $WetGrass$ and every later sentence and then reassert them one by one. TMSs also speed up analysis of multiple hypothetical situations. Choosing Olympic sites, a great deal of reasoning follows from $Site(Athletics, Bucharest)$; to consider $Site(Athletics, Sibiu)$ instead, retract the first, assert the second, and the TMS revises only what depends on the change — inference chains not touching the choice are reused. An **ATMS** (assumption-based TMS) goes further. A JTMS represents one state at a time; an ATMS keeps _all_ states considered so far, labeling each sentence not simply in or out but with the set of assumption sets under which it holds. This makes context-switching between hypothetical worlds nearly free. ATMSs also generate **explanations**: an explanation of $P$ is a set of sentences $E$ that entails $P$, possibly including **assumptions** — sentences not known true but which would suffice. For "car won't start," an ATMS makes assumptions like "battery dead" or "no gas" in any order, then reads off from $P$'s label which assumption sets would justify it. The label is the whole mechanism. Designate a set of **assumptions** $\{BatteryDead, NoGas, StarterBroken\}$ — sentences the reasoner may posit but does not know true. Each derived sentence is labelled with a set of assumption sets, where every member is a minimal collection of assumptions sufficient to derive it. Given the rules $BatteryDead \Rightarrow WontStart$, $NoGas \Rightarrow WontStart$, and $StarterBroken \Rightarrow WontStart$, the label of $WontStart$ becomes $$ L(WontStart) = \{\, \{BatteryDead\},\; \{NoGas\},\; \{StarterBroken\} \,\} $$ read as: the car fails to start under any one of these assumptions. A sentence requiring two assumptions at once, say $DimLights$ needing both a weak battery and lights left on, would carry a label whose member is the two-element set $\{BatteryDead, LightsOn\}$. $$ % caption: An ATMS label. Each derived sentence carries a set of minimal assumption % sets; WontStart holds under any one of three single-assumption sets, so its label % has three members, while a conclusion needing two assumptions carries a % two-element set. Reading the label off gives every diagnosis at once. \begin{tikzpicture}[>=stealth, font=\footnotesize, a/.style={draw, minimum width=24mm, minimum height=6.5mm, font=\scriptsize, fill=black!6}, concl/.style={draw, minimum width=22mm, minimum height=7mm, font=\scriptsize}, lab/.style={font=\scriptsize, text=black, align=center}] \definecolor{acc}{HTML}{2348F2} \node[a] (b) at (0,2.4) {BatteryDead}; \node[a] (g) at (0,1.2) {NoGas}; \node[a] (s) at (0,0.0) {StarterBroken}; \node[concl, draw=acc, text=acc] (w) at (5.2,1.2) {WontStart}; \draw[->, black] (b) -- (w); \draw[->, black] (g) -- (w); \draw[->, black] (s) -- (w); \node[lab, anchor=west] at (7.0,1.9) {label of WontStart}; \node[lab, anchor=west] at (7.0,1.4) {set 1: BatteryDead}; \node[lab, anchor=west] at (7.0,1.0) {set 2: NoGas}; \node[lab, anchor=west] at (7.0,0.6) {set 3: StarterBroken}; \node[acc, font=\scriptsize, anchor=north] at (5.2,0.4) {holds under any one}; \end{tikzpicture} $$ Because the label is computed once and updated incrementally as rules fire, the reasoner never re-solves the diagnosis when it switches from considering $BatteryDead$ to considering $NoGas$; both contexts are already recorded in the label. That is the trade the ATMS makes against the JTMS: more bookkeeping per sentence, but every hypothetical context available at once instead of one at a time. Truth maintenance is not free — its complexity is at least that of propositional inference, so it is NP-hard. Used carefully, though, a TMS gives a logical system a real increase in its ability to cope with complex environments and hypotheses. ## From description logics to OWL and the Semantic Web The taxonomic tradition described here — semantic networks, then description logics with subsumption and classification — became a deployed standard. The **Web Ontology Language (OWL)** was published as a W3C recommendation in 2004 and revised as **OWL 2** in 2009, and its expressive dialect OWL 2 DL is grounded in a specific description logic. Horrocks, Kutz, and Sattler, in "The Even More Irresistible SROIQ" (KR 2006), defined that logic, $\mathcal{SROIQ}$, by extending an earlier one with complex role-inclusion axioms, qualified number restrictions, and reflexive and irreflexive roles, and gave a tableau reasoning procedure for it; their paper is the logical basis W3C adopted for OWL 2. The constructors are the same $All$, $AtLeast$, $AtMost$, and $Fills$ this lesson used, formalized to the point of a decidability proof. $$ % caption: The line from this lesson's machinery to deployed standards. Semantic % networks and description logics feed the SROIQ logic behind OWL 2; tableau % reasoners such as HermiT decide subsumption and classification over ontologies; % knowledge graphs like Wikidata supply the facts at Web scale. \begin{tikzpicture}[>=stealth, font=\footnotesize, b/.style={draw, minimum width=30mm, minimum height=8mm, font=\scriptsize, align=center}] \definecolor{acc}{HTML}{2348F2} \node[b] (dl) at (0,2.2) {description logics\\(this lesson)}; \node[b, draw=acc, text=acc] (sroiq) at (0,0.4) {SROIQ / OWL 2}; \node[b] (hermit) at (5.4,2.2) {tableau reasoner\\(HermiT)}; \node[b] (kg) at (5.4,0.4) {knowledge graph\\(Wikidata)}; \draw[->, black] (dl) -- (sroiq); \draw[->, black] (sroiq) -- (hermit) node[midway, above, font=\scriptsize] {decides}; \draw[->, black] (sroiq) -- (kg) node[midway, above, sloped, font=\scriptsize] {schema for}; \end{tikzpicture} $$ Deciding subsumption over such a logic needs an actual reasoner. **HermiT**, described by Glimm, Horrocks, Motik, Stoilos, and Wang in the _Journal of Automated Reasoning_ (2014), is an OWL 2 reasoner built on a hypertableau calculus; it performs classification, entailment checking, and consistency testing over OWL ontologies and is compliant with the OWL 2 direct semantics standardized by the W3C. It is the industrial version of the subsumption and consistency tests this lesson stated abstractly. The other modern current is the large curated store of facts. **Wikidata**, described by Vrandečić and Krötzsch in _Communications of the ACM_ (2014), is a free, collaboratively edited knowledge base built to hold the structured, multilingual factual data behind Wikipedia; it represents facts as items with property-value statements, a reification of the same object-relation structure this lesson began with. Earlier, Miller's **WordNet** (_Communications of the ACM_, 1995) organized English nouns, verbs, adjectives, and adverbs into synonym sets linked by hyponym and other lexical relations — a hand-built taxonomy of word senses that became a standard resource in language processing. Between the reasoners and the fact stores, the two halves of this subject — the machinery here and the content of the previous lesson — each have a deployed descendant. ## Where this sits First-order logic supplies the language; these two lessons cover using it well at scale. An ontology fixes the top-level categories; reification turns categories, propositions, and events into objects you can quantify over and pin facts to; the event calculus threads time and change through the whole thing; modal logic represents agents' beliefs. On top of that content, description logics keep subsumption tractable, and default reasoning with a truth maintenance system lets conclusions be held tentatively and withdrawn cleanly when the beliefs beneath them change. The recurring problem across all of it is exceptions — most useful rules hold only by default. The logical treatments here (circumscription, default logic, TMSs) buy retractability but not _degree_: they cannot say a car has four wheels with probability $0.99$. That graded account is the alternative developed under [uncertainty](/artificial-intelligence/uncertainty/probability-and-bayes), where the same commonsense inferences reappear as conditioning on evidence rather than overriding a default.