Reduced Space Test

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 project /bound's source-grounded result into a synchronized test space and coverage complement ∘ /inquire for evidence inside it → scoped resolution + carried complement. It is a thin composition over existing protocols, kept outside the core protocol set 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)
  -> /bound outcome        (an applicable DefinedBoundary proceeds; other exits keep what they left — a withdrawal's record, or a gate still holding — under Phase 2)
  -> recognition of the undrawn cut   (the user draws every part of the cut no act of theirs drew)
  -> BoundedTestSpace       (applicable result projected into settled test scope, coverage complement, and pending boundary obligations)
  -> EmpiricalEvidence      (/inquire: observe inside the bounded space, evidence over inference)
  -> ScopedResolution | CoverageShortfall   (carry the scope record, including pending boundary obligations; 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)

An empirical terminal pairs a scoped result (ScopedResolution or CoverageShortfall) with a carried residual: the supported outcome or explicit shortfall, paired with the coverage complement. The scoped result retains its scope record, including still-pending boundary obligations with their sources and next treatment; these obligations remain distinct from coverage. A /bound run that ends without an applicable DefinedBoundary follows Phase 2 and supplies no successful validation result.

Types

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      [applicable DefinedBoundary, or another actual exit]  Phase 2
   -> recognize the cut the user did not draw                         Phase 2, before projection
   -> project scope, coverage complement, and pending obligations     Phase 2, only with the applicable result
   -> /inquire    [ContextInsufficient -> SufficientContext, Observe]  Phase 3
   -> residual carry-forward (/inquire | /elicit)                      Phase 4

• On an actually emitted, applicable DefinedBoundary, project the validation scope and its coverage complement from the current boundary entries, their setting record, and the ScopedClaimFrame. An item in the boundary's residual can be pending work inside the scope; an established exclusion can belong to the coverage complement with no unsettled judgment. Preserve this distinction when composing the result.
• At the /inquire handoff, pass the settled scope, conditions, and source-grounded pending obligations that bear on the observation. Its scope-covers-claim discipline governs what the evidence can support.

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 would inject attention bias at the root; surfacing it for recognition keeps the choice of which facets count with the user.

Phase 2: Bound the Test Space (compose /bound)

Compose /bound (Horismos: BoundaryUndefined -> DefinedBoundary) to define the validation boundary with the user, then derive BoundedTestSpace only from an actually emitted DefinedBoundary applicable to this claim. A /bound this utility composes is an explicit invocation.

Constraint sync is a Constitution interaction. The user defines the reduced space, and that definition constitutes the verifiable claim — testing "does the API respond" and testing "does the API sustain its rated throughput" are different reduced spaces that license different claims. The boundary the user draws is therefore not a mechanical narrowing; it determines what the eventual resolution is allowed to assert. Surface the facet frame from Phase 1 so the user draws the boundary in recognition of what each cut includes and excludes.

• Before projecting, present for the user's recognition every part of the cut they did not draw themselves — in their own words, by selecting or accepting what they were shown, or by an earlier decision of theirs, however /bound cites it. What observation returned draws nothing, and neither does a choice the AI made inside a grant. Show what each side includes and excludes; the user's answer draws it, and nothing is projected from that part alone.
• When an applicable DefinedBoundary has been emitted, read its map and setting record to resolve the actual included conditions and exclusions against the ScopedClaimFrame. Project the included conditions into the test scope and the uncovered facets into this utility's Residual; cite the source of each cut.
• When /bound ends without an applicable DefinedBoundary, preserve what it left — a withdrawal's record (the snapshot at the user's word, and the boundary that last stood, if any), or a gate still holding (its context, from which its map is read) — with its sources, limits, and open decisions. Respect the actual exit and the user's instruction: a withdrawal ends the withdrawn composition, a continuation the user names follows its stated reach, and an unanswered boundary judgment holds dependent validation. Neither an empty successful boundary nor an automatic restart is supplied by the exit. Resume projection only when an actual applicable result is available. Where a boundary already projected reopens — /bound holds again, keeping the boundary that last stood — dependent validation waits on the reopened items and resumes from the boundary when it stands again; evidence already observed inside still-settled conditions stays evidence of those conditions.
• When the emitted boundary carries unresolved material, retain it in BoundedTestSpace with the next treatment each open item of the boundary's residual names — who settles it under its governing arrangement, and why it bears — reading its dependencies from the map. Distinguish a pending in-scope selection or prerequisite from an uncovered facet; copying the entire boundary residual as the coverage complement loses that distinction.
• Before empirical work depends on an unsettled scope value or prerequisite, resolve it through its source-defined disposition or return to the affected /bound judgment in Phase 2. Continue independent authorized observation only within already-settled conditions. Carry still-pending obligations in the final scoped result's scope record, with sources and required next treatment.

Phase 3: Capture Empirical Evidence (compose /inquire)

Compose /inquire (Aitesis: ContextInsufficient -> SufficientContext) to observe inside the BoundedTestSpace and settle the scoped uncertainty (confirm, disconfirm, or find it inconclusive).

• Read the projected scope and pending obligations before observation; satisfy the dependencies of the observation under their setting sources.
• Capture observation evidence in the bounded space — evidence over inference, with cited basis.
• Hold the scope-covers-claim discipline: the space actually exercised must cover the claim the evidence will license. Evidence drawn from a narrower slice than the claim it is asked to support is under-covering and does not yield a ScopedResolution.

The output is EmpiricalEvidence plus a ScopedResolution retaining the BoundedTestSpace scope record and recording the outcome — confirming, disconfirming, or inconclusive — for the bounded space. Under-coverage (evidence drawn from a slice narrower than the claim) is the one case that yields no ScopedResolution for the full claim — its typed exit is a CoverageShortfall: re-scope the resolution to the slice actually covered (resolution over the slice + the uncovered remainder carried as Residual) or re-bound the space (→ Phase 2). A disconfirming result, by contrast, is a resolution, not its absence. Both empirical terminal forms carry the scope record and its still-pending obligations; explicitly state when none remain.