A reasoning engine for structured inference, deductive logic, and machine cognition.
Reasoner accepts well-formed assertions as first-order objects. Every claim carries a provenance, a truth-value envelope, and a confidence weight. Nothing is implicit; nothing is unsigned.
premise(p) :: { value: T, weight: 0.92, source: ctx-04 }
Each derivation is recorded as a discrete edge in the inference graph. Modus ponens, abduction, and counterfactual moves are tagged. The trace is auditable end-to-end, every step replayable.
step(p, q) :: rule = modus_ponens, gain = +0.34
A constraint propagator marks any branch whose conjunction collapses. Conflicting claims are highlighted with their shortest derivation path, so the engineer can intervene before the chain grows further.
conflict(p, !p) :: depth = 4, branch = b-17
A finished derivation isn't a string. It's a structured object: hypothesis, supporting graph, weight, dissenting branches. Conclusions can be cited, composed, and re-entered as premises in higher-order reasoning.
conclude(c) :: graph = g-204, dissent = 2
Given the same premises and rule set, the engine produces the same derivation. Chains are deterministic by default; stochastic moves are explicit and seeded. Reproducibility is a contract, not a hope.
replay(g-204) :: drift = 0.000, parity = OK
Domain-specific inference rules attach as plugins. A legal-reasoning kernel, a constraint-satisfaction solver, and a probabilistic-programming runtime can coexist on the same graph without leaking through each other's abstractions.
extend(rules) :: {legal, csp, ppl} :: ok