Closed-World Assumption (CWA)

The core tenet of CWA is that any fact not explicitly present in the knowledge base is assumed to be false. This is formalized as: if a proposition P is not provable from the knowledge base KB, then conclude ¬P (not P).

• Key Implication: This enables definitive negative answers. A query for "Does employee X have a security clearance?" can return "No" if that fact is not stored, rather than "Unknown."
• Database Default: This is the standard mode of operation for relational databases (SQL) and most business rule engines, where the system's world is defined entirely by the stored data.

CWA operates under the assumption that the knowledge base is a complete description of the domain for the predicates it uses. If the KB contains facts about employees, it is assumed to list all employees.

• Contrast with OWA: Under the Open-World Assumption, the absence of a fact means its truth value is simply unknown. The system cannot infer falsehood.
• Practical Requirement: For CWA to be valid, data ingestion and integrity checks must be rigorous to ensure the KB truly represents a closed world. Missing data leads to incorrect false inferences.

This is the operational mechanism implementing CWA in logic programming (e.g., Prolog, Datalog). Negation as Failure (NAF) is a rule of inference stating: "if P cannot be proven, then assume not-P."

• Syntax: Often written as not(P) or \+ P.
• Non-Monotonicity: Adding new facts to the KB can retract previous conclusions. If not(cleared(alice)) was true because the fact cleared(alice) was absent, adding cleared(alice) later makes not(cleared(alice)) false. This makes reasoning under CWA non-monotonic.

CWA often applies to two distinct levels: the Extensional Database (EDB) and the Intensional Database (IDB).

• EDB (Facts): The set of ground facts (e.g., managed_by(alice, bob)). Under CWA, these are assumed to be the complete set of true facts for those predicates.
• IDB (Rules): The set of deductive rules. The Domain Closure Assumption (DCA) is a stronger variant that also assumes all objects in the domain are known and named by constants in the KB. This prevents reasoning about unknown objects.

CWA is computationally attractive because it allows for:

• Finite Proof Procedures: Since the world is closed, systems can perform exhaustive checks. A query can terminate with a definitive false after checking all known facts and derivable conclusions.
• Materialization: All possible inferences can be precomputed (forward chaining) and stored, making query answering a simple lookup. This is common in deductive databases.
• Deterministic Output: For a given state of the KB, the truth value of any query is binary (true/false), not ternary (true/false/unknown). This is critical for business rule systems requiring unambiguous decisions.

CWA is not universally applicable. Its use is a deliberate architectural choice.

• Typical CWA Systems: Traditional SQL databases, business rule engines (BRMS), deductive databases, and legacy expert systems.
• Typical OWA Systems: Semantic Web stacks (RDF, OWL), ontology-based reasoning, and systems integrating incomplete data from multiple open sources.
• Hybrid Approaches: Modern knowledge graph systems may use OWA for schema/ontology reasoning but apply CWA to specific, vetted data layers to enable efficient querying for known negatives. Graph-based RAG often relies on a CWA-like stance over its retrieved subgraph to provide confident, grounded answers.

CWA is the default operational mode for relational databases (SQL) and most NoSQL systems. A query returns only explicitly stored records; absence of a record is interpreted as the fact being false.

Key Example: A customer database query: SELECT * FROM customers WHERE id = 12345; If no row is returned, the system concludes "Customer 12345 does not exist." This enables efficient integrity checks, such as preventing duplicate primary keys, because the system operates under the certainty that all known entities are present.

Business Rules Management Systems (BRMS) and production rule systems heavily rely on CWA for deterministic decision-making.

How it works: Rules fire based on the presence of facts in the working memory. The absence of a triggering fact means the rule's conditions are not met, and its action is not executed.

Real-world use case: Loan approval systems. A rule might state: IF credit_score >= 700 AND employment_status = 'verified' THEN approve_loan. If the employment_status fact is not present in the session, the rule does not fire, and the loan is not approved—this is a closed-world denial.

Languages like Prolog and Datalog implement CWA through negation as failure. The predicate not(P) is considered true if P cannot be proven from the facts and rules in the knowledge base.

Example in Prolog:

prologCopy
parent(john, mary).
child(X, Y) :- parent(Y, X).
?- child(mary, john). % Returns true.
?- child(john, mary). % Returns false (fails to prove).

The system does not have a rule stating John is Mary's child, so it concludes he is not. This allows for concise representation of default knowledge (e.g., "by default, an animal is not a bird").

This is the critical distinction in semantic systems.

Closed-World Assumption (CWA):

