Knowledge Representation and Symbolic Reasoning

Introduction

Artificial intelligence systems require more than data and computational power. They also need ways to represent what is known about the world and mechanisms for deriving conclusions from that knowledge. Knowledge representation (KR) is the study and engineering of formal structures that allow an AI system to store, organize, interpret, and reason with information. Symbolic reasoning refers to inference over symbols representing objects, properties, relations, events, and rules.

Although contemporary AI often emphasizes machine learning, symbolic methods remain essential in domains requiring explainability, consistency, explicit constraints, legal compliance, and reasoning over sparse or structured information. Medical diagnosis, configuration, planning, cybersecurity, digital assistants, industrial maintenance, and regulatory analysis all benefit from representations in which the premises leading to a conclusion can be inspected.

This chapter examines propositional and first-order logic, production rules, semantic networks, ontologies, knowledge graphs, and expert systems. It also considers inference strategies, uncertainty, inconsistency, explainability, and the integration of symbolic reasoning with modern AI.

Learning Objectives

After completing this chapter, the reader should be able to:

1. Explain the role and architecture of knowledge representation systems.

2. Translate simple statements into propositional and first-order logic.

3. Apply logical inference rules, including modus ponens and resolution.

4. Design rule-based systems and distinguish forward from backward chaining.

5. Compare semantic networks, ontologies, and knowledge graphs.

6. Construct explanations for symbolic conclusions.

7. Evaluate the strengths, limitations, governance implications, and contemporary uses of symbolic AI.

1. Knowledge Representation as an AI Discipline

A knowledge-based system generally contains four conceptual elements:

• Knowledge base: Explicit facts, rules, definitions, constraints, and relationships.
• Representation language: A formalism used to encode knowledge.
• Inference engine: Procedures that derive consequences from stored knowledge.
• Interface and explanation component: Mechanisms for acquiring knowledge, answering queries, and showing why a conclusion was reached.

Knowledge representation differs from ordinary data storage. A database may record that a device has a temperature of 90°C. A knowledge base may additionally represent that temperatures above 80°C indicate overheating, overheating requires inspection, and a device in an unsafe state must be isolated. The latter supports inference.

A useful representation should provide:

• Representational adequacy: It can express relevant concepts and relations.
• Inferential adequacy: It supports deriving useful conclusions.
• Inferential efficiency: It permits reasoning with acceptable computational cost.
• Acquisitional efficiency: New knowledge can be added without excessive effort.
• Clarity and maintainability: Experts can inspect and revise it.

These requirements often conflict. Highly expressive formalisms may make inference computationally expensive, whereas restricted rule languages may be efficient but unable to represent complex situations.

Syntax, Semantics, and Pragmatics

The syntax of a representation specifies which expressions are well formed. The semantics specifies what those expressions mean. Pragmatics concerns how the representation is used in a particular task, including priorities, defaults, and interpretation conventions.

For example, `Alarm(Boiler1)` is syntactically an atomic formula in a suitable logical language. Its semantics depends on whether `Alarm` denotes a current state, a past event, or a recommendation. A knowledge engineer must therefore define vocabulary and interpretation, not merely write formal expressions.

2. Propositional Logic

Propositional logic represents complete statements that are either true or false. A proposition is denoted by a symbol such as P or Q. The principal connectives are:

• Negation: ¬P, meaning “not P”
• Conjunction: P ∧ Q, meaning “P and Q”
• Disjunction: P ∨ Q, meaning “P or Q,” usually inclusive
• Implication: P → Q, meaning “if P, then Q”
• Biconditional: P ↔ Q, meaning “P if and only if Q”

An interpretation assigns a truth value to every proposition. A formula is satisfiable if at least one interpretation makes it true, valid if every interpretation makes it true, and unsatisfiable if no interpretation makes it true.

Implication and Equivalence

The implication P → Q is false only when P is true and Q is false. It does not, by itself, imply Q → P. For example:

“If a server is compromised, an alert is generated” does not mean “if an alert is generated, the server is compromised.” The reverse inference is the fallacy of affirming the consequent.

Similarly, P ↔ Q is stronger than P → Q because it asserts both directions:

(P → Q) ∧ (Q → P).

Inference in Propositional Logic

An argument is valid when its conclusion follows from its premises. A fundamental rule is modus ponens:

P, P → Q ⊢ Q

