Closed-World Assumption

The closed-world assumption operates on the principle of negation as failure. If a fact cannot be proven true from the available knowledge base, it is concluded to be false. This is formalized in logic programming (e.g., Prolog) and is the default mode for relational database queries, where a missing record implies the non-existence of that entity-property relationship.

• Mechanism: A query returns false or an empty set if a matching fact is not found.
• Contrast: Differs fundamentally from the open-world assumption, where a missing fact simply means the system lacks knowledge about its truth value.

The CWA is the default operational mode for relational database management systems (RDBMS). The database schema defines a complete universe of discourse; any data not present in the tables is considered non-existent.

• SQL Queries: A SELECT statement that returns no rows is interpreted as "no such records exist."
• Integrity Constraints: Mechanisms like foreign keys and NOT NULL enforce a closed world by defining what must be present and what relationships must hold.
• Practical Implication: Enables efficient querying and transaction processing by relying on the completeness of the stored data.

This is the most critical distinction in knowledge representation. The open-world assumption (OWA), used in ontologies (OWL) and the semantic web, treats the knowledge base as incomplete. The absence of a fact does not imply its falsehood; it may be true, false, or simply unknown.

• OWA Example: An ontology may state Person(Alice). Without a hasSibling assertion, the system cannot conclude Alice has no siblings. A reasoner remains agnostic.
• CWA Example: A database table Employees with no record for Bob authoritatively means Bob is not an employee.
• Interoperability Challenge: Integrating closed-world data (databases) with open-world knowledge (ontologies) is a central challenge in Ontology-Based Data Access (OBDA).

Under the CWA, query answers are deterministic and complete based on the stored data. This leads to two key behaviors:

• Complete Knowledge: The system can definitively answer both positive queries ("Is X true?") and negative queries ("Is X false?").
• Monotonic vs. Non-Monotonic Reasoning: CWA enables non-monotonic reasoning. Adding a new fact to the knowledge base can invalidate previous negative conclusions. For example, learning a new fact can change an answer from false to true. This contrasts with monotonic reasoning under OWA, where adding facts only increases knowledge without retracting previous conclusions.

The CWA is formally implemented in logic programming languages like Prolog. The semantics are defined such that a goal is considered false if it cannot be proven true through the application of rules and facts in the program.

• Negation as Failure: The operator \+ ("not provable") explicitly embodies the CWA. \+ goal succeeds if goal cannot be proven.
• Stable Model Semantics: More advanced formalisms like Answer Set Programming (ASP) extend the CWA to provide declarative semantics for complex reasoning with defaults and constraints.

While efficient, the CWA carries significant risks if applied to inherently incomplete knowledge, leading to erroneous conclusions.

• Risk of False Negatives: If the knowledge base is incomplete (e.g., a customer database missing recent entries), the system will incorrectly assert the non-existence of those customers.
• Unsuitability for Integration: In semantic data integration or when working with federated, evolving data sources, the OWA is typically more appropriate to avoid premature, incorrect closures of the world.
• Design Requirement: Applying CWA requires high confidence in the completeness and authority of the data source for the queries being executed.

Relational databases are the canonical example of closed-world systems. A query like SELECT * FROM Employees WHERE Department = 'Sales' returns only the records explicitly stored in the Employees table. Any employee not in the result set is assumed not to work in Sales. This is enforced through:

• Integrity Constraints: Primary and foreign keys define a complete, consistent universe of valid data.
• ACID Transactions: Guarantee that the database moves from one complete, consistent state to another.
• Null Values: Represent the explicit absence of known information within the closed world.

The SQL language is designed for closed-world querying. Key operations rely on the assumption that the database contains all relevant facts.

• NOT EXISTS / NOT IN Clauses: These constructs explicitly leverage the closed-world assumption to find absences.
• Closed-World Query Semantics: The result of any SELECT statement is a definitive answer set from the known data. If a fact isn't derivable from the stored tables and joins, it is considered false for the purpose of the query.
• Three-Valued Logic: SQL's handling of NULL (unknown) is a pragmatic extension, but query results themselves are a closed set of known-true tuples.

Datalog, a declarative logic programming language, typically operates under the closed-world assumption via negation as failure. If a fact cannot be proven from the given rules and base facts, it is assumed false. This is critical for:

• Deductive Databases: Extending RDBMS with recursive rules, while maintaining complete answer sets.
• Business Rule Engines: Executing policy rules (e.g., "approve loan if income > X and no default exists") where the absence of a default record is a conclusive negative. Contrast with Prolog, which often uses an open-world, proof-based model.

