---
slug: staged_asymmetric_screening
name: Staged Asymmetric Screening
one_liner: "A cheap, one-sided-error first stage gates access to an expensive authoritative check, so the costly test runs only on the survivors of the cheap one."
type: prime
schema_version: 2
status: density_v2_draft
categories: [structural, computational, economic]
origin_domain: information_processing
alternate_origin_domains: [security_and_cryptography, medical_diagnostics, hiring_and_selection, computer_science]
aliases: [cascade_filtering, cheap_gate_before_expensive_gate, tiered_triage, coarse_to_fine_screening, pre_filter_pipeline]
related: []
solution_archetypes: []
review_flags:
- "OPERATOR-DERIVED (op-05 generalization) — the proposed GENUS of `asymmetric_screening` (lift: strip the single-filter frame and generalize to a multi-stage pipeline where a cheap low-fidelity stage gates an expensive high-fidelity one). Discovered in the op-05 remaining-strata sweep 2026-07-03. Tier B candidate (sonnet coinage — genus label not an established term). STATUS: HOLD pending owner keep/cut."
- "DOMAIN-INSTANCE / RESTATEMENT RISK: the input `asymmetric_screening` already carries the cheap-gate/expensive-check anatomy; this candidate mainly adds the *staging/pipeline* dimension. Must verify it is a genuine super-genus (multiple ordered stages, siblings that are NOT one-sided-error filters) and not just `asymmetric_screening` renamed."
- "Created 2026-07-03; STUB ONLY (frontmatter + Core Idea + Notes). SI/SF/similarity are PROPOSER ESTIMATES pending triangulation. Body sections (Structural Signature onward) NOT written."
- "Phase-C action: re-similarity-check vs `asymmetric_screening` (the input) and any existing triage / pipeline / filter-cascade prime; confirm it is a genuine genus (covers the input AND the antivirus-scan / metal-detector / resume-filter siblings) and not a domain instance or a restatement of the input; draw a subsumption edge asymmetric_screening→candidate + sibling edges at incorporation; sync one_liner to a v1 draft per CLAUDE.md before merge."
substrate_independence:
  composite_substrate_independence: 4
  domain_breadth: 4
  structural_abstraction: 4
  transfer_evidence: 4
  reasoning: 'The bare structure — order a set of tests by cost/fidelity and route each item through the cheap coarse test first, promoting only survivors to the expensive fine test — is a clean, content-free scheduling/routing relation. It presupposes nothing about what is being screened, only a cost ordering over tests and a pass/reject decision at each stage. It recurs identically across malware detection (heuristic scan → deep analysis), physical security (metal detector → manual pat-down), and hiring (keyword filter → human interview), which is genuine cross-substrate transfer. It scores higher than its framed input `asymmetric_screening` because the lift removes the one-sided-error commitment and leaves a pure coarse-to-fine cascade. Held at 4 rather than 5 because the payoff logic still leans on an economic premise (fidelity correlates with cost), a mild content assumption.'
similarity_to_nearest_existing_prime:
  slug: asymmetric_screening
  similarity: 0.7
structural_framed:
  label: structural
  aggregate: 0.28
  criteria: {vocab_travels: 0.9, evaluative_weight: 0.1, institutional_origin: 0.2, human_practice_bound: 0.2, import_vs_recognize: 0.2}
  rationale: 'The candidate is a bare pipeline/routing structure: a cost-ordered sequence of tests with promotion on pass. Its vocabulary (stage, gate, coarse-to-fine, promote) travels freely across computing, security, and selection; it carries almost no evaluative content and is recognized as a structure rather than imported as a doctrine. It reads clearly structural, more so than the framed input from which it was lifted.'
phase_b_passes_completed: []
---
# Staged Asymmetric Screening

## Core Idea

Staged asymmetric screening is the structure in which *a cheap, low-fidelity test is placed in front of an expensive, high-fidelity test and used to gate access to it* — items are run through the coarse stage first, and only those that survive it are promoted to the costly authoritative stage. The genus is reached from its input, `asymmetric_screening`, by stripping the constraint that the front filter be a *single* one-sided-error filter: what remains when you drop the "one filter, deliberately biased error" frame is the more general pattern of an ordered pipeline of tests arranged by ascending cost and fidelity, where each stage's job is to shrink the population the next stage must examine.

