🤖 AI Summary
This work addresses the misalignment between capability boundaries and governance boundaries in current AI systems, which engenders uncontrolled risks and renders formal regulatory mechanisms ineffective. To resolve this, the paper introduces a “coterminous governance” framework that mandates strict alignment between these boundaries. Leveraging Rice’s theorem, it proves that behavioral governance is undecidable under Turing-complete architectures, thereby necessitating governance to be intrinsically embedded within system design rather than imposed ex post facto. The authors realize this principle through an architecture that decouples computation from effect, integrating governance checks directly into the execution pipeline instead of relying on a separate oversight layer. Using Coq-based formal verification—encompassing 454 theorems across 36 modules—the study establishes coterminous governance as a necessary criterion for verifiable AI governance systems.
📝 Abstract
Every system that performs effects has two boundaries: what it can do (expressiveness) and what governance covers (governance). In nearly all deployed AI systems, these boundaries are defined independently, creating three regions: governed capabilities (the only useful region), ungoverned capabilities (risk), and governance policies that address non-existent capabilities (theater). Two of the three regions are failure modes. We focus on the governance of effects: actions that AI systems perform in the world (API calls, database writes, tool invocations). This is distinct from the governance of model outputs (content quality, bias, fairness), which operates at a different level and requires different mechanisms. We present a formal framework for analyzing this structural gap. Rice's theorem (1953) proves the gap is undecidable in the general case for any Turing-complete architecture that attempts to govern effects behaviorally: no algorithm can decide non-trivial semantic properties of arbitrary programs, including the property "this program's effects comply with the governance policy." We define coterminous governance: a system property where the expressivenessboundary equals the governance boundary. We show that coterminous governance requires an architectural decision (separatingcomputation from effect) rather than a governance layer added after the fact. We show that structural governance under this separation subsumes separate governance infrastructure: governance checks become part of the execution pipeline rather than a second system running alongside it. We propose coterminous governance as the testable criterion for any AI governance system: either the two boundaries are provably identical, or risk and theater are structurally inevitable. Proofs are mechanized in Coq (454 theorems, 36 modules, 0 admitted).