# Equation Underverse Doctrine

Status: HOLD / conceptual doctrine
Authority: workbench definition; not formal proof
Related:

- `docs/gcl/NonCompressedGoxelGeometryDoctrine.md`
- `docs/gcl/GoxelShapeRepresentationCollapseAddendum.md`
- `docs/gcl/HolyDiverGoxelMOIMBridge.md`
- `docs/gcl/RunawayDigitalCellDivisionDoctrine.md`

## Purpose

This document defines the Underverse of the Equation Forest.

The Equation Forest tracks the positive / explicit side of the stack: equations, kernels, routes, attractors, compression maps, and admissible structures.

The Underverse tracks the negative / implicit side: residuals, complements, voids, rejected routes, anti-surfaces, inverse pressure, failed bindings, and structured absence.

## Core definition

```text
Underverse = shadow-manifold of the Equation Forest.
```

More explicitly:

```text
The Underverse of an equation is the structured space of everything that equation excludes, fails to resolve, suppresses, forbids, leaves as residual, or converts into absence in order to produce an admissible form.
```

## Positive / negative split

```text
Equation Forest:
  what forms
  what binds
  what solves
  what routes
  what stabilizes
  what becomes admissible

Equation Underverse:
  what fails to form
  what cannot bind
  what remains unsolved
  what routes are rejected
  what destabilizes
  what remains inadmissible
```

## Operating sentence

```text
Every equation has an Underverse: the complement-space of rejected, inverted, missing, unstable, or unresolved states that define the boundary of what the equation can lawfully express.
```

## Why the Underverse is needed

A positive equation alone tells us what is allowed.

It does not fully tell us:

```text
what was excluded
where the residual went
which paths were forbidden
which manifolds failed to instantiate
which voids became structural
which collisions were avoided
which inverse pressures accumulated
```

For GCL / Goxel / SSMS / MOIM work, this missing side matters because a non-compressed manifold primitive may carry multiple unresolved representation branches before collapse.

The Underverse is the accounting layer for those unresolved branches.

## Goxel relation

A Goxel is a non-compressed manifold primitive.

It can hold pre-shape potential before representation collapse.

The Underverse of a Goxel is not a shape.

It is the indexed absence of all the shapes that were possible but not selected.

```text
Goxel
  -> pre-shape potential
  -> collapse into selected representation system
  -> represented geometry
  -> Underverse records rejected representation systems and unresolved residues
```

## Voxel / Hoxel contrast

```text
Voxel:
  committed occupancy
  Underverse = empty cells, collision misses, unresolved sub-voxel detail

Hoxel:
  committed higher-dimensional transition cell
  Underverse = failed temporal transitions, inadmissible phase branches

Goxel:
  uncommitted manifold primitive
  Underverse = all non-selected shape-representation systems plus residual absence
```

## Underverse transform

For any equation or operator `E`, define an informal Underverse transform:

```text
U(E) = residual(E) + complement(E) + forbidden(E) + failed(E) + unrepresented(E)
```

Where:

```text
residual(E)      = error / mismatch left by E
complement(E)    = region outside E's admissible domain
forbidden(E)     = states E explicitly rejects
failed(E)        = states that tried to bind but could not
unrepresented(E) = states not representable by E's current system
```

This is not yet a theorem. It is a routing grammar.

## Negative sequence

The Underverse can be represented as an inverted integer sequence.

Positive sequence:

```text
P(n) = where structure appears
```

Negative sequence:

```text
N(n) = where structure is missing, forbidden, inverted, suppressed, or unresolved
```

Typed negative term:

```text
N_n = (absence_class, recursion_depth, turbulence, binding_deficit, curvature_defect, memory_scar)
```

Suggested absence classes:

```text
Null0 = ordinary empty
Null1 = complement empty
Null2 = recursive void
Null3 = anti-boundary / inverted fold
Null4 = carrier-depleted region
Null5 = representation-uncommitted region
Null6 = forbidden / inadmissible region
Null7 = collapsed identity region
```

## Hyper PIST surface relation

A positive Hyper PIST sequence records where the surface becomes.

A negative Hyper PIST sequence records where becoming fails, folds, or remains latent.