The symbol ⊢ means that Q can be derived syntactically from the premises. If the knowledge base contains `HighLoad` and `HighLoad → CoolingRequired`, then `CoolingRequired` follows.

Another important method is resolution. For clauses of the form (P ∨ Q) and (¬P ∨ R), resolution derives (Q ∨ R). In automated theorem proving, a query can be tested by adding its negation to the knowledge base and attempting to derive the empty clause. This is a refutation procedure and is complete for propositional logic.

Limitations

Propositional logic treats each complete statement as indivisible. It cannot naturally express that several objects share a property or that a relation holds between particular objects. Statements such as “all authenticated users may access the portal” require repeated propositions if represented propositionally. First-order logic addresses this limitation.

3. First-Order Logic

First-order logic (FOL), also called predicate logic, represents objects, properties, and relations. Its vocabulary includes:

• Constants: Names of individuals, such as `Alice` or `Server7`.
• Variables: Symbols such as x and y that range over individuals.
• Predicates: Properties or relations, such as `Employee(x)` or `Manages(x,y)`.
• Functions: Mappings from individuals to individuals, such as `ManagerOf(x)`.
• Quantifiers: Universal (∀) and existential (∃).

Examples include:

∀x (Employee(x) → HasIdentityCard(x))

This states that every employee has an identity card.

∃x (Server(x) ∧ LocatedIn(x, “London”))

This states that at least one server is located in London.

The scope of a quantifier is important. The formula

∀x (Student(x) → ∃y (AdvisedBy(x,y)))

states that every student has at least one adviser, possibly a different adviser for each student. It does not assert that there is one adviser for all students.

Translating Natural Language

Consider the statements:

1. Every encrypted file requires a key.

2. File F17 is encrypted.

3. Therefore, F17 requires a key.

A suitable formalization is:

∀x (EncryptedFile(x) → RequiresKey(x))

EncryptedFile(F17)

By universal instantiation, the first formula yields:

EncryptedFile(F17) → RequiresKey(F17)

Modus ponens then yields `RequiresKey(F17)`.

Care is needed with ambiguous language. “Only administrators may approve a request” means:

∀x (Approves(x, r) → Administrator(x))

It does not necessarily mean that every administrator approves the request. “All and only administrators may approve” would require both directions.

Unification

Unification is the process of finding substitutions that make logical expressions identical. For example, `ReportsTo(x, Manager1)` and `ReportsTo(Ada, y)` unify under x = Ada and y = Manager1. The resulting substitution is called a unifier.

Unification is central to automated inference, particularly in logic programming and rule engines. A substitution must respect variable consistency: in `Knows(x, x)`, both occurrences of x must receive the same value.

Generalization and Inference

FOL supports universal instantiation: from ∀x P(x), infer P(a), where a is an individual in the domain. It also supports existential instantiation under appropriate conditions, but careless use can create invalid conclusions. From ∃x P(x), one may introduce a new symbol referring to an unspecified witness, but one may not assume that this witness is a named individual already in the knowledge base.

The expressive power of FOL has a computational cost. General theorem proving in unrestricted FOL is undecidable: there is no algorithm guaranteed to terminate with a correct yes-or-no answer for every possible input. Practical systems therefore restrict the language, use bounded reasoning, or accept incomplete procedures.

4. Rule-Based Representation and Inference

A production rule has the general form:

IF condition(s) THEN conclusion(s)

For example:

IF `FailedLoginCount(User, n)` and n ≥ 5 THEN `RequireMultiFactorAuthentication(User)`.

Rules separate domain knowledge from the inference mechanism. A rule base may contain facts such as `FailedLoginCount(Ada, 7)` and derive a security action.

Forward Chaining

Forward chaining is data-driven. It begins with known facts, identifies rules whose conditions are satisfied, adds their conclusions, and continues until no new facts can be derived or a target condition is reached.

A simplified agenda-based procedure is:

1. Place initial facts on an agenda.

2. Select a fact and find rules that may be triggered by it.

3. If all conditions of a rule are satisfied, assert its conclusion.

4. Add newly inferred facts to the agenda.

5. Stop when the agenda is empty or a goal is reached.

Forward chaining is suitable for monitoring and situations in which new events continually arrive. Its weakness is that it may derive many facts irrelevant to a particular query.

Backward Chaining

Backward chaining is goal-driven. It begins with a query, searches for rules that could conclude the query, and recursively tries to prove their premises. It is efficient when the number of possible goals is small and is commonly associated with logic programming.

