Ternary Logic (TL) Core Doctrine

No Log = No Action
Non-Bypassable Execution Invariant

Formal Transition System  |  LTL / CTL / Past-Time LTL  |  Inductive Proof Obligations
The Iron Law

No state transition, transaction, API call, or physical actuation may be released unless a corresponding log entry has been fully committed to a local hardware-backed non-volatile accumulator prior to execution. No exception. No override. No privilege level reaches this boundary.

I. Problem Definition: Optional Logging Failure

Traditional computing and control architectures treat logging as a telemetry concern, decoupled from execution by asynchronous buffering, deferred writes, and best-effort delivery semantics. This architectural separation introduces non-determinism between execution and persistence, because the temporal ordering of action completion and log commitment is not enforced by any structural constraint. Actions routinely complete while their corresponding log entries remain in volatile buffers, transit queues, or write-back caches that may be lost to power interruption, process termination, or network partition.

I.2 DMA, MMIO, and IOMMU Insufficiency

Direct hardware manipulation paths, including DMA and memory-mapped I/O, can reach physical actuator control registers without any software-layer awareness or logging. IOMMU protections are insufficient for three documented reasons: early boot gaps where IOMMU translation tables are not yet enabled; deferred DMA attacks exploiting stale mappings after virtual machine destruction; and message-signaled interrupt (MSI) forgery that bypasses IOMMU enforcement entirely by forging interrupt signals outside the DMA transaction path. The conclusion is inescapable: telemetry-grade logging provides observability but not enforcement, and any architecture that permits action without structurally guaranteed prior log commitment cannot provide the evidentiary integrity that Ternary Logic demands.

II. The Invariant: Formal Definition

In the DITL/MT hardware substrate, this invariant is material. The Commit Gate stands physically in-line on the actuation path. The NL=NA write pulse, a voltage pulse on a dedicated hardware wire, is the only mechanism that can transition the Commit Gate to Low Resistance State. No instruction in any processor's ISA, no DMA transfer, no firmware call, and no software privilege level has access to this wire.

II.1 Transition System

The invariant is defined over a transition system TS = (S, Act, T, I, AP, L) where S is the set of system states, Act is the set of actions, T is the transition relation, I is the set of initial states, AP is the set of atomic propositions, and L is the labeling function. Two atomic propositions are distinguished: log(a), which holds when a log entry for action a has been fully committed to durable storage with integrity verified, and exec(a), which holds when action a has produced an externally observable effect or state mutation.

II.2 LTL Specification

Primary LTL Invariant (Dwyer, Avrunin, Corbett precedence pattern)
For all actions a: ◇exec(a) → (¬exec(a) U (log(a) ∧ ¬exec(a)))
If exec(a) ever occurs, exec(a) must not hold until log(a) holds, and at the moment log(a) first holds, exec(a) must still be false.
Past-Time LTL Equivalent
□(exec(a) → O(log(a)))
At every point in every trace, if exec(a) holds then log(a) must have held at some strictly earlier position. O is the Once operator.

II.3 CTL Specification

CTL: No Bypass Path Exists
¬E[¬log(a) U exec(a)]
There exists no computation path on which exec(a) occurs while log(a) has not yet held.
CTL: Weak Until (Fail-Closed)
A[¬exec(a) W log(a)]
On all paths, exec(a) does not occur until log(a) has occurred. If log(a) never occurs, exec(a) never occurs either. This is the correct fail-closed behavior.
Strongest CTL Formulation
AG(∀a ∈ Act : exec(a) → logged(a))
logged(a) is a state predicate asserting that a complete, hash-verified, integrity-confirmed log entry for a exists in the committed log store.

II.4 Log Completeness: Four Conditions

Log commitment requires all four conditions satisfied simultaneously:

ConditionRequirement
Canonical SerializationRFC 8785 (JCS) for text or deterministic CBOR for binary. Identical semantic content always produces identical bytes.
Cryptographic HashingSHA-3-256 minimum. In DITL/MT deployments, PUF binding hash SHA3-256(K_PUF ∥ device_serial_OTP ∥ log_session_nonce) appended.
Physical PersistenceWritten to hardware-backed non-volatile storage (TaOx 1T1R ReRAM, MRAM, nvSRAM, or battery-backed SRAM). Arrhenius 20-year retention at 85 degrees C on named baseline.
Read-Back ConfirmationStorage reads back the written data, recomputes hash, confirms match. Only then does log(a) evaluate to true.

