Formalizing common sense for scalable inconsistency-robust information integration using Direct Logic(TM) reasoning and the Actor Model

Because contemporary large software systems are pervasively inconsistent, it is not safe to reason about them using classical logic. The goal of Direct Logic is to be a minimal fix to classical mathematical logic that meets the requirements of large-scale Internet applications (including sense making for natural language) by addressing the following issues: inconsistency robustness, contrapositive inference bug, and direct argumentation. Direct Logic makes the following contributions over previous work: * Direct Inference (no contrapositive bug for inference) * Direct Argumentation (inference directly expressed) * Inconsistency-robust deduction without artifices such as indices (labels) on propositions or restrictions on reiteration * Intuitive inferences hold including the following: * Boolean Equivalences * Reasoning by splitting for disjunctive cases * Soundness * Inconsistency-robust Proof by Contradiction Since the global state model of computation (first formalized by Turing) is inadequate to the needs of modern large-scale Internet applications the Actor Model was developed to meet this need. Using, the Actor Model, this paper proves that Logic Programming is not computationally universal in that there are computations that cannot be implemented using logical inference. Consequently the Logic Programming paradigm is strictly less general than the Procedural Embedding of Knowledge paradigm.

💡 Research Summary

The paper begins by observing that contemporary large‑scale software systems, especially those deployed on the Internet, are intrinsically inconsistent. Classical logic, with its reliance on the law of excluded middle, the contrapositive inference rule, and unrestricted proof‑by‑contradiction, assumes a globally consistent knowledge base. When contradictions are present, even a single erroneous inference can explode, causing the entire logical apparatus to collapse. This “contrapositive bug” is especially pernicious in distributed, asynchronous environments where state changes are frequent and global synchronization is impossible.

To address these shortcomings, the authors introduce Direct Logic™ – a minimal, principled modification of classical mathematical logic designed for inconsistency‑robust reasoning. The core innovation is Direct Inference, which permits a conclusion Q to be drawn from a premise P → Q only when the antecedent P is explicitly asserted as true. The contrapositive (¬Q → ¬P) is deliberately excluded, eliminating the dangerous backward inference that propagates contradictions. Direct Logic also formalizes Direct Argumentation, a proof‑style where each inference step is a self‑contained argument rather than an implicit accumulation of premises. This makes proofs transparent, reusable, and amenable to automated checking.

Unlike many inconsistency‑tolerant frameworks, Direct Logic does not rely on auxiliary devices such as proposition indices, labels, or restrictions on reiteration. The same proposition may be reused arbitrarily, reflecting the reality of mutable state in software. The system preserves familiar Boolean equivalences, supports case‑splitting for disjunctions, and maintains soundness in the sense that any derived theorem is semantically valid under the intended interpretation, even when the knowledge base contains contradictions. A particularly noteworthy contribution is Inconsistency‑Robust Proof by Contradiction, which allows a proof to exploit the existence of a contradiction to establish a target claim without allowing that contradiction to contaminate unrelated derivations.

On the computational side, the paper argues that the traditional global‑state model of computation (originating with Turing) is inadequate for modern, highly concurrent Internet applications. Instead, the Actor Model is adopted as the underlying execution paradigm. Actors are independent entities that communicate solely via asynchronous messages, encapsulating their own state and behavior. This model naturally accommodates partial consistency: each actor can maintain its own local invariants even when the overall system is globally inconsistent.

Using the Actor Model, the authors prove that Logic Programming is not computationally universal. They construct scenarios involving nondeterministic message ordering and simultaneous state updates that cannot be expressed purely through logical inference rules. In other words, there exist computable functions that require procedural control flow, side‑effects, or explicit concurrency constructs—features absent from pure logic programming languages such as Prolog. Consequently, the Procedural Embedding of Knowledge (PEK) paradigm, which integrates procedural code with declarative knowledge, is shown to be strictly more expressive.

The paper’s contributions can be summarized as follows:

1. Direct Logic – a concise, inconsistency‑robust logical foundation that eliminates the contrapositive bug, supports direct argumentation, and allows unrestricted reiteration.
2. Inconsistency‑Robust Deduction – Boolean equivalences, case‑splitting, soundness, and a novel form of proof‑by‑contradiction that remain valid in the presence of contradictions.
3. Actor‑Based Computational Model – demonstrates why a message‑passing, state‑encapsulated model is essential for large‑scale, distributed systems.
4. Non‑Universality of Logic Programming – formal proof that pure logical inference cannot capture all computations achievable in the Actor Model, establishing the superiority of PEK.
5. Practical Implications – the combined framework offers a theoretically sound yet practically viable approach for building robust Internet‑scale services, natural‑language understanding systems, and cyber‑physical infrastructures that must operate reliably despite inevitable inconsistencies.

In conclusion, by marrying Direct Logic with the Actor Model, the authors provide a unified theory that reconciles logical reasoning with the realities of modern, inconsistent, and highly concurrent software ecosystems. This work lays a solid foundation for future research in inconsistency‑tolerant AI, distributed system design, and the development of programming languages that seamlessly blend declarative knowledge with procedural control.