Research-Stack/6-Documentation/docs/specs/PROJECTABLE_GEOMETRY_COMPRESSOR_SPEC.md

# Projectable Geometry Compressor Spec

Status: draft v0.1
Date: 2026-05-08
Scope: compression architecture, symbolic geometry, reversible accounting
Primary claim boundary: this is not a physics theory, biological claim, financial claim, or proof of optimal compression. It is a receipt-gated compressor design for projectable geometry with explicit residual accounting.

## 1. Purpose

The compressor exists to edge the compression decimal by turning large structured objects into:

```text
shared projectable geometry
+ compact carrier symbols
+ bounded residual sidecars
+ exact rehydration receipts
```

The core objective is not to discover true physics. The core objective is:

```text
project -> preserve -> improve
```

Where:

```text
project:
  map a large object into a lower-dimensional control basis

preserve:
  track every displaced coordinate in a residual lane

improve:
  reduce per-instance cost once the shared model is amortized over a corpus
```

For a single object, the model cost may dominate. For a corpus, the test is:

```text
K(model) + K(residuals | model) < K(raw objects)
```

No compression claim is promoted until that inequality is benchmarked against baselines.

## 2. Provenance

This spec is grounded in the receipt chain built from the Standard Model Lagrangian term-family probe:

```text
equation wall
  -> 12D term-family source plane
  -> exact rational centroid
  -> signed 16-axis envelope
  -> 4D primitive keel
  -> 12D residual lane
  -> genus-3 residual boat
  -> force-regime model
  -> DNA carrier substitution
  -> absurd genetics stress
  -> extension failure boundary
```

Relevant receipt-bearing runners:

```text
4-Infrastructure/hardware/standard_model_lagrangian_exact_average.py
4-Infrastructure/hardware/standard_model_12_to_4_reduction.py
4-Infrastructure/hardware/standard_model_genus3_residual_boat.py
4-Infrastructure/hardware/standard_model_force_regime_model.py
4-Infrastructure/hardware/standard_model_dna_substitution_alignment.py
4-Infrastructure/hardware/standard_model_absurd_genetics_stress.py
4-Infrastructure/hardware/standard_model_extension_failure_probe.py
```

The design rule extracted from those receipts is:

```text
anything weird is allowed if it is reversible, conserved, and receipted
```

Reference Lean gate:

```text
0-Core-Formalism/lean/Semantics/Semantics/ProjectableGeometryCanonical.lean
```

The Lean gate encodes the canonical dimensional representation and executable
negative witnesses for broken residual and unresolved-shell cases.

## 3. Core Objects

### 3.0 Canonical Dimensional Representation

The current canonical representation is:

```text
16D signed envelope
  -> 12D source/residual plane
  -> 4D primitive keel
  -> genus-3 residual boat
  -> 0D closure
```

Expanded accounting:

```text
16D signed envelope:
  12 exact source axes
  + 4 meta/control axes

12D source plane:
  unreduced canonical source coordinates

4D primitive keel:
  field / shear / packet / spectral

12D residual lane:
  source_12D - lift(project(source_12D))

genus-3 residual boat:
  three handle vectors carrying the residual lane

0D closure:
  no unresolved mass debt
```

The representation law is:

```text
source_12D =
  lift(project(source_12D))
  + residual_12D
```

The genus-3 residual carrier law is:

```text
packet_local
+ shear_torsion
+ spectral_field
= residual_12D
```

The dimensional shell closure prior prices the representation in twelfths:

```text
visible_4d = 4/12
shadow_3d  = 3/12
closure_0d = 1/12
lawbound   = 4/12
unresolved = 0/12
total      = 12/12
```

Promotion requires:

```text
axis counts match 16 -> 12 -> 4 -> 3 -> 0
shell mass closes with unresolved = 0
three residual handles sum to residual_12D
lifted_4D + residual_12D reconstructs source_12D
source hash is present
receipt hash is present
```

Failure cases:

```text
broken residual handle sum -> reject
unresolved shell mass debt -> reject
16D axes without typed semantics -> reject
genus-3 carrier without exact residual replay -> reject
```

Claim boundary:

```text
16D is a typed routing/witness envelope.
12D is a source/residual accounting plane.
4D is a compact primitive control keel.
3D is a three-handle residual carrier.
0D is closure, not deletion.
```

### 3.1 Source Plane

The source plane is the unreduced coordinate system for the current object family.

Example:

```text
12D source plane = twelve symbolic equation term-family axes
```

Requirements:

```text
source axes must be named
source vector must be canonicalized
source vector must have a stable hash
source vector must support exact or bounded numeric representation
```

### 3.2 Primitive Keel

The primitive keel is the compact control vector.

Current four-primitives basis:

```text
field
shear
packet
spectral
```

Interpretation:

```text
field:
  density/value surface coordinate

shear:
  gradient, coupling, torsion, transformation coordinate

packet:
  localized event, witness, claim, or receipt coordinate

spectral:
  eigenmode, covariance, resonance, and residual-spectrum coordinate
```