• Premise: "What is not known is false."
• Domain: Traditional databases, logic programming.
• Query Result: Returns false or no results for unknown facts.

Open-World Assumption (OWA):

• Premise: "What is not known is unknown."
• Domain: Semantic Web, Description Logics, OWL ontologies.
• Query Result: Returns unknown for facts not stated or inferable.

Example: In an OWA system, not finding hasSibling(Alice, Bob) does not mean Alice has no siblings; it means the system lacks that information. This is essential for integrating incomplete data from multiple sources.

While OWA is more flexible for knowledge integration, CWA is computationally essential for many practical tasks.

Why CWA is Necessary:

• Efficiency: Proving something is false under OWA requires exhaustive knowledge of the entire domain, which is often intractable. CWA allows for fast, localized checks.
• Determinism: Critical for business applications (e.g., billing, compliance) where a definitive yes/no answer is required, not a "maybe."
• Default Reasoning: Models commonsense defaults efficiently (e.g., "a flight is assumed to be on time unless a delay is reported").

The choice between CWA and OWA is a fundamental architectural decision based on whether completeness of knowledge or efficiency and determinism is paramount.

Advanced systems often bridge the CWA/OWA divide.

Circumscription: A formal, non-monotonic logic technique that minimizes the extension of predicates, effectively enforcing a form of CWA for specific predicates within a logical framework. It allows stating, "Assume these are the only entities that satisfy this property, unless forced to conclude otherwise."

Hybrid Knowledge Graphs: Modern enterprise systems may use a layered approach:

1. A core OWA-based ontology for flexible integration and semantic reasoning.
2. A CWA-based operational layer (e.g., a graph database with property graphs) for high-performance, deterministic querying of asserted facts. Rule-based mediators translate between these layers, applying local closed-world reasoning to global open-world data where appropriate.

The Open-World Assumption (OWA) is the formal reasoning paradigm that a statement's truth value is considered unknown if it is not explicitly stated or cannot be logically inferred. This is the default for Semantic Web technologies (RDF, OWL) and description logic reasoners. Under OWA, a lack of information does not imply falsehood.

• Key Contrast to CWA: OWA treats absence of evidence as unknown, while CWA treats it as false.
• Primary Use: Essential for integrating incomplete or distributed knowledge sources where the total knowledge is not assumed to be complete.

Non-monotonic reasoning is a class of logical inference where adding new premises (knowledge) can invalidate previously derived conclusions. This is necessary to model default assumptions, beliefs, and commonsense reasoning that must be retracted in light of new evidence.

• Relationship to CWA: CWA is a simple, strict form of non-monotonic reasoning. If a new fact is added that contradicts a previous CWA-based presumption of falsehood, the system's conclusions must be revised.
• Examples: Default logic, autoepistemic logic, and circumscription are formalisms for non-monotonic reasoning.

A rule-based system is an AI system that uses a set of conditional 'if-then' production rules and an inference engine to perform automated reasoning over a knowledge base (set of facts).

• CWA Context: Traditional rule-based systems operating on a fixed database often implicitly use the CWA. The knowledge base is treated as complete; any fact not present is presumed false for rule evaluation.
• Components: Consists of a rule base, a working memory of facts, and an inference engine that applies rules via forward or backward chaining.

An inference engine is the core processing component of a knowledge-based system that applies logical inference rules to a knowledge base to deduce new information, answer queries, or reach conclusions.

• Role with CWA: The inference engine's operational semantics define whether it applies CWA or OWA. A database query engine typically uses CWA, while an OWL reasoner uses OWA.
• Strategies: Implements reasoning strategies like forward chaining (data-driven) and backward chaining (goal-driven).

Negation as Failure (NAF) is a rule of inference, central to logic programming (e.g., Prolog), where a proposition is assumed to be false if it cannot be proven to be true from the available knowledge base and rules.

• Formalization of CWA: NAF provides the operational mechanism for implementing the Closed-World Assumption within a logic program.
• Syntax: Often denoted as not p in Prolog, meaning "p is not provable," which is interpreted as "assume p is false."

Datalog is a declarative logic programming language, often used as a query language for deductive databases and knowledge graphs. It is a subset of Prolog designed for database applications, focusing on recursive queries and bottom-up evaluation.

• CWA Basis: Datalog programs operate under the Closed-World Assumption (and Negation as Failure). The Herbrand universe of the program defines the complete domain, and any fact not derivable is false.
• Use Case: Foundational for graph query languages and implementing business rules over enterprise data where the domain is known and complete.