# v7-W ε-frontier catalog

**Companion to:** `docs/_source/merkle-agi-v7w-spatial-temporal.rst`
(the v7-W substrate paper, ticket #000013).
**Status:** draft v0, 2026-05-09.

This catalog enumerates the four canonical ε-frontiers in
v7-W — the kernel-boundaries where ε proofs are admissible. Each
is **affine after appropriate canonical projection** (T4-W) and
each has a published quantization-derived ε bound.

A frontier is the boundary between "model forward pass" and
"committed integer kernel." Below the frontier, proofs are at
the float-tensor level (v7's domain). Above the frontier,
canonical bytes admit replay-audit.

---

## Reference table

| Frontier | Domain | Canonical kernel | ε bound | Reuses |
|---|---|---|---|---|
| `pose_integration`     | object pose / agent ego-motion       | SE(3) integer composition | Δ_rot + Δ_trans · |t_max| | v7 § 5 bigint accumulator |
| `observation_update`   | Kalman / Bayesian state update       | affine in innovation       | Δ_innovation + Δ_covariance | v7 § 5; arithmetic@v1 for residual fold |
| `object_logits`        | per-object classification logits     | linear projection          | manifest-declared per-class | v7 § 11 multimodal composition |
| `relation_logits`      | pairwise scene-graph edge prediction | bilinear scoring           | predicate-whitelist + feature granularity | v7 § 11; relation_graph carrier |

Each frontier's full design lives in the substrate paper Part 4;
this catalog is the operator-facing quick reference.

---

## §1 `pose_integration`

**Inputs (canonical bytes):**

```
{
  "prev_pose_quantized": {
    "axis_angle_int32": [<int32 x 3>],
    "translation_int32": [<int32 x 3>]
  },
  "ego_motion_quantized": {
    "axis_angle_int32": [<int32 x 3>],
    "translation_int32": [<int32 x 3>]
  },
  "Δ_t_ticks": <int32>
}
```

**Output:**

```
{
  "next_pose_quantized": {
    "axis_angle_int32": [<int32 x 3>],
    "translation_int32": [<int32 x 3>]
  }
}
```

**Operator.** SE(3) composition. The axis-angle representation
is integer-encoded with manifest-declared `Δ_rot_milli_radians`;
translation in `Δ_trans_micrometers`. Composition uses bigint
arithmetic to avoid float drift, then re-quantizes to the
manifest grid.

**ε bound.** Per-step: `Δ_rot + Δ_trans · |translation_max|`.

**Affine after canonical projection.** The axis-angle
representation linearizes rotation under small-time-step
assumption (the common SLAM regime); the linearization error
is bounded by the small-angle approximation residual, captured
in the manifest's published `Δ_rot_residual_bound` field.

**When to use.** Every agent-trace tick. Every object whose
pose changes between observations.

---

## §2 `observation_update`

**Inputs (canonical bytes):**

```
{
  "prior_state_quantized": [<int32 x state_dim>],
  "prior_covariance_quantized": [[<int32>], ...],
  "observation_quantized": [<int32 x obs_dim>],
  "innovation_covariance_quantized": [[<int32>], ...],
  "observation_matrix_quantized": [[<int32>], ...]
}
```

**Output:**

```
{
  "posterior_state_quantized": [<int32 x state_dim>],
  "posterior_covariance_quantized": [[<int32>], ...]
}
```

**Operator.** Standard Kalman update:

```
innovation = observation - H · prior_state
K_gain = prior_cov · H^T · (H · prior_cov · H^T + innov_cov)^-1
posterior_state = prior_state + K_gain · innovation
posterior_cov = (I - K_gain · H) · prior_cov
```

All arithmetic uses bigint accumulators (v7 § 5) to avoid
analog leakage in the matrix inversion. Final values
re-quantized to the manifest grid.

**ε bound.** Per-step: `Δ_innovation + Δ_covariance`.

**Affine after canonical projection.** Innovation is affine in
observation; gain application is affine in innovation; posterior
update is affine in gain. The matrix inverse is the only
non-affine step — handled by bigint arithmetic + re-quantization
so the canonical bytes remain deterministic.

**When to use.** Every observation that updates a stateful
estimate (object pose, agent location, place geometry).
Stateless classifications (single-frame object detection
without temporal smoothing) skip this frontier.

---

## §3 `object_logits`

**Inputs (canonical bytes):**

```
{
  "object_features_quantized": [<int32 x feature_dim>],
  "classifier_weights_quantized": [[<int32>], ...],
  "classifier_bias_quantized": [<int32 x num_classes>]
}
```

**Output:**

```
{
  "logits_quantized": [<int32 x num_classes>]
}
```

**Operator.** Linear projection: `logits = W · features + b`.
All on quantized integers. Pre-softmax — softmax itself is
NOT in the kernel (softmax is monotone and order-preserving
on the logits, so commitments to logits implicitly commit to
the softmax-class predictions).

**ε bound.** Manifest-declared per-class quantization
threshold. Typical values: 1/256 of the full logit range.

**Affine after canonical projection.** Linear-in-features by
construction.

**When to use.** Every object-detection commitment. Multimodal
pipelines that route through v7's vision encoder use this
frontier as the v7→v7-W handoff.

---

## §4 `relation_logits`

**Inputs (canonical bytes):**

```
{
  "subject_features_quantized": [<int32 x feature_dim>],
  "object_features_quantized": [<int32 x feature_dim>],
  "relation_classifier_weights_quantized": [[<int32>], ...]
}
```

**Output:**

```
{
  "relation_logits_quantized": [<int32 x predicate_count>]
}
```

**Operator.** Bilinear scoring on the (subject, object) feature
pair. The bilinear tensor B is canonicalized to its tensor-
decomposed form (Tucker decomposition with manifest-declared
ranks; or CP decomposition for low-rank cases). Scoring then
factorizes:

```
score_per_predicate = subject_features · core · object_features^T
```

…with `core` being the canonicalized decomposition.

**ε bound.** `predicate-whitelist size factor + feature
quantization`. The whitelist size factor accounts for the
finite alphabet of declared predicates per substrate.

**Affine after canonical projection.** Bilinear becomes affine
once the subject (or object) features are fixed; the
factorization makes this explicit. Substrate manifest pins the
factorization rank to keep the canonical bytes deterministic.

**When to use.** Every scene-graph edge commitment. Relation
extraction in multimodal pipelines.

---

## Cumulative ε across frontiers

Per the data-processing inequality, ε accumulates additively
across composed kernels:

```
ε_total = Σ_frontier (ε_frontier × invocation_count)
```

A typical 10-tick agent trace with 3 detected objects + 6
relations:

```
10 ticks × (pose_integration + observation_update)
       + 30 object_logits invocations (3 obj × 10 ticks)
       + 60 relation_logits invocations (6 rel × 10 ticks)
```

Each invocation contributes its frontier's per-step ε. Operators
size their grid choices (manifest's Δ values) to keep ε_total
under the downstream consumer's tolerance.

---

## Out of scope (per #000013 §5)

- **Continuous-state kernels** that haven't been re-canonicalized
  to integer state. v7-W requires explicit integer-encoding;
  proofs at the float layer live in v7 + arborist's existing
  integer-kernel discipline (SQD § 5).
- **Sensor-specific kernels** (LIDAR ICP, RGB-D fusion). Each is
  a separate adapter ticket; the four frontiers above are the
  *abstract* kernel set, not deployment-specific implementations.
- **Cross-substrate frontiers** (v7-W ↔ arborist-text). Captured
  by the cross-domain π* composition theorem (#000015) and the
  multimodal composition section in the v7-W substrate paper
  (Part 5).

---

## Status

Catalog draft v0. Each frontier's full proof-of-affine-property
and ε derivation will be folded back into the substrate paper
(Part 3 theorems) once the catalog stabilizes. This document is
the operator-facing quick reference; the substrate paper is the
formal source.