The primitive keel must be canonical and normalized for the target family:

```text
sum(primitive_keel) = 1
```

### 3.3 Projection Matrix

The projection matrix maps source axes into the primitive keel.

Minimum law:

```text
P : source_n -> primitive_4
rows(P) sum to 1
```

Projection is allowed to be lossy. Loss is lawful only if the residual lane is emitted.

### 3.4 Lift

The lift is the deterministic low-cost reconstruction from the primitive keel back into source coordinates.

The lift is not expected to recover the original source by itself.

```text
lift(project(source)) != source
```

Instead, the compressor must emit:

```text
residual = source - lift(project(source))
```

### 3.5 Residual Lane

The residual lane carries all displaced information required for exact rehydration.

Law:

```text
lift(project(source)) + residual = source
```

Acceptance:

```text
rehydration_l1_error = 0
```

For lossy modes, the receipt must explicitly mark the loss budget and the irreversible boundary.

### 3.6 Genus-3 Residual Boat

The genus-3 residual boat is the current structured residual bucket. It has three handle vectors:

```text
packet_local
shear_torsion
spectral_field
```

Law:

```text
packet_local + shear_torsion + spectral_field = residual
```

Metrics:

```text
hull_capacity_l1 = ||residual||_1
handle_l1
dominant_handle
zero_drift
closure_l1_error
```

Acceptance:

```text
three_handles_sum_to_residual = true
closure_l1_error = 0
zero_drift = true
```

The genus-3 boat is a residual carrier, not a cosmological topology claim.

### 3.7 Signed Envelope

The signed envelope records positive, negative, and origin/control coordinates.

Current test envelope:

```text
12 exact mirror axes
+ 4 meta/control axes
= 16 signed axes
```

Purpose:

```text
make projection distance navigable
record mirror closure
separate exact axes from measurement or residual axes
```

## 4. Carrier Alphabets

The compressor must separate the mathematical basis from the carrier alphabet.

Current compatible carrier:

```text
A -> field
T -> shear
G -> packet
C -> spectral
```

The carrier may be:

```text
binary tags
packed structs
glyphs
DNA-like bases
hachimoji-style extensions
Typst/logogram symbols
virtual baud symbols
```

Carrier substitution is lawful only when it preserves accounting.

## 5. Carrier Laws

### 5.1 Primitive Conservation

Decoded carrier vector must equal the primitive keel.

```text
decode(encode(primitive_keel)) = primitive_keel
```

Failure:

```text
primitive_roundtrip_error
```

### 5.2 Normalized Keel

Carrier mass must preserve the normalized primitive total.

```text
sum(carrier_keel) = 1
```

Failure:

```text
keel_total_not_one
```

### 5.3 Decode Completeness

Every active carrier symbol must have a decode rule.

Failure:

```text
nonzero_unmapped_extension_mass
missing_core_base_decode
```

### 5.4 Primitive Coverage

Every primitive must remain representable.

Failure:

```text
primitive_coverage_failure
primitive_loss
```

### 5.5 Residual Closure

Residual sidebands must close.

```text
sum(residual_sideband) = 0
```

unless explicitly carried as rehydration payload.

Failure:

```text
residual_drift
```

### 5.6 Fail Closed

Ambiguity must reject instead of silently decoding.

Failure:

```text
primitive collision
ambiguous aliasing
unknown primitive target
checksum/hash mismatch
```

## 6. Extension Boundary

Extra carrier bases or symbols are permissible only in three cases:

```text
inert:
  extra symbol carries zero mass

decoded split:
  extra symbol carries mass but maps back to an existing primitive exactly

balanced sideband:
  extra residual sideband carries signed mass but sums to zero
```

Forbidden extension behavior:

```text
untracked extension mass
primitive collisions
missing decode rules
residual drift
primitive loss
ambiguous aliasing
```

This boundary is receipt-backed by:

```text
4-Infrastructure/hardware/standard_model_extension_failure_probe.py
```

## 7. Virtual Baud Reconstruction Layer

The decompressor should be treated as a signal reconstruction path.

Pipeline:

```text
compressed archive
  -> framing decoder
  -> virtual baud reconstruction layer
  -> control-bit interpreter
  -> glyph/kernel dispatch
  -> primitive keel reconstruction
  -> residual boat replay
  -> exact output
```

Lanes:

```text
DATA:
  carrier symbols, literals, glyph/eigen descriptors

CTRL:
  mode switches, kernel dispatch, page/domain framing

CLOCK:
  frame/tick boundaries, phase buckets, resync points

REPAIR:
  residual bytes, correction vectors, patch ops

WITNESS:
  hashes, type witnesses, closure checks, receipts
```

One virtual baud tick is:

```text
one admissible reconstruction event
```

Examples:

```text
emit literal
switch carrier alphabet
apply primitive projection
replay residual handle
verify frame hash
resync stream
```