Suppose the goal is `Unsafe(Machine1)`, and the rule is:

`Overheated(x) ∧ PressureHigh(x) → Unsafe(x)`.

The system attempts to prove both `Overheated(Machine1)` and `PressureHigh(Machine1)`, possibly using further rules.

Conflict Resolution

If several rules are applicable, the engine needs a policy. Common strategies include:

• Specificity: Prefer the rule with more detailed conditions.
• Priority: Use an explicit priority assigned by the designer.
• Recency: Prefer rules involving recently added facts.
• Ordering: Use a predetermined sequence.

Conflict policies must be documented because they can affect outcomes. In safety-critical systems, nondeterministic or hidden rule ordering is unacceptable.

Closed-World and Open-World Assumptions

Under the closed-world assumption, failure to prove a statement is treated as evidence that it is false. Many traditional databases use this assumption. Under the open-world assumption, failure to prove a statement means that it is unknown, not false. Knowledge graphs and ontology languages commonly use open-world reasoning.

This distinction is operationally important. If a personnel knowledge base does not state that an employee has completed training, a closed-world system may classify the employee as non-compliant, whereas an open-world system reports that completion status is unknown.

5. Semantic Networks and Ontologies

A semantic network represents knowledge as a graph of nodes and labeled links. Nodes may denote entities or concepts; links may denote relations such as `is-a`, `part-of`, `causes`, or `located-in`.

For example:

`ElectricCar —is-a→ Vehicle`

`ElectricCar —uses→ Battery`

Semantic networks support inheritance. If `ElectricCar` is a subtype of `Vehicle`, properties attached to `Vehicle`, such as having a registration identifier, may be inherited by `ElectricCar`, subject to exceptions and the semantics of the representation.

An ontology is a formal and shared specification of concepts, categories, relations, constraints, and sometimes axioms in a domain. It is more than a diagram: it defines the intended meaning of terms and supports interoperability among systems.

Important ontology components include:

• Classes or concepts, such as `Vehicle` and `Sensor`.
• Individuals, such as `Vehicle_101`.
• Object properties, such as `installedOn`.
• Data properties, such as `hasSerialNumber`.
• Class restrictions and axioms.
• Hierarchical relations, especially subclass relations.

An ontology may state that `ElectricVehicle` is a subclass of `Vehicle`, that `hasBattery` relates a vehicle to a battery, and that every vehicle has at least one identifier. Description logics provide carefully controlled fragments of FOL for ontology reasoning. Languages such as OWL are based on description-logic principles and support automated classification and consistency checking, although the exact computational properties depend on the selected language profile.

Ontology Engineering

Ontology development commonly involves:

1. Defining scope and competency questions.

2. Identifying important terms and synonyms.

3. Establishing class hierarchies.

4. Defining relations, domains, ranges, and constraints.

5. Adding individuals and mappings to external vocabularies.

6. Testing for logical consistency and competency-question coverage.

7. Versioning, governance, and maintenance.

A competency question is a query the ontology should answer, such as “Which machines use batteries manufactured by supplier S?” It prevents ontology development from becoming an unbounded attempt to model an entire domain.

6. Knowledge Graphs

A knowledge graph represents entities and relationships as a graph, often integrating data from heterogeneous sources. A basic triple has the form:

(subject, predicate, object)

For example:

(`Machine17`, `manufacturedBy`, `AcmeEnergy`)

Knowledge graphs may combine schema-level information, instance data, provenance, temporal qualifications, and links to external datasets. Unlike a simple semantic network, a production knowledge graph normally requires data integration pipelines, identity resolution, access control, quality monitoring, and governance.

Graph Construction and Quality

Knowledge graph construction can use databases, documents, application programming interfaces, sensors, and machine-learning extraction systems. Important quality dimensions include:

• Accuracy: Is the assertion correct?
• Completeness: Are important entities and relations missing?
• Timeliness: Is the information current?
• Consistency: Do assertions conflict?
• Provenance: Can the origin and transformation of an assertion be traced?

A graph should distinguish a directly observed fact from an automatically extracted claim or an inferred relation. Provenance enables users to assess confidence and supports auditability.

Querying and Reasoning

Graph query languages, such as SPARQL for RDF-based graphs, retrieve patterns of connected information. Inference may derive subclass relationships, transitive relations, or domain-specific conclusions. However, graph connectivity alone is not reasoning. A path in a graph has meaning only under a defined vocabulary and semantics.

