---
name: Reduced-Space Test
slug: reduced-space-test
category: AI Engineering
description: Reduced-Space Test validates an uncertain claim in a bounded stand-in space, then reports what holds, fails, or stays inconclusive under those conditions. It also carries the untested remainder forward for follow-up.
github: "https://github.com/jongwony/epistemic-protocols/tree/main/epistemic-cooperative/skills/reduced-space-test"
language: JavaScript
stars: 161
forks: 15
install: "npx degit https://github.com/jongwony/epistemic-protocols/tree/main/epistemic-cooperative/skills/reduced-space-test ~/.claude/skills/reduced-space-test"
installs_to: ~/.claude/skills/reduced-space-test
source_path: epistemic-cooperative/skills/reduced-space-test/SKILL.md
collection_size: 25
category_size: 3670
collection_url: "https://dirskills.com/collections/jongwony/epistemic-protocols"
added: 2026-09-08T05:36:06.944Z
last_synced: 2026-09-08T05:36:06.944Z
canonical_url: "https://dirskills.com/skills/reduced-space-test"
---

# Reduced-Space Test

Reduced-Space Test validates an uncertain claim in a bounded stand-in space, then reports what holds, fails, or stays inconclusive under those conditions. It also carries the untested remainder forward for follow-up.

**Install:**

```bash
npx degit https://github.com/jongwony/epistemic-protocols/tree/main/epistemic-cooperative/skills/reduced-space-test ~/.claude/skills/reduced-space-test
```

## README

# 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` and `/forge`: 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)
  -> 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 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 `BoundedTestSpace` with the user and to emit its `Residual` complement in the same move.

**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.

`/bound` returns the in-scope space and the residual together; carry both forward.

## Phase 3: Capture Empirical Evidence (compose /inquire)

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

- 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` 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.

## Phase 4: Scope the Claim + Carry the Residual Forward

Restrict the resolution to the conditions actually tested, and route the complement onward.

- **Scope the claim**: state the resolution as an updated failure probability within the defined conditions — reduced where the evidence confirmed, raised where it disconfirmed, left open where it was inconclusive. An absolute assertion in either direction ("it behaves identically" / "it is broken") exceeds what any stand-in space can support and is set aside in favor of the scoped form.
- **Carry the residual forward**: route the `Residual` to a follow-up protocol — `/inquire` to gather more before a next decision, or `/elicit` to crystallize what the uncovered region still leaves open. The carry-forward is explicit output, recorded so a later session re-enters the uncovered region without re-deriving it.

At convergence, present the pairing: the scoped resolution with its defined conditions, and the carried residual with its routing. When the run ends in a `CoverageShortfall`, the pairing is the slice-scoped resolution (or an explicit no-resolution where no slice was covered) together with the uncovered claim-remainder as residual — the under-coverage path converges through the same pairing, never as a silent retry. The two together are the evidence that the test was honest about its reach.

## Rules

1. **Facet decomposition is the core act** (orchestration identity): The test's value is the explicit decomposition of the target↔surrogate equivalence into verifiable facets, not the construction of a stand-in space. A reduced space presented without its facet frame is an untested equivalence assumption wearing the appearance of evidence. The decomposed frame is surfaced for user recognition — with an Emergent probe for missing facets — before it constrains the boundary, so which facets count is never a silent AI determination.
2. **Constraint sync is Constitution** (authority boundary): The user defines the bounded space, and that definition constitutes the verifiable claim. The skill surfaces the facet frame and the boundary's includes/excludes; the user draws the cut.
3. **Scoped claim only** (evidence discipline): Resolution sentences assert an updated failure probability within the defined conditions — lower on confirmation, higher on disconfirmation, open on inconclusive. Absolute claims in either direction exceed what a stand-in space supports and are reframed to the scoped form. A disconfirming or inconclusive result is a first-class resolution, never suppressed to force a confirmation.
4. **Residual carries forward** (completeness): The uncovered complement is a first-class output routed to a follow-up protocol. A scoped resolution that omits its residual overclaims its reach.
5. **Scope covers claim** (coverage): The bounded test space must cover the claim it licenses. Evidence from a slice narrower than its claim is under-covering: it yields no scoped resolution for the full claim and exits as a `CoverageShortfall` — re-scope to the covered slice (resolution over the slice + remainder as residual) or re-bound — never an implicit retry.
6. **Compose, do not reinvent** (cost discipline): Reduced-Space Test orchestrates `/bound` and `/inquire` (with a conditional `/elicit` or `/induce` front). It introduces no new interaction deficit and does not constitute a new protocol.

## Boundary Note

`/reduced-space-test` sequences existing protocols and holds the scoping discipline across them. It reads the user's proposition and emits a scoped resolution plus a carried residual; it does not run the experiment substrate, provision environments, or enforce gate passage that belongs to a harness. Domain-specific facet templates (for data, software, or infrastructure stand-in spaces) are a deferred extension — the present contract is domain-free and decomposes facets per claim rather than from a fixed template.

## Anti-patterns

- **Absolute-claim leak**: asserting "it behaves identically" or "it is the same" from stand-in evidence. The claim must be scoped to the tested conditions; absolutes are not defensible from a reduced space.
- **Surrogate without difference inventory**: bounding a test space without naming where it diverges from the target. The unnamed differences are exactly where the scoped resolution silently fails.
- **Residual drop**: presenting the scoped resolution while discarding the complement. The uncovered region is the part most likely to surprise a later session.
- **Space-creation framing**: treating "build the reduced space" as the work and skipping the facet decomposition. The equivalence claim, left implicit, becomes an assumption rather than a tested facet.
- **New-protocol creep**: growing the utility into a standalone protocol with its own deficit. The composite is sufficient; a new mechanism would duplicate `/bound` and `/inquire`.
- **Constraint sync by relay**: drawing the reduced-space boundary on the user's behalf. The boundary constitutes the claim, so it is the user's to set.
- **Silent facet selection**: forming the facet frame and bounding the space without surfacing the frame for user recognition. Which facets count is the attention-shaping act; chosen silently, it injects the AI's bias into the very frame that licenses the claim.
- **Confirmation-only terminal**: treating the test as complete only when it confirms, with no honest terminal for a disconfirming or inconclusive result. A validation that cannot fail validates nothing; the disconfirming outcome is first-class.

## Operational checklist (per cycle)

- [ ] Phase 0 the `InferenceUncertainClaim` is stated; a `/elicit` or `/induce` front is used only when the intent is aporetic or the pattern is unnamed
- [ ] Phase 1 critical facets, surrogate↔target difference inventory, influence-path hypotheses, and a gap-measurement approach are surfaced as the `ScopedClaimFrame`, and the frame is surfaced for user recognition (with an Emergent missing-facet probe) before Phase 2 draws the boundary over it
- [ ] Phase 2 `/bound` defines the `BoundedTestSpace` with the user as a Constitution interaction and emits the `Residual`
- [ ] Phase 3 `/inquire` captures `EmpiricalEvidence` inside the bounded space under a scope-covers-claim discipline
- [ ] Phase 4 the resolution is scoped to the tested conditions (no absolute claim; a disconfirming/inconclusive outcome recorded as a first-class resolution, not retried into a confirmation) and the `Residual` is routed to a follow-up protocol
- [ ] Convergence pairs the scoped resolution with its defined conditions and the carried residual with its routing (or, on under-coverage, a `CoverageShortfall`: slice-scoped resolution + uncovered remainder as residual, or a re-bound)