---
slug: information_discarding_projection
name: Information-Discarding Projection
one_liner: "A structure-preserving mapping from a richer representation to a poorer one that deliberately discards whatever the map does not preserve, keeping the target's dimensions while collapsing the rest irrecoverably."
type: prime
schema_version: 2
status: density_v2_draft
categories: [structural, computational, epistemic]
origin_domain: mathematics
alternate_origin_domains: [information_theory, computer_science, statistics, signal_processing]
aliases: [lossy_mapping, dimension_reduction_map, forgetful_map, information_erasure_projection, many_to_one_collapse]
related: []
solution_archetypes: []
review_flags:
- "OPERATOR-DERIVED (op-05 generalization) — the proposed GENUS of `projection` (lift: strip the geometric/linear-algebra frame — 'onto a chosen direction or subspace' — to expose the bare information-theoretic move of any structure-respecting mapping that discards what it does not preserve). Discovered in the op-05 remaining-strata sweep 2026-07-03. Tier A candidate (genuine cross-domain genus: compression, type erasure, marginalization; verified absent). STATUS: HOLD pending owner keep/cut."
- "Tier-A convergence/absence flag (from data): genuine cross-domain genus (lossy compression, abstraction/type-erasure, statistical marginalization over nuisance variables); corpus lacks it and all three siblings pass the sibling test, so this is not a single-instance coinage."
- "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 `projection` (the input) and the named siblings; confirm it is a genuine genus (covers `projection` AND compression / type-erasure / marginalization) and not a domain instance or a restatement of the input; also disambiguate from any existing abstraction / information-discarding-projection / lossy-compression prime; draw a subsumption edge input→candidate + sibling edges at incorporation; sync one_liner to a v1 draft per CLAUDE.md before merge."
substrate_independence:
  composite_substrate_independence: 5
  domain_breadth: 5
  structural_abstraction: 5
  transfer_evidence: 5
  reasoning: 'The bare structure — a mapping from a source with more degrees of freedom to a target with fewer, respecting the target''s structure while irrecoverably collapsing everything the map does not preserve — is a pure relational/information-theoretic form with no domain content. It is instantiated identically by linear projection onto a subspace, lossy audio/image compression, type erasure and abstraction in programming languages, and statistical marginalization over nuisance variables, and it underwrites the data-processing inequality. Every subscore sits at the top: the vocabulary (source, target, preserved vs. discarded degrees of freedom) travels everywhere, structural abstraction is maximal, and transfer evidence is unusually rich and genuinely cross-domain (math, information theory, PL type systems, statistics, signal processing). This is a paradigm generalization lift — the geometric input `projection` is one species of a fully substrate-independent genus.'
similarity_to_nearest_existing_prime:
  slug: projection
  similarity: 0.68
structural_framed:
  label: structural
  aggregate: 0.10
  criteria: {vocab_travels: 0.1, evaluative_weight: 0.0, institutional_origin: 0.1, human_practice_bound: 0.1, import_vs_recognize: 0.2}
  rationale: 'This is a bare structural/information-theoretic relation carrying no evaluative content (discarding information is neither good nor bad in itself) and no binding to a human institution or practice. Its vocabulary travels across mathematics, computing, statistics, and signal processing without translation, and it is recognized as the same move wherever a many-to-one structure-preserving map appears rather than imported as a domain doctrine. It reads clearly structural — one of the most substrate-neutral candidates in the sweep.'
phase_b_passes_completed: []
---
# Information-Discarding Projection

## Core Idea

Information-discarding projection is the bare structural move of *mapping a richer representation onto a poorer one in a way that respects the target's structure while deliberately, and irrecoverably, discarding everything the map does not preserve*. The single constraint stripped from the input `projection` is its geometric/linear-algebra frame: the input specifies a mapping "onto a chosen direction or subspace," collapsing the dimensions perpendicular to a target *within a vector space*. This genus keeps the information-theoretic essence — many-to-one, structure-preserving, lossy — and drops the requirement that source and target be geometric spaces or that the map be linear. What remains is any forgetful mapping between representations that keeps some degrees of freedom and throws the rest away.