Classic expert systems like MYCIN or business rule management systems (BRMS) use a production rule engine working on a working memory of facts. This memory represents the complete known state of the world for the session.

• Forward/Backward Chaining: Inference engines apply IF-THEN rules only to known facts in working memory. The inability to match a rule's antecedent is treated as the antecedent being false.
• Certainty Factors: While they may handle uncertainty, the core reasoning operates over a closed set of asserted evidence. This allows for deterministic diagnosis or decision-making based on a finite knowledge base.

Certain machine learning paradigms implicitly adopt a closed-world view during training and inference.

• Multi-class Classification: A model trained to distinguish between, e.g., 10 animal classes will assign any input to one of those 10. An image of a novel, unseen animal is forced into one of the known categories—a closed-world decision.
• Anomaly Detection: Models are trained on "normal" data; anything sufficiently different is flagged as an anomaly, effectively defining a closed world of normality.
• Knowledge Graph Completion: Link prediction models infer missing triples within the known set of entities and relation types, assuming the graph's schema defines the universe.

Systems that synchronize data between applications (e.g., CRM to ERP) often use a closed-world reconciliation logic.

• Master Data Management (MDM): A golden record is constructed from known source systems. If a system does not report a value for an attribute, the MDM process may treat it as non-applicable or use a default, rather than preserving an "unknown."
• Change Data Capture (CDC): Propagates updates as definitive new states, overwriting previous values. The target system's state after sync is treated as the complete and current truth. This ensures deterministic, actionable data flows across business systems.

Negation as failure is a rule of inference in logic programming (e.g., Prolog) where a proposition is assumed to be false if it cannot be proven to be true, given the available knowledge and rules. It is a procedural implementation of the closed-world assumption.

• Operationalization of CWA: It explicitly codifies the CWA within a program's execution model. The query not(p) succeeds if p fails to be proven.
• Scope: Applies within the context of a specific program or database. It does not make a claim about the universal truth of p, only about its derivability from the given rules.
• Use Case: Common in database query languages (e.g., SQL's NOT EXISTS) and declarative business rules for checking absence.

The unique name assumption is a simplifying principle where different names (identifiers) are assumed to refer to different entities in the world. It is often adopted alongside the closed-world assumption in database systems.

• Database Default: In a SQL database, two rows with different primary keys are assumed to be different entities.
• Contrast with OWA/OWL: Standard OWL does not make the UNA. Two different URIs (e.g., :id_123 and :employee_456) could, in principle, refer to the same individual unless explicitly declared otherwise with owl:differentFrom.
• Impact on Integration: Relaxing the UNA is necessary for entity resolution and linking data from multiple sources where the same entity may have different identifiers.

The domain closure assumption is a stronger form of the closed-world assumption which asserts that the set of individuals in the knowledge base is all the individuals that exist in the domain of discourse. There are no other individuals.

• Complete Enumeration: It assumes the knowledge base contains a complete list of all relevant entities. For example, if the KB lists Alice, Bob, and Charlie as Employees, then there are exactly three employees.
• Formal Logic: Often expressed in logic by adding axioms that state the known individuals are the only ones. This enables stronger forms of reasoning, like reasoning by cases.
• Application: Useful in constrained, well-defined domains (e.g., configuring a specific piece of hardware with known components) but unrealistic for open domains like general web data.

Default logic is a non-monotonic logic formalism that allows reasoning with default assumptions—conclusions that hold in the absence of contradictory information. It provides a formal framework for concepts like the closed-world assumption.

• Non-Monotonicity: Adding new facts can invalidate previous conclusions (unlike classical monotonic logic). This mirrors how a database update can change the result of a negation-as-failure query.
• Default Rules: Expressed as A : B / C, meaning: if A is believed, and B is consistent with our beliefs, then conclude C. For example, "If X is a bird, and it is consistent that X can fly, then conclude X can fly."
• CWA as a Default: The CWA for a predicate P can be modeled as a default rule: true : ¬P(x) / ¬P(x), meaning: for any x, if it's consistent to assume ¬P(x), then assume it.

Completion is the process of transforming a set of facts and rules into a logical theory that explicitly includes the negations of all facts not entailed by the program, thereby enforcing the closed-world assumption at a semantic level.

• Clark's Completion: A formal method for assigning semantics to logic programs with negation. It transforms a program like P(a). P(b). into statements meaning "P(x) is true if and only if x is equal to a or x is equal to b." This logically implies ¬P(c) for any other constant c.
• Link to CWA: The completion of a database or program is a logical formula whose models correspond exactly to the intended meaning under the CWA.
• Role in Query Answering: Query engines for deductive databases often use completion semantics to evaluate queries involving negation correctly and efficiently.