reduced-space-test

What this skill does

# Reduced-Space Test: Scoped Empirical Validation

Validate an inference-uncertain proposition inside a constraint-bounded stand-in space synchronized with the user, obtain a scoped resolution ("within these conditions, whether it holds, fails, or remains inconclusive"), and carry the uncovered complement forward to a follow-up protocol. This skill does not run the experiment substrate, open branches, or create PRs. It orchestrates existing protocols around one disciplined empirical move.

**This is an orchestration utility, not a runtime executor and not a new epistemic protocol.** Reduced-Space Test introduces no new interaction deficit. It realizes a known composite — decompose the target↔surrogate equivalence claim into verifiable facets, then `/bound` a synchronized test space (+ residual) ∘ `/inquire` for evidence inside it → scoped resolution + carried complement. It is sibling to `/triage`, `/dispatch`, and `/forge`: a thin composition over existing protocols, kept out of the protocol graph because it owns no deficit of its own.

The core recognition act is **decomposing the equivalence claim into verifiable facets** — not "creating a reduced space." A stand-in space is only as good as the facets on which it is claimed equivalent to the target; the value lives in making those facets explicit and observable.

## Core Contract

`/reduced-space-test` owns scoped empirical validation:

```
InferenceUncertainClaim
  -> ScopedClaimFrame       (core: decompose target↔surrogate equivalence into verifiable facets)
  -> BoundedTestSpace       (/bound: user-synchronized in-scope space + residual complement)
  -> EmpiricalEvidence      (/inquire: observe inside the bounded space, evidence over inference)
  -> ScopedResolution | CoverageShortfall   (scoped outcome — holds, fails, or inconclusive — within the claim's defined conditions; or, on under-coverage, a CoverageShortfall: slice-scoped resolution or no resolution, with the remainder re-bounded or carried)
  -> Residual               (uncovered complement -> follow-up protocol)
```

The orchestration produces two first-class outputs: a **scoped resolution** (the proposition's outcome — holds, fails, or inconclusive — within the tested conditions) and a **carried residual** (the complement the test did not cover). Neither stands without the other — a scoped resolution that hides its residual overclaims.

## Types

| Type | Meaning |
|---|---|
| `InferenceUncertainClaim` | A proposition about behavior, performance, transfer, or value that inference alone cannot settle and that the user wants grounded in evidence. |
| `EquivalenceClaim` | The asserted target-environment ↔ surrogate-space equivalence the test rests on. The test is only valid on the facets where this equivalence is itself examined. |
| `VerifiableFacet` | One decomposed, observable dimension of the equivalence claim — a place where target and surrogate can be compared and a gap measured. |
| `ScopedClaimFrame` | The Phase 1 output: the decomposed set of `VerifiableFacet`s the test will and will not speak to — critical facets, the surrogate↔target difference inventory, influence-path hypotheses, and the chosen gap-measurement approach. Surfaced for user recognition before it constrains the boundary; it is what keeps the later evidence sentence honest. |
| `BoundedTestSpace` | The in-scope validation space defined with the user through `/bound`, paired with its residual complement. The space's definition is what constitutes the verifiable claim. |
| `Residual` | The complement the bounded space does not cover. A first-class output, carried forward, never dropped. |
| `EmpiricalEvidence` | Observation captured inside the bounded test space through `/inquire` — evidence with cited basis, scoped to the conditions actually exercised. |
| `ScopedResolution` | The scoped outcome within the bounded space on the tested facets: the proposition holds, fails, or remains inconclusive — stated as an updated failure probability within the defined conditions (lower on confirmation, higher on disconfirmation), never a bare "it works". A disconfirming or inconclusive result is a first-class resolution, not a loop failure. |
| `CoverageShortfall` | The typed outcome when the bounded space turns out narrower than the claim it must license (under-coverage): no `ScopedResolution` is issued for the full claim; the honest exit re-scopes the resolution to the slice actually covered (resolution over the slice + the uncovered remainder carried as `Residual`) or re-bounds the space (→ Phase 2). A bounded exit, never an implicit retry. |

## Composition

Reduced-Space Test orchestrates existing protocols; most per-step work is delegated to them, while this skill owns the Phase 1 facet decomposition outright, plus the sequencing and the scoping discipline across the protocols it composes.

```
(conditional front) /elicit | /induce                              Phase 0
   -> decompose equivalence claim into facets [owned: ScopedClaimFrame]  Phase 1
   -> /bound      [BoundaryUndefined -> DefinedBoundary, + residual]  Phase 2
   -> /inquire    [ContextInsufficient -> InformedExecution, Observe]  Phase 3
   -> residual carry-forward (/inquire | /elicit)                      Phase 4
```

`/bound` natively emits a boundary plus its residual, so the complement is produced by the bound step itself rather than bolted on afterward. `/inquire` natively captures observation evidence under a scope-covers-claim discipline, so the empirical step reuses that grounding rather than re-deriving it.

## Phase 0: Intake + Name the Pattern (conditional)

Read the `InferenceUncertainClaim`: the proposition the user cannot settle by reasoning alone, and why evidence in a stand-in space is wanted.

Front with a crystallization step only when the test intent is genuinely under-formed:

- If the test intent is aporetic — the user senses an unknown but cannot yet state the proposition — front with `/elicit` (Euporia) to surface it.
- If the test pattern recurs but is unnamed — the same stand-in-validation shape appears across cases without a handle — front with `/induce` (Periagoge) to crystallize it.

When the proposition is already stated and the pattern is familiar, proceed directly to Phase 1. The front step is a conditional affordance, not a mandatory gate.

## Phase 1: Decompose the Equivalence Claim into Facets

This is the core act. The test rests on an `EquivalenceClaim` — that the surrogate space stands in for the target on the dimensions that matter. Make that claim observable:

- **Surface critical facets**: the dimensions on which the proposition's truth in the target depends (behavior, load, distribution, configuration, value).
- **Inventory surrogate↔target differences**: where the stand-in space diverges from the target, named rather than assumed away.
- **Hypothesize influence paths**: how each difference could change the outcome, so the test targets the differences that matter.
- **Choose a gap-measurement approach**: the means by which the surrogate-to-target gap is observed (for example randomization across conditions, shadowing live input, or a staged canary), selected for the facets in play.

The output is a `ScopedClaimFrame`: the facets that the test will and will not speak to. This frame is what keeps the later evidence sentence honest.

**Surface the frame for recognition before it constrains the boundary.** The facet set is an AI-formed hypothesis, not a settled determination — present it to the user as a structured, recognizable set (the critical facets, the surrogate↔target differences, and what is deliberately out of frame), with an explicit Emergent probe: *is any decision-relevant facet missing, and are these the dimensions that actually matter?* The user confirms, extends, or reweights the frame. Because the facet decomposition is the act that shapes where the test's attention goes — and that frame licenses every later claim — letting the AI fix it silently wou