The load-bearing anatomy is threefold. First, a *cost/fidelity ordering* over tests: the early stage is cheap and coarse, the late stage is expensive and precise, and the whole value of the arrangement comes from that gap. Second, a *gate*: the coarse stage does not decide the case, it decides only who advances, so the expensive stage never runs on the population the cheap stage has already cleared. Third, a *conservative early bias*: the coarse stage is tuned so that it rarely discards a true positive (it prefers to pass questionable items forward and let the authoritative stage catch them), because a false reject at stage one is unrecoverable while a false pass is merely paid for at stage two. The characteristic payoff is *amortized cost*: the expensive test's per-item price is paid only on the small surviving fraction, so total cost falls dramatically while the final verdict retains the authoritative stage's fidelity. The characteristic cost/failure is *cascaded blindness* — anything the cheap stage wrongly rejects can never be recovered downstream, so a miscalibrated front gate silently caps the accuracy of the entire pipeline, and the two error types must be traded against each other deliberately rather than left to chance.

Read structurally, the same cascade recurs across unlike domains. In *security software*, a fast heuristic or signature scan runs on every file and only flags suspicious ones for slow, deep malware analysis in a sandbox. In *physical screening*, an airport metal detector processes every passenger cheaply and gates the small flagged fraction into an expensive manual pat-down. In *hiring*, a resume keyword filter runs on thousands of applications and promotes a handful to the costly human interview. These are structurally unlike in medium (bytes, bodies, documents) yet identical in form: a cheap conservative gate up front, an expensive authoritative check behind it, and promotion-on-survival between them.

## Notes

**Provenance.** Produced by operator 05 (generalization / lift) as the proposed genus of the input prime `asymmetric_screening`, by stripping the single-one-sided-filter frame to reach a general cost-ordered gating pipeline. Surfaced in the op-05 remaining-strata sweep on 2026-07-03. It claimed the siblings *antivirus heuristic scan → deep malware analysis*, *metal detector → manual pat-down*, and *resume keyword filter → human interview*. Logged as a Tier-B (B-rest) candidate in the op-05 remaining-strata manifest.

**For owner evaluation (keep/cut).** The case FOR: the cheap-gate-before-expensive-gate pattern is a real and recurring engineering structure with clean, structurally-unlike transfer across security, physical screening, and selection, and it scores well on substrate-independence (composite ~4, structural label ~0.28) — it is a pure routing/scheduling relation, cleaner than its framed input. The RISKS Kurt should weigh, plainly: (1) **This is a sonnet COINAGE, not an established genus name** — "staged asymmetric screening" is a descriptive label the operator built for this input, not a term of art; the concept is real but the name may not survive. (2) **Restatement / collapse into the input** — the estimated similarity to `asymmetric_screening` is high (~0.7); the input already contains a cheap-gate/expensive-check pair, so the only new content this candidate adds is the *staging/multi-stage pipeline* generalization and the removal of the one-sided-error commitment. The sharp keep/cut question: **does the pipeline generalization buy enough to warrant a separate prime, or should `asymmetric_screening` simply be broadened in place to cover the coarse-to-fine cascade?** (3) **Alias risk vs. a general filter/triage prime** — if the corpus has or later adds a cascade-filtering, triage, or coarse-to-fine prime, this may be an alias of that instead of a distinct genus.

**At incorporation.** Re-run similarity against `asymmetric_screening` (the input) and against any existing triage, filter-cascade, pipeline, or coarse-to-fine prime to confirm it is neither a restatement of the input nor an alias of a broader filtering prime. If kept, draw a subsumption edge `asymmetric_screening` → `staged_asymmetric_screening` (input as one species of the genus) and sibling edges linking the three named exemplars. If instead Kurt judges the pipeline generalization too thin, prefer broadening `asymmetric_screening` in place and record a cut. Write a v1 draft and sync the one_liner across v1 and v2 per CLAUDE.md before merge.
