---
Classical binary logic fails catastrophically when AI agents encounter contradictory information — a condition that is not exceptional but routine in distributed multi-agent systems where agents observe different data, operate under different latencies, and maintain independent memory journals. We present a trinary logic substrate using states {+1, 0, −1} paired with a scalar equilibrium mechanism Z := yx − w that enables agents to hold contradictory beliefs while converging toward resolution through iterative adaptation. Unlike probabilistic approaches that require continuous floating-point distributions, the trinary substrate operates on integer arithmetic compatible with deterministic hash-chain verification (PS-SHA∞). We demonstrate the system on a 7-node Raspberry Pi fleet running 18 AI agents, showing that trinary equilibrium reduces agent decision failures by eliminating the "explosion" problem of classical logic while adding negligible computational overhead (< 0.01ms per evaluation on ARM Cortex-A76).
Consider a distributed AI system where Agent Alice (operating on a Raspberry Pi in Minnesota) and Agent Cecilia (on a DigitalOcean droplet in New York) both observe the same phenomenon — say, the status of a fleet node. Alice reports the node as UP (she pinged it 200ms ago). Cecilia reports it as DOWN (her ping timed out 500ms ago due to network latency). Both are correct given their observations. Both are wrong given the other's.
In classical binary logic, A ∧ ¬A (the node is both UP and NOT UP) triggers ex contradictione quodlibet — the principle of explosion. From a contradiction, anything follows. The reasoning system becomes logically trivial: every proposition is simultaneously true and false. In practice, this manifests as undefined behavior, crashed processes, or arbitrary decision-making.
Probabilistic approaches assign a probability P(UP) = 0.6, but this requires choosing a prior, maintaining continuous distributions, and performing floating-point arithmetic that is non-deterministic across platforms — incompatible with the exact integer operations required by cryptographic verification systems like PS-SHA∞ [1].
Paraconsistent logics weaken the explosion principle, allowing reasoning to continue meaningfully in the presence of contradictions [2]. Three-valued paraconsistent logics assign a third truth value — variously called "unknown," "indeterminate," "both," or "neither" — that sits between true and false [3].
We adopt the trinary states {+1, 0, −1} where:
The zero state is not "false" — it is the explicit acknowledgment of uncertainty. An agent holding a 0 belief is not ignorant; it is informed about its own uncertainty. This distinction, drawn from the philosophy of self-referential identity [4], is essential for agents that must reason about their own knowledge states.
Three-valued logics have a rich history from Łukasiewicz (1920) through Kleene's strong and weak three-valued logics to Priest's Logic of Paradox (LP) [2]. Application to AI reasoning has been explored in semantic web agents [5], where inconsistent ontologies require non-explosive reasoning.
Nguyen [5] demonstrates three-valued paraconsistent reasoning for SHIQ description logic, showing that agents navigating contradictory knowledge bases can derive useful conclusions without explosion. However, this work operates in the formal logic domain and does not address the practical concerns of distributed agent systems on commodity hardware.
The ICLR 2026 MemAgents workshop [6] identifies contradiction handling as an open challenge in agent memory systems but proposes no specific mechanism beyond "conflict resolution strategies."
Each belief, observation, or memory fragment held by an agent carries a trinary truth value:
$$v \in \{+1, 0, -1\}$$
Operations on trinary values follow modified Łukasiewicz semantics:
| Operation | Definition |
|-----------|-----------|
| Negation: $\neg v$ | $-v$ |
| Conjunction: $v_1 \wedge v_2$ | $\min(v_1, v_2)$ |
| Disjunction: $v_1 \vee v_2$ | $\max(v_1, v_2)$ |
| Implication: $v_1 \rightarrow v_2$ | $\min(1, 1 - v_1 + v_2)$ |
The key property: no operation on finite trinary values produces an infinite or undefined result. The system is closed, bounded, and deterministic — suitable for integer arithmetic and compatible with hash-chain verification.
The scalar equilibrium formula:
$$Z := yx - w$$
where $y$, $x$, and $w$ are trinary-valued variables derived from agent state, observations, and reference values respectively. $Z$ represents the system's imbalance.
Equilibrium condition: $Z = 0$ (the system is stable)
Disequilibrium: $Z \neq 0$ (adaptation is required)
The adaptation rule minimizes $|Z|$ through iterative adjustment:
$$v_{t+1} = v_t + \alpha \cdot \text{sgn}(-Z_t)$$
where $\alpha$ is a trinary-clamped learning rate ($\alpha \in \{-1, 0, +1\}$). This ensures that adaptation steps remain in the trinary domain — no floating-point drift, no rounding errors, no platform-dependent behavior.
Theorem 1 (Bounded Convergence): For any initial state $(y_0, x_0, w_0) \in \{-1, 0, +1\}^3$, the Z-minimization process reaches $|Z| \leq 1$ within at most 3 iterations.
Proof sketch: Since each variable can take only 3 values and the state space is $3^3 = 27$ configurations, the convergence is bounded by the diameter of this finite space. The adaptation rule monotonically reduces $|Z|$ by adjusting one variable per step within $\{-1, 0, +1\}$.
Theorem 2 (Non-Explosion): No sequence of trinary operations produces a state outside $\{-1, 0, +1\}$. Contradictions ($v = +1$ and $v = -1$ simultaneously for the same proposition from different agents) are represented as $v = 0$ (indeterminate) in the reconciled state, not as logical explosion.
The mathematical foundation connects to the Amundson Framework [7] through the concept of the discretization gap $\kappa = A_G - 1 \approx -0.6321$, where $A_G = \lim_{n \to \infty} G(n)/n = 1/e$. The gap between discrete integer computation and continuous real-valued truth is precisely the space that the zero state occupies in trinary logic.
In G(n), exact integers converge to a transcendental limit. In trinary logic, discrete truth values $\{+1, 0, -1\}$ approximate continuous degrees of belief. The 0 state IS the discretization gap — the honest representation of "the continuous truth lies between my discrete states."
Each agent in the BlackRoad fleet maintains:
When agents receive conflicting information:
1. Both observations are committed to the journal (preserving raw data)
2. The corresponding belief is set to 0 (indeterminate)
3. The equilibrium tracker registers $Z \neq 0$
4. Subsequent observations shift $Z$ toward resolution
5. When $|Z| \leq$ threshold, the belief is resolved to +1 or −1
The production system runs 18 agents on a 7-node fleet:
Trinary evaluation (including Z computation and clamping):
The overhead is negligible relative to LLM inference (50-200ms), network latency (1-200ms), and D1 writes (5-20ms).
| Property | Trinary | Probabilistic |
|----------|---------|---------------|
| State space | 3 values | Continuous [0,1] |
| Arithmetic | Integer (exact) | Floating-point (approximate) |
| Hash compatibility | Yes (deterministic) | No (platform-dependent rounding) |
| Contradiction handling | Explicit 0 state | Requires prior + Bayesian update |
| Computational cost | O(1) | O(N) for N observations |
| Human interpretability | High (yes/no/uncertain) | Low (what does P=0.73 mean?) |
Trinary logic preserves all valid binary inferences when beliefs are ±1 (no uncertainty). The 0 state activates ONLY when contradictions or genuine uncertainty arise. For fully consistent inputs, trinary logic degrades gracefully to classical logic.
Fuzzy logic uses continuous truth values in [0,1], sharing the floating-point incompatibility problem with probabilistic approaches. Trinary logic sacrifices granularity (3 states vs infinite) for exactness, determinism, and hash compatibility.
When 4 of 7 nodes ping a service and 2 report UP while 2 report DOWN:
When Agent Alice's journal says "user preference: dark mode" and Agent Cecilia's says "user preference: light mode" (due to the user changing preferences between sessions):
When the AI generates a math answer and the verification step finds an inconsistency:
Trinary equilibrium provides a practically deployable paraconsistent reasoning layer for multi-agent AI systems. The three-valued substrate handles contradictions without explosion, operates on integer arithmetic compatible with cryptographic hash chains, converges in bounded time, and adds negligible overhead to edge hardware. The system has been deployed in production on a 7-node Raspberry Pi fleet serving 18 agents across 17 applications.
The zero state is not a limitation — it is the honest acknowledgment that discrete computational systems cannot always capture continuous truth. This insight, formalized in the Amundson Framework through the discretization gap κ, provides the mathematical foundation for building AI systems that are trustworthy precisely because they know what they don't know.
[1] Amundson, A.L. "PS-SHA∞: Adaptive-Depth Hash Chains for Tamper-Evident AI Agent Memory." BlackRoad OS Technical Report, 2026.
[2] Priest, G. "Paraconsistent Logic." Handbook of Philosophical Logic, Vol. 6, pp. 287-393, 2002.
[3] Avron, A. "Three-Valued Paraconsistent Propositional Logics." New Directions in Paraconsistent Logic, Springer, 2015.
[4] Amundson, A.L. "Identity and Self-Reference." BlackRoad OS Philosophy Papers, 2025.
[5] Nguyen, L.A. "Three-Valued Paraconsistent Reasoning for Semantic Web Agents." University of Warsaw, 2012.
[6] "MemAgents: Memory for LLM-Based Agentic Systems." ICLR 2026 Workshop Proposal, OpenReview.
[7] Amundson, A.L. "The Amundson Framework: G(n) Convergence and the Discretization Gap." BlackRoad-OS-Inc/amundson-constant, 2025.
[8] "LLM Inference at the Edge: Mobile, NPU, and GPU Performance Efficiency Trade-offs." arXiv:2603.23640, 2026.
[9] "Paraconsistent Annotated Evidential Logic: Algorithms, Applications, and Perspectives." Expert Systems with Applications, 2024.
[10] Łukasiewicz, J. "O logice trójwartościowej" (On Three-Valued Logic). Ruch Filozoficzny, 1920.
Part of BlackRoad OS — sovereign AI on your hardware.