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.

Candidate Inference Γ ⊢ φ Premises and conclusion to verify Proof-Checker (Lean 4) Derives valid inferences with mathematical certainty Syntactic verification via formal proof Model-Checker (Z3) Searches for counterexamples using constraint solving Semantic verification via model search Proof Receipt Positive RL Signal Proof receipts certify that an inference is valid. These serve as positive RL signals, teaching AI systems which reasoning patterns are correct. Countermodel Corrective RL Signal Countermodels provide concrete scenarios where a claimed inference fails. These serve as corrective RL signals, teaching AI systems to avoid invalid reasoning. AI Training Data Unlimited verified training signals

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

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

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

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

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 4
In Progress

Derives 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 / Z3
v1.2.12

Searches 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

Rust
Planned

Transforms 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.