```text
Positive Hyper PIST sequence:
  activation / surface / binding / becoming

Negative Hyper PIST sequence:
  suppression / anti-surface / binding deficit / non-becoming
```

Underverse object:

```text
Negative Hyper PIST Surface Sequence = typed absence-index over a recursively layered PIST manifold.
```

## Menger-Gabriel relation

Gabriel's Horn stresses volume/surface intuition: finite volume with unbounded surface demand.

Menger recursion stresses occupancy intuition: recursive void formation and scale-dependent boundary logic.

The negative Menger-Gabriel object stresses absence logic.

```text
positive Menger-Gabriel:
  pathological surface

negative Menger-Gabriel:
  pathological absence
```

Underverse reading:

```text
negative Menger-Gabriel = recursively typed absence generated by the complement of a finite-volume / infinite-boundary horn and a void-dominant Menger rule.
```

## Equation Forest mapping

Each Equation Forest kernel should eventually receive an Underverse entry.

Example categories:

| Positive Kernel Type | Underverse Shadow |
|---|---|
| Entropy / Compression | irreducible residue, uncompressible remainder, code-space waste |
| Thermodynamics | forbidden free energy, leakage, impossible efficiency, unpaid cost |
| Topology | non-manifold collision, unresolved hole, failed gluing |
| PDE / Flow | shock discontinuity, turbulence residue, unsmoothed singularity |
| Neural / Behavioral | failed binding, unstable adapter, hallucinated route |
| Encoding | unaddressable state, aliasing, checksum scar |
| Geometry | excluded shape, boundary ambiguity, representation failure |
| Quantum / Phase | decohered branch, forbidden state, unmeasured complement |

## Underverse routing rule

```text
if positive equation passes:
  record minimal Underverse receipt

if positive equation fails:
  route into Underverse analysis

if Underverse structure is stable:
  mine it for a new adapter, kernel, or representation system

if Underverse structure grows unbounded:
  trigger collapse / quarantine / Warden review
```

## ACI / Warden relation

ACI validates positive manifestation.

The Underverse explains why validation failed or what was excluded for validation to pass.

```text
ACI pass:
  positive form is admissible
  Underverse receipt records excluded contradiction

ACI fail:
  positive form is inadmissible
  Underverse becomes active diagnostic space
```

## Market / cross-domain relation

In market or cross-domain filtering, the Underverse is useful because two objects may share the same positive behavior or the same negative constraint.

Example:

```text
shipping containers
DNA sequencing
grandmother's cookies
```

Positive common operator:

```text
batch transformation pipeline
```

Underverse common operator:

```text
queue failure
capacity shadow
spoilage / error / rework
unserved demand
input scarcity
```

The positive manifold finds shared behavior.

The Underverse finds shared failure geometry.

## Implementation rule

Do not implement the Underverse as mystical infinity.

Implement it as finite bounded residual bookkeeping.

A practical Underverse packet should track:

```text
equation_id
positive_kernel_type
absence_class
residual_q16
binding_deficit_q16
turbulence_q16
forbidden_region_tag
failed_representation_tag
recursion_depth
aci_residual_q16
warden_status
receipt_hash
```

All hot-path numeric quantities must remain fixed-point, not float.

## Minimal pseudo-schema

```text
UnderversePacket = {
  equation_id,
  positive_kernel_type,
  absence_class,
  residual_q16,
  binding_deficit_q16,
  turbulence_q16,
  forbidden_region_tag,
  failed_representation_tag,
  recursion_depth,
  aci_residual_q16,
  warden_status,
  receipt_hash
}
```

## Promotion ladder

```text
HOLD:
  conceptual shadow entry exists

DRAFT:
  Underverse packet schema exists

CALIBRATED:
  residual metrics are bounded and deterministic

REVIEWED:
  Lean theorem / benchmark receipt verifies the Underverse transform for a concrete kernel family
```

## Compact definition

```text
The Equation Underverse is the finite, typed, auditable shadow-space of the Equation Forest: for every positive equation, it records the residual, complement, forbidden route, failed binding, anti-surface, and structured absence that the positive equation must exclude or resolve in order to become admissible.
```