7. Expert Systems

An expert system emulates selected problem-solving capabilities of a human specialist. A typical architecture includes:

• Knowledge acquisition tools.
• A domain knowledge base.
• A working memory containing case-specific facts.
• An inference engine.
• An explanation facility.
• A user interface.

Expert systems became prominent in the 1970s and 1980s. They remain useful when domain rules are relatively stable, decisions must be traceable, and training data are scarce or costly.

Explanation Facilities

An explanation system should answer at least two questions:

• Why was this conclusion reached?
• Why was this conclusion not reached?

A proof trace can show that `Isolate(Machine17)` was inferred from `Overheated(Machine17)` and `UnsafeState(Machine17)` using Rule R12. A contrastive explanation may state that isolation was not recommended for Machine18 because the required evidence of unsafe state was absent.

Explanations must be faithful to the actual inference process. A fluent natural-language explanation generated after the fact is not necessarily a genuine account of how the decision was made.

Knowledge Acquisition Bottleneck

The knowledge acquisition bottleneck is the difficulty of eliciting tacit expertise and translating it into precise rules. Experts may disagree, use context-dependent judgments, or find it difficult to articulate routine practices. Knowledge engineers therefore use interviews, protocol analysis, document analysis, observation, and iterative validation.

8. Worked Application: Industrial Cooling-System Diagnosis

The following is an illustrative case, not a report of a particular real organization.

Background and Problem

A manufacturing plant operates cooling units for high-value equipment. Unplanned overheating causes production loss. Engineers want a diagnostic assistant that recommends inspection and emergency isolation while showing the reasoning behind each recommendation.

Representation

The system stores facts such as:

• `Temperature(Unit7, 92)`
• `FanFailure(Unit7)`
• `PressureNormal(Unit7)`
• `CriticalEquipment(Unit7)`

The unit of temperature is degrees Celsius. Rules include:

R1: If a unit temperature exceeds 80°C, it is overheated.

R2: If a unit is overheated and a fan has failed, cooling inspection is required.

R3: If a critical unit is overheated and pressure is not normal, emergency isolation is required.

R4: If a unit is overheated and pressure is normal, recommend controlled inspection rather than emergency isolation.

R1 can be written as:

Temperature(x, t) ∧ t > 80 → Overheated(x)

R2 is:

Overheated(x) ∧ FanFailure(x) → InspectionRequired(x)

Analysis

From `Temperature(Unit7, 92)` and the condition 92 > 80, the system derives `Overheated(Unit7)`. R2 then derives `InspectionRequired(Unit7)`. R3 cannot fire because the available fact is `PressureNormal(Unit7)`, not abnormal pressure. R4 derives a controlled-inspection recommendation, assuming the rule language represents normal pressure explicitly as a condition.

The explanation is therefore:

1. Unit7 has a measured temperature of 92°C.

2. The overheating threshold is greater than 80°C.

3. Unit7 is classified as overheated.

4. Its fan has failed.

5. Therefore, cooling inspection is required.

6. Because pressure is normal, the emergency-isolation rule is not supported.

Outcome and Learning Points

The system does not replace an engineer. It prioritizes cases, applies documented policy consistently, and exposes missing evidence. The case demonstrates the importance of units, threshold ownership, explicit negative information, and separate recommendations for inspection and isolation. It also shows why a rule base must distinguish “not known to be abnormal” from “known to be normal.”

9. Uncertainty, Defaults, and Inconsistency

Classical logic is monotonic: adding premises does not invalidate an already derived conclusion. Real-world reasoning is often non-monotonic. A conclusion may be withdrawn when new information arrives. For example, a system may normally assume that a vehicle is operational, but withdraw that assumption when a maintenance record is received.

Default reasoning represents typical conditions without treating them as universal truths. A default such as “birds normally fly” must allow exceptions for penguins or injured birds. Default rules require careful conflict handling and should not be confused with strict implications.

Many applications also involve uncertainty. A rule system may attach confidence, probabilities, fuzzy degrees, or evidential weights to assertions. These approaches have different semantics:

• Probability represents uncertainty about events or propositions.
• Fuzzy membership represents degree to which an object satisfies a vague concept.
• Possibility and belief functions represent alternative forms of incomplete evidence.

A system should not present a confidence score as if it were a logical proof. Logical validity and empirical confidence are different properties.

