---
slug: expansion_unpacking
name: Expansion (Unpacking)
one_liner: "Transform a condensed representation back into an explicit, redundant form that trades size for direct accessibility — the reconstruct-and-elaborate dual of compression along the compactness-vs-explicitness axis."
type: prime
schema_version: 2
status: density_v2_draft
categories: [computational, structural, mathematical]
origin_domain: information_theory
alternate_origin_domains: [computer_science, mathematics, linguistics]
aliases: [decompression, unpacking, unfolding, decoding, expansion]
related: []
solution_archetypes: []
review_flags:
- "OPERATOR-DERIVED (op-01 dualization, sub-flavors 1a/1c) — the inverse-transform dual of `compression` along the compactness-vs-explicitness (redundancy-out vs redundancy-in) axis. Discovered in the op-01 full sweep 2026-07-03. Verified absent via search_prime + slug check. COLLISION/OVERLAP RISK flagged in manifest: potential screen overlap with `redundancy` — must be screened carefully. STATUS: HOLD — pending owner curation."
- "Created 2026-07-03; STUB ONLY (frontmatter + Core Idea + Notes). Did NOT go through Phase-A triage. SI/SF/similarity grades are PROPOSER ESTIMATES pending triangulation. Body sections (Structural Signature onward) NOT yet written."
- "Phase-C action: re-similarity check vs `compression` (the input/dual), `redundancy` (flagged overlap), `decoding`, and any `inverse_function`/`invertibility` prime to confirm it is not (a) a mere restatement of compression's inverse leg, or (b) subsumed by `redundancy`; at incorporation draw the dual/sibling edge to `compression` and the parent edge to whatever transform-inverse genus is chosen. one_liner must be synced to a v1 draft per CLAUDE.md before merge."
substrate_independence:
  composite_substrate_independence: 3
  domain_breadth: 3
  structural_abstraction: 4
  transfer_evidence: 3
  reasoning: 'The structure — apply the inverse of a size-reducing encoding to recover an explicit, directly-usable form, reintroducing redundancy so that consumers no longer pay a per-access reconstruction cost — is medium-neutral and states cleanly as "the inverse leg of a compress/expand transform pair," earning structural abstraction a 4. It recurs beyond file decompression: macro/template expansion and inlining in compilers, expanding a recurrence or product into its explicit terms in mathematics, unfolding a folded/loop representation, elaborating an abbreviation or ellipsis in language, and expressing a compact rule as an explicit lookup table. Domain breadth is a 3 because the strongest instances cluster in computing and mathematics; linguistic/perceptual instances are real but softer. Transfer evidence is 3 — the compress/expand duality is well understood inside information theory and CS, but as an *independent* prime (rather than the trailing half of compression) its cross-domain standing is asserted more than demonstrated, and the redundancy-overlap risk is unresolved.'
similarity_to_nearest_existing_prime:
  slug: compression
  similarity: 0.71
structural_framed:
  label: structural
  aggregate: 0.08
  criteria: {vocab_travels: 0.1, evaluative_weight: 0.0, institutional_origin: 0.0, human_practice_bound: 0.0, import_vs_recognize: 0.2}
  rationale: 'Recovering an explicit, redundant representation by inverting a size-reducing encoding is a pure transform-on-representations relation: medium-neutral, carrying no normative or institutional content, running with no human in the loop (a decompressor, a CPU expanding a macro, a math identity all do it). Every diagnostic reads at or near zero; the faint import_vs_recognize reflects that "unpack/expand" is mildly a term of art. This is clearly structural — the open question is not its structural/framed character but whether it is *distinct enough* from compression and redundancy to stand alone.'
phase_b_passes_completed: []
---
# Expansion (Unpacking)

## Core Idea

Expansion is the transformation that takes a *condensed* representation and produces an *explicit, redundant* one — recovering, from a form built to be small, a form built to be directly usable. It is one pole of a single axis, *compactness versus explicitness* (equivalently, *redundancy removed versus redundancy restored*), whose opposite pole is `compression`. Where compression exploits redundancy to encode information in fewer symbols than the original, expansion runs the inverse: it re-introduces the structure that compression squeezed out, turning a compact encoding back into a spelled-out representation whose parts are individually present and directly addressable rather than implied.

