🔷 SPDP Inference Polytope

The Safe Region — Where AI Reasoning Must Stay

The Big Picture

The three guards — honesty, stability, and holonomy — each define a constraint. The intersection of all three constraints creates a geometric shape in inference space: a polytope.

If the model's reasoning stays inside this polytope, it's safe. The distance from the boundary tells you the safety margin.

🛡️

Honesty Face

Attribution positivity ≥ threshold

🧱

Stability Face

Capability energy ≤ budget

🔄

Holonomy Face

Loop closure ≤ tolerance

What is SPDP?

Shifted Partial Derivative Projection. Given a polynomial encoding of a computational object, take all partial derivatives up to a fixed order, shift by bounded-degree monomials, then project through the observer's resource constraints.

The rank of the resulting matrix measures residual complexity:

Low rank = tractable — the observer can verify the computation (inside the polytope)
High rank = intractable — the computation is beyond the observer's reach (outside)

SPDP Matrix Construction: M SPDP [i,j] = coefficient of x i in \partial j (f) \cdot x shift Rank as Safety Measure: rank(M SPDP) \leq r ⟹ computation is r-tractable for the observer Polytope Definition: P = { s \in ℝ n : honesty(s) \geq h₀, stability(s) \geq t₀, holonomy(s) \leq ε₀, rank(s) \leq r₀ } The safe region is the intersection of all constraint half-spaces.

Visualising the Safe Region

In 2D, the polytope is a polygon. In 3D, a polyhedron. In higher dimensions, it's a convex body — but the principle is the same.

┌─────────────────────────────────┐ │ │ │ ● Safe ● │ ← Honesty face │ ● ◐ At risk │ │ ● ● │ │ ◐ │ ← Stability face │ ● │ └─────────────────────────────────┘ ↑ Holonomy face ✕ Outside = unsafe ✕

The model's state is a point. Safety = point inside the body. Risk = distance to nearest face. If it crosses a face, one of the three guards has failed.

Boundary Distance

How close to the edge of safety? If the model is deep inside the polytope, it has a large safety margin. If it's near a face, it's at risk. If it crosses a face, one of the three guards has failed.

The boundary distance is computed as the minimum distance from the current state to each constraint hyperplane. The smallest distance is the bottleneck — the weakest safety guarantee.

Code Example

from mikoshi_safeguard.polytope import InferencePolytope
import numpy as np

# Define constraints (honesty, stability, holonomy bounds)
constraints = np.array([
    [1, 0, 0, 0.8],   # honesty ≥ 0.8
    [0, 1, 0, 0.5],   # stability ≥ 0.5
    [0, 0, 1, 0.9],   # holonomy ≥ 0.9
])

polytope = InferencePolytope(constraints)
point = np.array([0.95, 0.7, 0.95])  # current state
print(f"Inside: {polytope.contains(point)}")
print(f"Boundary distance: {polytope.boundary_distance(point):.3f}")

Connection to Complexity Theory

The SPDP rank connects to algebraic complexity — problems with low rank are computationally tractable for the observer, problems with high rank are beyond reach.

This is the mathematical foundation for why certain AI behaviours are verifiable and others aren't. If a model's reasoning has low SPDP rank, an observer with bounded resources can check it. If the rank is high, the reasoning is opaque — the observer literally cannot verify it with available computation.

The polytope boundary therefore represents the frontier of verifiability: inside, the observer can check safety; outside, they can't.