Inconsistency is another practical concern. Two sources may state that an asset is located in two sites. Classical logic can suffer explosion if both P and ¬P are accepted unrestrictedly, because arbitrary conclusions may follow. Practical systems may use source priorities, paraconsistent logics, temporal validity, or inconsistency reports to prevent unreliable conclusions.

10. Challenges, Governance, and Ethics

Scalability and Complexity

Inference can become expensive as the number of entities, rules, and relations grows. Strategies include indexing, modular knowledge bases, restricted logical languages, caching, query planning, and incremental reasoning.

Knowledge Drift

Rules and ontologies become obsolete as regulations, products, terminology, and organizational processes change. Governance should define owners, review intervals, approval workflows, version identifiers, and rollback procedures.

Bias and Fairness

Symbolic systems can encode discriminatory policies explicitly or inherit bias from the experts and sources used to construct them. Explicit rules are not automatically fair. Designers should conduct impact assessments, test outcomes across relevant groups, document policy assumptions, and provide appeal mechanisms.

Privacy and Security

Knowledge graphs may expose sensitive relationships even when individual data fields appear harmless. Access controls, minimization, encryption, purpose limitation, retention policies, and provenance are essential. Rules themselves may reveal confidential business logic.

Accountability

In high-impact applications, an organization should be able to identify which data, ontology version, rule version, and inference path produced a decision. Audit logs should record changes and user interventions. Human oversight is particularly important when recommendations affect safety, employment, healthcare, finance, or access to essential services.

11. Contemporary Developments and Best Practices

Modern AI increasingly combines neural and symbolic approaches. Neural models can extract entities and relations from unstructured text, while symbolic systems validate constraints, perform structured inference, and provide traceable conclusions. Retrieval-augmented generation can use knowledge graphs to ground responses, but retrieved statements still require provenance and verification.

Neuro-symbolic systems may use learned representations together with logical constraints, differentiable reasoning, program synthesis, or symbolic planners. These approaches are promising but introduce integration challenges: learned components may produce uncertain or incorrect facts, while symbolic components may be brittle when inputs are ambiguous.

Recommended practices include:

1. Define the decision scope and competency questions before selecting a formalism.

2. Separate schema, domain facts, rules, provenance, and user-specific working memory.

3. Use explicit identifiers, units, time intervals, and source metadata.

4. Distinguish false, unknown, and not applicable states.

5. Test rules with normal, boundary, exceptional, and conflicting cases.

6. Use version control, peer review, automated consistency checks, and regression tests.

7. Design explanations during system development rather than adding them later.

8. Measure precision, recall, coverage, latency, contradiction rates, and human acceptance where appropriate.

9. Limit inference depth or language expressiveness when predictable performance is required.

10. Establish governance for privacy, fairness, access, accountability, and retirement of obsolete knowledge.

Chapter Summary

Knowledge representation gives AI systems formal structures for storing concepts, facts, relations, rules, and constraints. Propositional logic represents whole statements, while first-order logic represents individuals, properties, relations, and quantified claims. Modus ponens, resolution, unification, and quantifier-based inference support automated reasoning, although unrestricted first-order theorem proving is computationally difficult.

Rule-based systems use forward chaining for data-driven inference and backward chaining for goal-directed inference. Semantic networks provide graph-based conceptual organization, while ontologies add formal meaning, constraints, and shared domain vocabulary. Knowledge graphs integrate entities and relationships across heterogeneous sources and require attention to provenance, quality, identity, and governance. Expert systems combine a knowledge base, inference engine, working memory, interface, and explanation facility.

Practical systems must address uncertainty, defaults, inconsistency, closed-world versus open-world assumptions, scalability, knowledge drift, privacy, fairness, and accountability. Contemporary neuro-symbolic systems combine learned extraction or representation with explicit constraints and reasoning. Effective symbolic AI depends not only on formal logic but also on careful domain analysis, testing, explanation design, and lifecycle governance.

Key Terms

Knowledge representation: Formal organization of information for computational interpretation and reasoning.

Symbolic reasoning: Inference over explicitly represented symbols and rules.

Knowledge base: Collection of facts, rules, definitions, and constraints.

Inference engine: Component that derives conclusions from knowledge.

Proposition: A statement with a truth value.

Predicate: A property or relation applied to terms.

Quantifier: Logical operator specifying universal or existential scope.

Satisfiable: True under at least one interpretation.

Valid: True under every interpretation.