The baud layer is architectural only if it constrains parsing and recovery. If it merely names a metaphor, it is not part of the codec.

## 8. Packet Shape

The general packet shape is:

```text
PGC1 packet =
  magic/version
  family id
  source basis id
  projection id
  carrier alphabet id
  primitive keel payload
  residual boat payload
  extension sideband payload
  witness/checksum/hash trailer
```

The current finance-claim harness uses `FCL1/FCS1` for a narrower payload family. `PGC1` is the proposed general projectable geometry compressor envelope. It should not replace `FCL1/FCS1` until it can reproduce or improve those receipts.

## 9. Compression Gain Test

A candidate packet is accepted only if its expected gain is positive after decoder cost.

```text
gain =
  baseline_size
  - (
      model_reference_cost
      + projection_payload_size
      + carrier_payload_size
      + residual_payload_size
      + witness_payload_size
      + amortized_decoder_cost
    )
```

Accept:

```text
gain > 0
```

Keep but mark exploratory:

```text
gain <= 0
and structural receipts pass
```

Reject:

```text
rehydration fails
carrier laws fail
baseline comparison missing
claim boundary missing
```

## 10. Codec Baselines

Every benchmark receipt should compare:

```text
canonical JSON or canonical source bytes
zlib
CBOR when available
MessagePack when available
Protobuf/Nanopb-style schema when available
FlatBuffers-style schema when available
packed-struct/custom bitpack
projectable geometry packet
```

Missing optional libraries are skipped, not failures.

No competitive claim is allowed until the corpus is larger than a toy sample set.

## 11. Receipts

Every compressor run emits a JSON audit envelope even if the wire format is binary.

Required receipt fields:

```text
schema
generated_utc
surface_id
source hashes
basis ids
projection ids
carrier alphabet ids
primitive keel
residual lane
residual boat
extension sidebands
closure checks
roundtrip checks
benchmark table
claim boundary
stable hash
timestamped receipt hash
lawful
```

Stable hashes exclude timestamp-only fields. Timestamped receipt hashes include the generated timestamp.

## 12. Failure Codes

Minimum failure vocabulary:

```text
bad_magic
unsupported_version
bad_checksum
unknown_basis
unknown_projection
unknown_carrier
missing_decode_rule
primitive_roundtrip_error
keel_total_not_one
nonzero_unmapped_extension_mass
primitive_coverage_failure
primitive_loss
residual_drift
residual_closure_error
rehydration_l1_error
baseline_missing
gain_not_positive
claim_boundary_missing
```

Failures that affect exactness must fail closed.

## 13. Implementation Phases

### Phase 0: Freeze Laws

Deliverables:

```text
this spec
wiki tiddler
failure vocabulary
receipt schema draft
```

### Phase 1: General Harness

Build a projectable geometry compressor harness that can read a source vector, projection matrix, carrier map, and residual policy.

Commands:

```text
encode
decode
verify
bench
stress-carrier
stress-extension
```

### Phase 2: Binary Envelope

Define `PGC1` as a compact binary envelope.

Required tests:

```text
bit flip rejects
unknown carrier rejects
missing residual rejects
extension mass leak rejects
exact rehydration passes
```

### Phase 3: Corpus Benchmarks

Run over multiple object families:

```text
FinancialClaimPacket
symbolic equation graphs
DNA/base sequence surfaces
Typst/logogram render packets
```

### Phase 4: Optimization

Optimize projection matrices and carrier alphabets:

```text
local search
H200 burst optimizer dry-run, then optional rented run
noisy recovery simulator
virtual baud decoder profiling
```

### Phase 5: Committee Evidence

Export:

```text
Jupyter Book chapter
receipt bundle
benchmark tables
failure-mode appendix
claim-boundary appendix
```

## 14. Acceptance Gates

A compressor candidate is lawful only if:

```text
source canonical hash is recorded
projection rows satisfy stated laws
primitive keel roundtrips
residual lane rehydrates exactly
genus/residual carrier closes
carrier alphabet is bijective or explicitly extended lawfully
extension sidebands are inert, decoded, or balanced
bad mappings fail closed
benchmark baselines are present or explicitly skipped
claim boundary is present
```

The current known positive evidence:

```text
12D -> 4D reduction closes with exact residual rehydration
genus-3 residual boat closes with zero drift
DNA carrier substitution aligns exactly
absurd genetics lawful cases survive
broken non-bijective carrier fails closed
extension failure boundary is identified
```

The current known limitation:

```text
This has not yet demonstrated competitive compression over a large corpus.
It has demonstrated structural stability and exact accounting under carrier recoding.
```

## 15. Non-Claims

This spec does not claim:

```text
new physics
genomic physics
biological implementation
financial correctness
legal/audit validity
compression superiority
Kolmogorov optimality
Hutter Prize competitiveness
```

It claims only a design:

```text
projectable geometry with explicit residual accounting can be made carrier-stable
and fail-closed under known extension failures.
```