The Technology
The Logos is an extensible formal language, generating unlimited clean reasoning data for the logical operators needed for a given application.
The Data Problem
Pretraining AI systems requires verified reasoning data
Training AI systems to reason requires vast quantities of high-quality reasoning data. Human annotation is expensive, costing tens of thousands of dollars for hundreds of examples. It is limited in complexity by human cognitive capacity and introduces errors, biases, and inconsistencies that scale with volume. No amount of human effort can produce the unlimited, error-free reasoning data needed for robust AI pretraining.
The Logos provides unlimited data through formal verification. Every inference is checked by proof assistants and constraint solvers, producing training signals with mathematical certainty rather than human judgment. This approach scales without quality degradation, generating arbitrarily complex reasoning data far exceeding human annotation capabilities.
Pretraining on verified reasoning overcomes a critical failure: training AI systems on the appearance of validity rather than validity itself. When training signals come from human judgment, models learn to optimize for persuasiveness and plausibility rather than correctness, creating incentives for deception. Formal verification eliminates this threat by making the training signal identical to actual validity.
Dual Verification
Every inference is checked from two independent directions: syntactic proof and semantic countermodel search.
Independent syntactic and semantic theories provide a dual verification training training signal for an extensible formal language. Together, this dual verification architecture generates reasoning data without any dependence on human annotation, providing the foundation for scalable AI oversight.
Establishing the soundness of the Logos proof system over its semantics ensures alignment between the negative and positive signals so that all derivable inferences are guaranteed to exclude counterexamples.
Layer Architecture
The foundations are extended with conceptual and agential resources for interpreted reasoning in multi-agent systems.
Constitutive Foundation
Required base layer
Fundamental building blocks: predicates, functions, and hyperintensional logical operators
General
Constitutive Foundation
Required base layer
Fundamental building blocks: predicates, functions, and hyperintensional logical operators
The fundamental building blocks that provide basic descriptive and logical resources to draw the fine-grained distinctions needed to draw explanatory connections. This layer is interpreted over a hyperintensional semantics with bilateral propositions.
Operators
- Boolean operators ∧, ∨, ¬, ⊥, ⊤: For combining and negating propositions
- Lambda abstraction λ: For reasoning about complex properties
- Quantifiers ∀, ∃: For reasoning about all or some entities
- Identity =: For asserting sameness of objects
- Propositional identity ≡: For asserting sameness of propositions
- Grounding ≤: For reasoning about sufficient conditions
- Essence ⊑: For reasoning about necessary conditions
- Reduction ⇒: For reasoning about constitutive explanation
Dynamical Foundation
Required, builds on Constitutive
Temporal evolution operators for modeling change, processes, and state transitions
General
Dynamical Foundation
Required, builds on Constitutive
Temporal evolution operators for modeling change, processes, and state transitions
Extends the base with temporal and modal operators: necessity, possibility, past, future, since, until, counterfactual conditionals, causal operators, and the actuality predicate.
Operators
- Necessity / Possibility □, ◇: For reasoning about what must or could be the case
- Past temporal H, P: Always/sometimes in the past
- Future temporal G, F: Always/sometimes in the future
- Extended temporal S, U: Since and Until for interval reasoning
- Counterfactuals □→, ◇→: Would/might conditionals
- Store/Recall ↓, ↑: For cross-temporal reference
- Actuality predicate Act: For distinguishing actual from possible
- Stability operator ⊡: For what holds across compatible histories
- Causal operators ○→, ⊙→: For explanatory causal links
Conceptual Extensions
Modular plugins, any combination
Specialized domains: belief, knowledge, obligation, permission, and value
Modular
Conceptual Extensions
Modular plugins, any combination
Specialized domains: belief, knowledge, obligation, permission, and value
Optional domain-specific extensions that can be loaded independently. The operators shown here are illustrative examples; many more extensions are possible depending on the application. Includes epistemic logic (belief, probability), normative logic (obligation, permission), abilities, choice theory, and spatial reasoning.
Operators
- Epistemic B, Pr, Mi, Mu, ↪: Belief, probability, might/must, indicatives
- Normative O, P, ≺, ↦: Obligation, permission, preference, reason-for
- Abilities Can, Stit: Ability and agency operators
- Choice FP, Ch: Free permission and best choice
- Spatial @, Dist: Location and distance relations
- ... Many more extensions are possible
Agential Extensions
Multi-agent indexed operators
Agent-indexed operators for multi-agent coordination, modeling beliefs and obligations across perspectives
Modular
Agential Extensions
Multi-agent indexed operators
Agent-indexed operators for multi-agent coordination, modeling beliefs and obligations across perspectives
Agent-dependent extensions that inherit from the layers above. Agential operators index epistemic and normative operators to specific agents for modeling what different agents believe and are obligated to do. Social operators enable common ground construction and group-level coordination. Reflection operators add first-person metacognitive reasoning about one's own beliefs and capabilities.
Operators
- Agential B_a, pref_a, O_a: Agent-indexed belief, preference, and obligation
- Social Shared beliefs, trust, common goals for group coordination
- Reflection I: First-person metacognitive operator for self-reasoning
Three Integrated Packages
The Logos verification system is implemented through three complementary packages, each providing a distinct role in the dual verification architecture.
Proof-Checker
Lean 4Derives valid inferences with mathematical certainty. Generates proof receipts that serve as positive reinforcement learning signals for AI training.
- Core Foundation layer implemented with full bilateral semantics
- Generates proof receipt certificates for verified inferences
- Constitutive and Dynamical Foundations complete
- Metalogic partially complete (~60% soundness proofs)
Model-Checker
Python / Z3Searches for counterexamples using constraint solving. Validates or refutes inferences, providing corrective RL signals when reasoning is invalid.
- Generates countermodel certificates for invalid inferences
- Published on PyPI as model-checker
- Uses Z3 SMT solver for semantic verification
- Active development, approaching v2 release
Model-Builder
RustTransforms natural language into formal semantic models that interpret the Logos to draw inferences. Provides a foundation for abductive and inductive reasoning.
- Translate natural language to formal Logos representations
- Enables non-experts to leverage formal verification
- Architecture specified in design documents
- Key to scaling Logos to practical applications
Interpreted Reasoning
Formal semantics for verifiable AI reasoning
The Logos provides a formal language with precise semantics, enabling AI systems to evaluate sentences at semantic models rather than relying on statistical pattern-matching. A semantic model represents a structured interpretation of a situation, specifying what exists, what properties entities have, and what relations hold between them at different times throughout the range of relevant possibilities. Evaluating sentences at such models yields explicit truth conditions, making it clear exactly why a conclusion follows or fails to follow from a given set of premises.
Once a model is constructed, the Logos enables evaluation of claims that standard logic cannot handle: counterfactuals ("if X had not happened, Y would not have occurred"), causal claims ("X caused Y"), epistemic claims ("agent A believes P"), and normative claims ("agent A ought to do X"). These conceptual resources extend the language beyond simple Boolean combinations to capture the fine-grained distinctions that expert reasoning requires with modular plugins to further extend the logic.
The Logos supports a complete reasoning cycle: abduction constructs candidate models that explain observed evidence, deduction draws testable consequences from each candidate, and induction tests those consequences against new observations to falsify, support, or revise the candidate semantic models. This loop converges toward interpretations with the strongest evidence, enabling systematic discovery through iterative refinement rather than relying on pattern matching.
Continue Exploring
Learn more about our research and applications.