II.5 Inductive Proof Obligations

Let Inv(s) ≡ ∀a ∈ Act : executing(a, s) → ∃e ∈ Log(s) : (e.action = a) ∧ (e.timestamp < exec_time(a, s)) ∧ verified(e.hash, s).

Base case: for all initial states s₀ ∈ I, Inv(s₀) holds; no actions are executing in any initial state.

Inductive step: for all states s and s' such that Inv(s) holds and T(s, a, s') is a valid transition, Inv(s') holds; established by the structural constraint that the transition relation T is physically gated such that no transition producing exec(a) in s' can fire unless log(a) is committed in s before the transition.

Strengthening: Inv(s) implies the safety property AG(∀a : exec(a) → logged(a)).

These obligations are dischargeable through symbolic model checking (BDD-based or SAT-based bounded model checking) encoding the hardware gate logic, the logging subsystem state machine, and the actuator release mechanism.

II.7 The Five-Layer NL=NA Enforcement Stack

Every Proceed (+1) authorization must pass all five independent enforcement layers. Bypassing one does not bypass the others.

5
On-Chain ABI: Terminal Constitutional Gate
TL_Ledger_Core.registerPermissionToken reverts NLNAViolation if logHash not in anchored Merkle root. In DITL/MT deployments, reinforced at the physical level by the Commit Gate and Window Comparator independently of the on-chain check.
4
AuditProof Cross-Reference
AuditProof.logHash and merkleRoot must match PermissionToken.logHash and merkleRoot. Mismatched values indicate forgery or accumulator divergence and are rejected.
3
TGLF-StateP1 Required Array
TGLF-StateP1.permissionToken in required array, with pillarsCertified at minItems 8 maxItems 8. A Proceed log entry that omits the permission token or carries incomplete pillar certification fails schema validation.
2
PermissionToken.laneOrigin Constraint
PermissionToken.laneOrigin carries const "GOVERNANCE_LANE". Inference Lane tokens are schema-invalid by construction. No token originating outside the Governance Lane can authorize execution.
1
Schema: State Envelope
permissionToken REQUIRED when currentState = +1. No schema-valid Proceed response exists without a permission token.
No Bypass. No Exception. No Privilege Level Reaches This Boundary.

III. Cryptographic Actuator Interlock

The Merkle accumulator root serves as the execution capability token, stored in hardware-protected registers modifiable only by the logging subsystem. Actuator release requires three independent cryptographic requirements simultaneously: valid log hash with preimage and collision resistance; hardware-generated attestation quote (TPM or enclave) including PUF binding hash in DITL/MT deployments; and inference containment verification confirming the complete TL decision vector is captured before release.

III.3 Non-Bypassability: From Software to Silicon

No administrative privilege, software override, hypervisor code, or SMM firmware can bypass execution gating. The actuation path physically traverses the interlock hardware. There is no alternate routing.

A compromised kernel cannot bypass the interlock because the kernel has no write access to the Merkle root register. A compromised hypervisor cannot bypass the interlock because the interlock's trust boundary is independent of the hypervisor's memory management. SMM code cannot bypass the interlock because it is implemented in dedicated hardware, such as an FPGA fabric or ASIC gate, not addressable from the SMM address space.

In DITL/MT deployments, non-bypassability extends to the silicon layer. The Muller C-element cannot generate output without complete verified input from all channels. No timing assumption, clock manipulation, or voltage glitch can advance it past an incomplete input state.

IV. DITL/MT Hardware Substrate

DITL (Delay-Insensitive Ternary Logic) is the asynchronous circuit substrate. MT (Mandated Ternary) is the hardware implementation layer. The named baseline is TSMC N2 CoWoS with embedded TaOx 1T1R ReRAM, 2025 PDK, with Arrhenius-model 20-year retention at 85 degrees C.

IV.2 Voltage Domain and Resistance State Mapping

TL StateValueResistance StateRangeVoltage
Proceed +1LRS~1-10 kΩ3.3V
Epistemic Hold 0IRS~100 kΩ - 1 MΩ1.65V
Refuse -1HRS~1-10 MΩ0V

These are physical conditions in silicon. Governance states cannot be overwritten by any instruction in any privilege ring. They can only be changed by the NL=NA write pulse, which applies a calibrated voltage pulse to the TaOx cell through the dedicated hardware wire.

IV.3 DITL Circuit Architecture and NL=NA Write Pulse

The Muller C-element is the fundamental gate primitive; its output cannot be generated without complete, verified input from all channels. Three-voltage single-wire encoding (Vdd, Vdd/2, GND). No global clock; genuinely asynchronous. Inline (series) topology required: parallel (sidecar) topology creates an alternate path around the enforcement gate and is constitutionally insufficient.

The NL=NA write pulse is a voltage pulse on a dedicated hardware wire. Not a software flag. Not a register write. Not a firmware call. Without the pulse, no TLState transition occurs regardless of any software state. The Window Comparator measures TaOx cell resistance with RC spoof detection at 5 ns threshold. The Commit Gate stands in-line on the actuation path; HRS blocks, LRS permits.

IV.6 Architecture B

SHIPPING Baseline: No fabricated DITL chip exists. Architecture B: software enforcement active for Layers 1-4; NULL_PUF_DEPLOYMENT sentinel in NLNAAuditToken; TLCapabilityFlags.pufAttestationMode: "ARCHITECTURE_B". Layer 5 on-chain enforcement unchanged. Architecture B does not reduce the Iron Law's authority.

V. Hardware Root of Trust

Trust chain: immutable boot ROM (mask ROM or OTP) measuring UEFI firmware and extending into TPM 2.0 PCRs (ISO/IEC 11889); the extend operation PCR_new = Hash(PCR_old ∥ measurement) is irreversible. Intel SGX enclaves and ARM TrustZone Secure World provide isolated execution for logging subsystem operations. Thales Luna 7 HSM (named baseline, FIPS 140-3 Level 3) provides tamper-resistant key storage with immediate zeroization on intrusion detection. PUF provides device-unique identity from post-manufacturing entropy; invasive probing destroys the physical characteristics, preventing extraction. PUF inter-die Hamming distance approximately 49-51% experimentally demonstrated.

Four documented software-only enforcement failure classes: kernel compromise, hypervisor escape, SMM subversion, and supply chain substitution. Hardware enforcement eliminates all four.

VI. Ternary Logic Mapping and Epistemic Hold

StateValueHardwareMeaning
Proceed +1LRS, 3.3V Clear affirmative; confidence satisfied, log committed, Commit Gate conducts
Epistemic Hold 0IRS, 1.65V The system has determined it cannot determine; confidence insufficient, inputs conflicting, or out-of-distribution
Refuse -1HRS, 0V Definitive negative; hard constraint violated or risk boundary exceeded

Epistemic Hold persists across power cycles without software reinitialization; hardware-semantic persistence of Epistemic Hold in silicon, not in volatile memory, is one of MT's two discontinuous advantages over conventional NVRAM. The Iron Law applies to all three states equally.

VI.2 Solvency Protocol

In financial contexts, Epistemic Hold implements the Solvency Protocol: all pending transactions halt, current positions are preserved without modification, and the complete market state snapshot with the pending transaction queue and triggering conditions is committed to the log. The Solvency Protocol recognizes that financial actions create irreversible obligations that may propagate instability through interconnected networks.

VI.3 Epistemic Hold Trigger Conditions

Mandatory under four conditions: confidence below calibrated threshold; conflicting inputs that cannot be reconciled within the decision cycle; incomplete or stale required data beyond freshness bounds; and out-of-distribution inputs beyond validated distribution envelopes detected through Mahalanobis distance, local outlier factor scores, or isolation forest path lengths.

Forced continuation prevention: Wesolowski VDF cryptographic time-lock (cannot be accelerated by parallel computation); external pressure detection through timing analysis monitoring command arrival rates; complete audit trail of all override attempts committed before any override can be evaluated.

VII. Cryptographic Non-Repudiation

Merkle inclusion proofs O(log n) demonstrate entry existence. Merkle consistency proofs O(log n) confirm no entries deleted or reordered. In DITL/MT deployments, signatures cover canonical serialization, TL state, decision vector, timestamp, monotonic counter, preceding entry hash, and PUF binding hash, binding the log entry inseparably to the specific physical silicon instance. Identity-integrity-logging triad: no component can be satisfied without the other two. Invalid execution states (orphaned action, hash mismatch, signature verification failure) each trigger immediate safe harbor transition.

VIII. Cryptographic Primitives and Adversarial Resistance

Canonicalization: RFC 8785 (JCS) or deterministic CBOR. Merkle accumulators: RFC 9162 (Certificate Transparency v2). Replay protection: hardware-RNG nonces combined with TPM monotonic counters, increment hardware-atomic with the NL=NA write pulse in DITL/MT deployments. Byzantine fault tolerance: PBFT (Castro and Liskov) with 3f+1 minimum nodes. Logres protocol with Isabelle/HOL formal verification providing agreement, completeness, and liveness guarantees. Post-commit immutability: WORM hardware storage combined with SealFS HMAC ratchet chains. Silent action prevention through power consumption correlation; out-of-baseline power during logged-idle periods indicates unlogged computation.

IX. Failure Modes and Safe Harbor States

Fail-closed behavior required across all critical failure modes. In DITL/MT deployments, the Commit Gate defaults to HRS (Refuse -1) in any undefined or error state; no fail-open mode exists in the silicon. For cyber-physical systems: Lyapunov-bounded kinetic energy minimization with convergence time 1/alpha, seven-segment S-curve deceleration with bounded jerk, stable equilibrium verified through Lyapunov criteria. For financial systems: immediate transaction halting and liquidity preservation. Model-checked state machine properties: AG(state in valid set) and AG(Logging_Failure implies AF(Safe_Harbor_Steady)). Manual override requires physical presence, M-of-N authorization (M no less than 2, organizationally independent), and complete logging through a secondary battery-backed channel if the primary is inoperative.

X. Dual-Lane Architecture

The Inference Lane proposes actions, never authorizes them, with no more than 2 ms WCET in FPGA or ASIC programmable logic. The Governance Lane evaluates constitutionally, authorizes or blocks, with no more than 300 ms ceiling. The Commit Gate is the resolution point. Governance Lane failures do not block Inference Lane operation.

Combined Dual-Lane Formal Property
□(exec(a) → inference_committed(a)) ∧ ◇(inference_committed(a) → governance_anchored(a))
Execution always requires prior Inference Lane commitment. Every Inference Lane commitment is eventually anchored in the Governance Lane.
Gap Tolerance Bound
AG(inference_committed(a) → A[¬gap_exceeded U governance_anchored(a)])
From any state where a is committed in the Inference Lane, the gap tolerance is never exceeded before a is anchored in the Governance Lane, on all paths where anchoring eventually succeeds.

Conclusion: Four Pillars of Enforcement

Pillar One
Formal Temporal Logic
LTL, past-time LTL, and CTL properties defining the required ordering between log commitment and action release, dischargeable through model checking.
Pillar Two
Five-Layer Enforcement Stack
Independent schema-level and on-chain layers that independently prevent any Proceed authorization without cryptographic log commitment. Bypassing one layer does not bypass the others.
Pillar Three
Cryptographic Coupling
Merkle accumulators, digital signatures, PUF binding, and hardware attestation quotes making log entries unforgeable and every log session bound to the specific physical silicon instance.
Pillar Four
DITL/MT Hardware Substrate
Muller C-elements that cannot generate output without complete input. Window Comparator enforcing TLState through physical resistance. Commit Gate in-line on the actuation path in silicon. NL=NA write pulse on a dedicated wire outside the processor's ISA.

The resulting system does not trust its operators, its software, or its firmware to maintain log integrity. It structurally prevents any of them from violating it.