The pattern's load-bearing commitments are three. First, there is a *compact source* — a representation that is short precisely because some of its content is left implicit (folded into a rule, a reference, a recurrence, a code). Second, there is an *inverse map*: expansion is defined relative to a condensing transform, and its job is to undo that transform's size reduction, making implicit content explicit. In the *lossless* case the recovery is exact (decompression reconstructs the original bit-for-bit); where the original condensing was lossy, expansion can only restore the *form*, not the discarded information — it re-inflates to full size without recovering what was thrown away, which is why expansion is not a guarantee of fidelity but of *explicitness*. Third, expansion *pays size to buy accessibility*: the expanded form is larger, but its content is available without further reconstruction work, so consumers stop paying the per-access decode cost that the compact form imposes. This is the characteristic trade, and it is the exact mirror of compression's: compression trades access cost for size; expansion trades size for access. Neither pole is the default-correct one — the right one depends on whether the representation is storage/transmission-bound (favor compact) or read/use-bound (favor explicit).

Structurally this is one pattern across substrates because "invert a size-reducing encoding to recover an explicit form" names no medium. It is file *decompression* and codec *decoding* in information systems; *macro expansion*, *template instantiation*, and *inlining* in compilers (a compact reference is replaced by its full spelled-out body); *unfolding* a recurrence, expanding a product, or writing a generating rule as its explicit sequence of terms in mathematics; and *elaborating* an abbreviation, ellipsis, or pronoun into its full referent in language. In every case the move is identical — take the thing that was made small by leaving structure implicit, and put the structure back so it can be read directly.

## Notes

**Provenance.** Produced by op-01 dualization, sub-flavors 1a/1c (inverse-transform dual), from the input prime `compression`, in the full op-01 sweep on 2026-07-03. Two independent routes proposed it in the sweep. Verified absent from the corpus via search_prime + slug check.

**For owner evaluation (keep/cut).** The case FOR: `compression` and expansion are a genuine transform/inverse pair, and inverse legs of important transforms are not always redundant with their forward legs — the expanded form has properties (direct addressability, no decode-on-access cost, exact-or-form-only recovery) that the compact form lacks, and those properties are what expansion names. If the corpus holds `compression` as a prime, the symmetry argument for holding its dual is real, and they complete a clean pair on the compactness/explicitness axis. The specific risks Kurt should weigh: (1) **Restatement risk (the big one).** Estimated similarity to `compression` is ~0.71 — high. The sharpest objection is that expansion is just *the inverse leg of compression* and adds no independent structure: compression already implies its own inverse, so naming expansion separately may double-count one transform pair. The counter is that the two poles carry *opposite* trades and opposite property profiles, exactly as `eager_evaluation`/`lazy_evaluation` do — but Kurt should decide whether that parallel holds or whether compression is more self-contained than the eager/lazy pair. (2) **Overlap with `redundancy` (explicitly flagged in the manifest).** Expansion *re-introduces redundancy*, so it can look like an instance or application of `redundancy` rather than a peer. The distinction to test: `redundancy` names the *property* (structure that could be removed without information loss); expansion names the *transform* that restores it. A property and the operation that produces it are different objects, but the screen must confirm the corpus's `redundancy` prime is scoped as the property, not the act. (3) **Lossy asymmetry.** Expansion cannot recover lossily-discarded information — it restores form, not content. This asymmetry is a genuine structural feature (and a reason it is not simply "compression backwards"), and it should be preserved in any keep decision as part of what makes expansion distinct. Genus candidate for a hold-instead: `inverse_function`/`invertibility` may be the better parent, with expansion as a named specialization.

**At incorporation.** Re-run the similarity check against `compression` (dual), `redundancy` (flagged overlap — confirm it is scoped as the property, not the operation), `decoding`, and any `inverse_function`/`invertibility` prime before drawing edges. If it survives the restatement and redundancy screens, draw the dual/sibling edge to `compression` and a subsumption edge up to the transform-inverse (invertibility) genus; if it fails the restatement screen, fold it into `compression` as the inverse-leg discussion rather than keeping a separate prime. Ensure the eventual Structural Signature carries the lossy-asymmetry point (restores form, not discarded content), since it is load-bearing for distinctness. Sync the one_liner to a v1 draft per CLAUDE.md before merge, and mirror it across v1/v2.