Modus ponens: Inference from P and P → Q to Q.

Resolution: Rule for deriving a clause by eliminating complementary literals.

Unification: Finding substitutions that make expressions identical.

Forward chaining: Data-driven rule inference.

Backward chaining: Goal-driven rule inference.

Ontology: Formal, shared specification of concepts and relations in a domain.

Semantic network: Graph representation of concepts and labeled relations.

Knowledge graph: Graph of entities, relationships, schema, and often provenance.

Closed-world assumption: Treating unproved statements as false.

Open-world assumption: Treating unproved statements as unknown.

Expert system: Knowledge-based system designed to perform specialist reasoning.

Review Questions

Short Answer Questions

1. What are the principal components of a knowledge-based system?

2. Distinguish syntax from semantics in a knowledge representation language.

3. What is the difference between forward chaining and backward chaining?

4. Why is unification important in automated reasoning?

5. Explain the difference between the open-world and closed-world assumptions.

Long Answer Questions

1. Compare propositional logic and first-order logic in terms of expressive power, examples, and computational limitations.

2. Explain ontology engineering from scope definition through validation and governance.

3. Describe the architecture of an expert system and the role of its explanation facility.

4. Discuss how knowledge graphs differ from semantic networks and ordinary relational databases.

5. Analyze the benefits and limitations of combining neural models with symbolic reasoning.

Analytical / Application Questions

1. Design a rule set for diagnosing a network service outage. State the facts, rules, chaining strategy, and explanation that the system should provide.

2. A knowledge base does not state whether an employee completed mandatory training. Explain how a closed-world and an open-world system would treat this situation, and recommend an approach for regulatory compliance.

3. Construct a first-order representation for a policy stating: every critical machine has at least one responsible engineer, and any machine with an active safety alarm must be inspected. Discuss possible ambiguity or missing information in your formalization.

Multiple Choice Questions with Answers

Question 1

Which statement best describes modus ponens?

A. From P and P → Q, infer Q

B. From Q and P → Q, infer P

C. From P ∨ Q, infer P and Q

D. From ¬P, infer ¬Q when P → Q

Correct Answer: A. From P and P → Q, infer Q

Question 2

What is the main limitation of propositional logic compared with first-order logic?

A. It cannot represent truth values

B. It cannot naturally represent objects and relations with variables

C. It cannot use conjunction

D. It cannot support automated inference

Correct Answer: B. It cannot naturally represent objects and relations with variables

Question 3

Which inference strategy is goal-driven?

A. Forward chaining

B. Truth-table enumeration

C. Backward chaining

D. Data normalization

Correct Answer: C. Backward chaining

Question 4

What does unification attempt to do?

A. Assign probabilities to rules

B. Make logical expressions identical through substitutions

C. Convert a graph into a database table

D. Remove all existential quantifiers

Correct Answer: B. Make logical expressions identical through substitutions

Question 5

Under the open-world assumption, failure to prove a statement means that the statement is:

A. Definitely false

B. Definitely true

C. Unknown

D. Automatically inconsistent

Correct Answer: C. Unknown

Question 6

Which component stores case-specific facts in a typical expert system?

A. Working memory

B. Compiler

C. Ontology editor

D. Resolution clause

Correct Answer: A. Working memory

Question 7

Which item is most characteristic of an ontology?

A. Only unstructured text documents

B. Formal concepts, relations, and constraints in a domain

C. A list of neural-network weights

D. A collection of random sensor readings without meaning

Correct Answer: B. Formal concepts, relations, and constraints in a domain

Question 8

Why is provenance important in a knowledge graph?

A. It eliminates the need for identifiers

B. It records the origin and transformation of assertions

C. It guarantees every assertion is true

D. It prevents all inference

Correct Answer: B. It records the origin and transformation of assertions

Question 9

A rule states Temperature(x,t) ∧ t > 80 → Overheated(x). If Temperature(Unit3, 85) is known, what follows?

A. Unit3 is necessarily isolated

B. Unit3 is overheated

C. Unit3 has normal pressure

D. Unit3 has a failed fan

Correct Answer: B. Unit3 is overheated

Question 10

Which is a major governance requirement for a high-impact rule-based system?

A. Hiding the rule version from auditors

B. Using undocumented rule priorities

C. Recording data, rule versions, and inference paths

D. Treating unknown facts as true

Correct Answer: C. Recording data, rule versions, and inference paths