The load-bearing anatomy has four commitments. First, a *source* with more degrees of freedom than will survive the map. Second, a *target* with fewer, whose structure the map respects (parallels are preserved). Third, a *retained axis / preserved substructure* — the part of the source the map keeps faithful. Fourth, and definitively, *irrecoverable discard*: the information orthogonal to the target is collapsed and cannot in general be reconstructed from the image, which makes the map many-to-one and is exactly why it is a *projection* and not a lossless re-encoding. The characteristic payoff is tractability and generalization: by discarding what is not needed for the purpose at hand, the projection yields a smaller, more stable, more portable representation — the whole value of abstraction, compression, and dimensionality reduction. The characteristic cost and failure is the twin of the payoff and is governed by the data-processing inequality: whatever is discarded is *gone*, so the projection can silently destroy information that later turns out to matter, and two genuinely different sources can be mapped to the same image (aliasing/confusion), making the loss invisible until a downstream task needs the collapsed dimension.

Read as a genus rather than as the geometric input, the same skeleton recurs across structurally unlike domains. In *signal and media processing*, lossy compression codecs (JPEG, MP3) are exactly this move — map the full signal onto a perceptually-weighted, lower-rate representation and discard the rest, unrecoverably, in exchange for size. In *programming-language type systems*, abstraction and type erasure project a value onto a coarser interface or erase generic type parameters at runtime — the concrete detail is preserved for the compiler's structural purposes and then irrecoverably discarded from the running representation. In *statistics*, marginalization over nuisance variables projects a joint distribution onto a subset of variables, integrating out and discarding the marginalized dimensions. Geometric projection, lossy codec, type erasure, and marginalization are four genuinely different substrates; the shared skeleton — richer source, structure-respecting map, retained axis, irrecoverable discard — is what makes this a real lift rather than the input restated.

## Notes

**Provenance.** Produced by operator 05 (generalization / lift) as the proposed GENUS of the input `projection`, by stripping the geometric/linear-subspace frame to expose the underlying information-theoretic move of a structure-preserving, information-discarding mapping. Surfaced in the op-05 *remaining-strata* sweep on 2026-07-03. It claimed three cross-domain siblings — lossy compression codecs, abstraction / type erasure in type systems, and statistical marginalization over nuisance variables. Manifest tier: A (Tier-A "rest"; genuine cross-domain genus, verified absent).

**For owner evaluation (keep/cut).** The case FOR is strong: this is a *genuine established genus*, not a coinage — the underlying object (a forgetful / lossy map, formalized by the data-processing inequality and by the notion of a forgetful functor / non-injective structure-preserving map) has an independent identity across mathematics, information theory, and computer science, and it is instantiated by three unrelated siblings that each pass the sibling test cleanly. Substrate independence is essentially maximal (SI estimate 5). The specific RISKS: (1) **collapse into the input (restatement / alias)** — estimated similarity to `projection` is ~0.68, so the sharp keep/cut question is whether `projection` should simply *be* this genus (re-headed to the structural framing, geometry demoted to lead example) or whether the corpus wants a narrow geometric `projection` plus this broader information-discarding parent. Because the input already reads fairly structurally, the merge-up option is live and Kurt should decide it explicitly. (2) **Overlap with an existing abstraction / lossy-representation prime** — the corpus plausibly already carries something in the neighborhood of "abstraction," "lossy compression," or "information discarding"; before accepting, confirm this genus is not an alias of an existing prime under a different name (the readability layer and prior sweeps have touched information-discarding themes). This is the single most important pre-accept check. (3) **Scope breadth** — because the genus is so general, it risks being *too* thin (every many-to-one map is an instance); the keep decision should confirm the *irrecoverable-discard* + *structure-preservation* pair carries enough content to be a load-bearing prime rather than a near-tautology.

**At incorporation.** Re-run similarity against `projection` (the input) and, critically, against any existing `abstraction`, `lossy_compression`, `information_discarding`, or dimension-reduction prime to rule out an alias before accepting. If distinct, draw a subsumption edge `projection` → `information_discarding_projection` (geometric input is a framed species of the information-theoretic genus) and sibling/example edges to the compression, type-erasure, and marginalization cases; add a missing-edge note to the data-processing-inequality neighborhood if such a prime exists. Write a v1 draft and sync the one_liner across v1 and v2 per CLAUDE.md before merge.
