From 8c76d9aebf94ba40c856fbd1437bca04e4d905a7 Mon Sep 17 00:00:00 2001 From: Nick Petalas Date: Thu, 22 Oct 2026 22:50:02 +0100 Subject: [PATCH] feat(research): prove the coupled-center information tradeoff --- research/center-output-compression/README.md | 178 ++++++++++++++++ .../center-output-compression/SOURCES.json | 30 +++ research/center-output-compression/TASK.json | 113 +++++++++++ .../center-output-compression/VERIFY.json | 34 ++++ research/center-output-compression/verify.py | 190 ++++++++++++++++++ 5 files changed, 545 insertions(+) create mode 100644 research/center-output-compression/README.md create mode 100644 research/center-output-compression/SOURCES.json create mode 100644 research/center-output-compression/TASK.json create mode 100644 research/center-output-compression/VERIFY.json create mode 100644 research/center-output-compression/verify.py diff --git a/research/center-output-compression/README.md b/research/center-output-compression/README.md new file mode 100644 index 0000000000..2a6cc03a29 --- /dev/null +++ b/research/center-output-compression/README.md @@ -0,0 +1,178 @@ +# Sharp information tradeoff for retained center outputs + +This scoped algebraic proof determines what remains recoverable when a caller +compresses the output of Cinna Davis's retained-center interface. Given all 632 +old output fields and only j independent scalar linear observations of its +eight center outputs, exactly **624+j independent linear functions of the +desired old endpoint** are recoverable, for 0 <= j <= 8. Recovering all 632 +requires eight observations. Arbitrary nonlinear decoding cannot improve this +threshold. These are dimensions of information, not native call prices. + +The contribution was produced by Nick Petalas. New work is Apache-2.0. + +## Interface and exact target-specific theorem + +Let F be any field. Let x in F^n and z in F^k be arbitrary independent inputs. +A is n by n, B is n by k, and R is k by n. The record matrix L has k columns +and the target matrix T has n columns; their row counts are unrestricted. +Assume the block map + + y = A x + B z, w = R x + z + +is invertible. Write S=A-BR, which is then invertible: a nonzero vector in +ker(S), together with z=-Rx, would give a nonzero kernel vector of the block +map. A caller sees all of y +and the linear record Lw. There is no other input-dependent state. L is fixed +independently of x and z. A target Tx is recoverable on every input, by an +arbitrary decoder, if and only if + + ker(L) is contained in ker(T S^-1 B). + +Equivalently, every row of C=T S^-1 B lies in the row space of L. Therefore the +least possible rank of a center record recovering Tx is exactly + + rank(T S^-1 B). + +This includes singular targets T and rank-deficient B. A basis of the rows of C +is an attaining record. The theorem does not assume that individual center +coordinates, rather than their linear combinations, must be retained. + +### Proof + +Substitute z=w-Rx. Then y=Sx+Bw, and hence + + Tx = T S^-1 y - Cw. + +If ker(L) is contained in ker(C), row-space duality supplies a matrix D with +C=DL. The displayed expression gives a linear decoder using y and Lw. + +Conversely choose v in ker(L) with Cv nonzero. Compare the zero input with + + delta x = -S^-1 Bv, delta z = v-R delta x. + +Their y and Lw observations agree, whereas their targets differ by -Cv. No +decoder, linear or nonlinear, can distinguish these inputs. This proves the +criterion. It also forces rank(L) >= rank(C). Choosing a row basis of C attains +that lower bound. This is a standard kernel argument applied to this boundary; +no priority is claimed for rank-nullity or block elimination themselves. + +## Sharp full-endpoint tradeoff + +Assume additionally that A is invertible and B has column rank k. For a fixed +record L of rank j, all possible differences in x between inputs with equal +observations form exactly + + U = S^-1 B ker(L). + +Since S^-1 B is injective, dim(U)=k-j. The recoverable linear functions of Ax +are exactly the annihilator of AU. That space has dimension n-k+j. Each of +its functions has the decoder just proved, so this is an equality for every +rank-j record L, rather than only a lower bound or an optimized choice of L. +It does not say that n-k+j particular coordinate entries can always be chosen. + +Over a finite field of order q, every observation fiber has exactly q^(k-j) +possible old endpoints. Thus arbitrary decoding does not distinguish two old +endpoints in the same fiber. The statement about independent linear functions +over an infinite field does not assert a bound on arbitrary nonlinear encodings. + +## Application and predecessor credit + +Cinna Davis's [PR #4694](https://github.com/CrocSwap/integer-mult-bounds/pull/4694), +head `2add42d1edf14a263abe90a3bcde67fc1ba30768`, supplies n=632, k=8, +A(X,Y,H)=(X,Y+X,H), invertibility of the whole interface, and rank(B)=8. +The merged [#4698 helper normalization](../center-helper-normal-form/README.md) +retains these properties and constructs eight explicit three-step chains. +Its [proof](../center-helper-normal-form/PROOF.md) states B's injectivity. +Those facts are cited premises, not reverified results of this package. +Their rational matrices give the specialization over Q and C. Their dyadic +native interface is not being specialized to characteristic two or three. + +The theorem gives the following complete rank table: + + retained center rank j: 0 1 2 3 4 5 6 7 8 + recoverable old rank: 624 625 626 627 628 629 630 631 632 + +The new result is this sharp observation-compression law and its +target-specific minimum. The predecessor's helper basis and conditional +two-call consumer are not new here. Chris R's +[PR #4839](https://github.com/CrocSwap/integer-mult-bounds/pull/4839) constructs +and prices a particular physical terminal. Our theorem concerns the amount of +linear center information required when all old endpoint functions are +demanded; it neither reprices nor excludes other terminal policies. + +Credit Cinna Davis #4694/#4698 and the #4440/#4441/#4447/#4470 lineage, +Cao Yifan #4610, Chris R #4839, zxv, Jacob Alan Sussman and the retained +native, scalar, E8, Clifford, precision and outer contributors. ywz65's +earlier center-observation-floor work supplies the information-boundary +perspective; its owner-routing model is a different theorem. +Ross Richardson's [#2480](https://github.com/CrocSwap/integer-mult-bounds/pull/2480) +proves a sharp retention threshold for another fixed QQ16 observation cut. +Ali Romman's [#4720](https://github.com/CrocSwap/integer-mult-bounds/pull/4720) +proves historical routed-query information and snapshot bounds. These are +credited precedents for kernel-based observation lower bounds. Neither counts +compression of the #4694 coupled endpoint studied here. + +## Evidence and reproduction + +The all-field claim is the written proof above. The self-contained verifier +uses two independent three-step chains at n=4,k=2. It enumerates every +zero-, one- and two-row record L over F2 and F3, including dependent rows. +For every L it enumerates every dirty input, checks every observation fiber, +constructs collisions, computes the recoverable row-space dimension and +checks target-specific recovery against literal zero fibers. It tests every +one-row target plus a full endpoint and a two-row target, and enumerates the +minimum record rank for each target. These small examples corroborate the +new theorem; they do not substitute for a native 640-column replay. + +From the worktree root: + +```sh +/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/research_package.py --package research/center-output-compression +/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -I -W error -O -B research/center-output-compression/verify.py +/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/check_research_commit.py --package research/center-output-compression --check-source-history +``` + +On another machine substitute its CPython 3.12 path. There are no external +runtime inputs or dependencies. SOURCES.json pins the cited merged proof as +historical provenance; the scientific verifier does not import or replay it. +Checks use explicit exceptions and remain active with -O. The verifier writes +only stdout. No receipt is handwritten or accepted as evidence. + +The card's historical first example was attempted and raised +`KeyError: 'complex_profile'` after the selected schema changed. The current +`scripts/research_selected_baseline.py` source-binding control passed. Neither +is an input to this algebraic theorem, and neither was repaired here. + +## Scope, obligations and expansion decision + +This is a scoped proof with finite corroboration, not a new supplier, kappa, +search failure, proof-kernel certificate or complete multiplication theorem. +The observation contract grants all old output fields and fixed scalar linear +center records. Additional input-dependent caller state, changed demanded +targets, nonlinear measurements, multiple calls or intermediate observations +can change the problem. The decoder is algebraic; endpoint chart conversions, +native reads, precision, routing, restoration, retained helper jobs and a +complete paid moment remain unknown. No information dimension is converted +into a recursive call count. The selected frontier is unchanged. + +Power-of-ten inspection: loops have fixed n<=6 and p in {2,3}; no recursion or +child processes occur. The finite census intentionally allocates Python tuples, +sets and dictionaries, bounded by 729 inputs and 729 fibers per record. +This is a managed-runtime allocation deviation, not a fixed-memory claim. +No additional tooling or native/formal replay is required for the written proof. +Independent human and formal proof-kernel review are unclaimed. + +Decision: stop at this information result. It does not justify another +construction round without a fully charged changed consumer. + +## Open next questions + +For one literal proposed consumer, compute C=T S^-1 B for its actual demanded +target T and find whether rank(C)<8. This can reduce the observation demand, +but the first step needs that consumer's explicit target matrix and costs. +Those are not supplied here. If all old outputs remain demanded, the sharp +threshold is settled under this observation contract. + +Separately, price one attaining row-basis record in the actual endpoint charts. +Start with its literal read and restoration word. Scalar rank alone supplies +no native cost bound; this is the blocker to applying the result to a moment. diff --git a/research/center-output-compression/SOURCES.json b/research/center-output-compression/SOURCES.json new file mode 100644 index 0000000000..35c480e9ba --- /dev/null +++ b/research/center-output-compression/SOURCES.json @@ -0,0 +1,30 @@ +{ + "schema_version": 1, + "base_commit": "624de9dc66858af0945e5f8a0942488d62280d43", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "c35482cd9035843b15a634cc8276a7e1e40e8395", + "sha256": "6fe0a099b89aa2aed796a13c3a21dafc63f3388ebf397464e44e0451893b9375" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "f126dd2e2dad2b669e75d1d0d0bd05c600725602", + "sha256": "f7a48bfa2659b88378282a8eee7d9fe52cdf505594124c4d1686b58510fffd72" + }, + { + "path": "research/center-helper-normal-form/README.md", + "usage": "provenance", + "git_blob": "a1ab98dd6c717243b60b78fbb60d5512f05d902c", + "sha256": "c02694140e99d68e4226ba3c334acf5326ac3977f53f7a123edc67c0a8545cd9" + }, + { + "path": "research/center-helper-normal-form/PROOF.md", + "usage": "provenance", + "git_blob": "f7af6ae6224a08df2ec581efc746e1c38fafb643", + "sha256": "c52ce9eb18ebeca54aa7bbd30560215f0ab87af547bf770da6c3f23e105579ec" + } + ] +} diff --git a/research/center-output-compression/TASK.json b/research/center-output-compression/TASK.json new file mode 100644 index 0000000000..34b0c17502 --- /dev/null +++ b/research/center-output-compression/TASK.json @@ -0,0 +1,113 @@ +{ + "schema_version": 1, + "task_id": "complex-new-helper-inventory", + "priority_revision": 7, + "base_commit": "624de9dc66858af0945e5f8a0942488d62280d43", + "original_card": { + "id": "complex-new-helper-inventory", + "question": "Can a new local cost interface change the deficit-to-recursive-cost ratio beyond current packing?", + "starting_points": [ + "docs/research/research-family-status.md", + "research/complex-local-word-ceiling/README.md", + "research/heterogeneous-owner-assembly/README.md", + "certificates/selected-result.json", + "research/selected-k8-unrestricted-ends/README.md" + ], + "methods": [ + "Propose a changed helper inventory and derive an optimistic exact moment.", + "Design a small completed instance and independently verify its endpoint and rank bill." + ], + "acceptance_gate": "A new physically realizable contract outside the frozen catalogue whose per-call profile, screened with ceiling.ceiling(), beats the selected word's packing ceiling; a lower cap does not establish identical circuitry or order attainable optima, and is insufficient to pass the stronger-budget target under this model. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "first_step": { + "command": [ + "python3", + "-B", + "research/complex-local-word-ceiling/verify.py" + ], + "expected": "PASS_COMPLEX_LOCAL_WORD_CEILING", + "inspect": "Read the selected word's per-call local profile, its packing ceiling and the lever table; run levers.py for the ideal budget of the lever you target.", + "scope": "Positive control and planning budget only; this is not a new construction or full cold replay." + }, + "first_experiment": "Before any synthesis, write the candidate per-call local profile (and centre charge / unpaid coordinates if changed) and screen it with ceiling.ceiling(); reject it if even the ideal ceiling does not beat the selected word's by your stated margin.", + "bottleneck_link": "Packing of the selected word is capped at +0.87% (ceiling model); only a lower local excess spend or a changed coverage law raises the cap.", + "allowed_variations": [ + "Narrow to one changed boundary or helper type with explicit counts.", + "If the coverage law, template or guard changes, derive an applicable fully charged replacement bound instead of applying the incumbent ceiling outside its scope." + ], + "scope_change_triggers": [ + "Mixing only providers already inside the pinned catalogue.", + "Only changing helper terminal subspaces and monotone frames within the fixed scalar word, entrances and cleanup contract already covered by #1995/#2013.", + "Continuing a partial cost improvement while leaving the same unpriced consumer, restoration or central-readout obligation unresolved; refresh the family expansion decision first. Local product-retiming evidence has a narrow scope and is not a ban on changed graphs or contracts." + ], + "overlap_terms": [ + "helper inventory", + "heterogeneous-owner", + "mutable leaver" + ] + }, + "scope_status": "changed", + "actual_scope": "Sharp all-field observation-compression theorem for an invertible coupled-center interface, with the 624+j specialization under the cited PR4694/4698 premises.", + "scope_change_reason": "The donor asks for original research rather than an audit. Replace helper synthesis and kappa optimization with a new scoped consumer-information tradeoff answering the predecessor consumer obligation. No physical moment is claimed.", + "bottleneck_link": "A caller cannot discard center information while demanding the complete old endpoint. The target-specific minimum rank(T (A-BR)^-1 B) identifies exactly which changed demands could need less information, before native cost synthesis.", + "budget_minutes": 60, + "stop_rule": "Stop at the first verified original sharp observation tradeoff. Do not extend into synthesis, predecessor replay, selected-frontier changes or kappa optimization.", + "outcome": "completed", + "evidence": "README.md contains the all-field proof and 624+j corollary; verify.py enumerates every 0..2-row center record and every dirty input of two three-step chains over F2 and F3, all one-row targets and two multirow targets, exact fibers and collision witnesses, and seven rejection controls.", + "author": "Nick Petalas", + "ai_assistance": "Independent human and formal proof-kernel review are unclaimed.", + "open_questions": [ + { + "question": "Can a literal consumer demand a target T with rank(T (A-BR)^-1 B)<8?", + "why_it_matters": "A smaller target can require fewer center observations than the full old endpoint.", + "first_step": "Supply one explicit consumer target matrix and compute the theorem's rank.", + "blocked_by": "No such changed demanded target or complete paid consumer is supplied." + }, + { + "question": "What is the actual native cost of an attaining row-basis record?", + "why_it_matters": "An information dimension is not a recursive call price.", + "first_step": "Emit a read/restoration word in the actual endpoint charts for one target.", + "blocked_by": "Physical chart conversions, precision, routing, restoration and the complete moment remain unpriced." + } + ], + "upstream_checkpoint": { + "commit": "624de9dc66858af0945e5f8a0942488d62280d43", + "priority_revision": 7, + "checked_at_utc": "2026-10-22T21:49:07Z" + }, + "predecessors": [ + { + "pr": 4694, + "head": "2add42d1edf14a263abe90a3bcde67fc1ba30768", + "use": "Cited endpoint and injective B, not replayed." + }, + { + "pr": 4698, + "head": "9079ab66ba9a1717df478a08eb957c20d84d3e61", + "use": "Merged helper normalization and explicit chain model." + }, + { + "pr": 4839, + "head": "cd6ce17acc1eedb9843c6c346b6aa4327673639b", + "use": "Related concrete terminal cost, not an input or recheck." + } + ], + "orientation": { + "selected_binding_control": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "historical_card_first_step": "attempted; KeyError: complex_profile; historical schema not repaired" + }, + "overlap": { + "open_prs_cached": 365, + "discussion_records_cached": 3817, + "complete_remote_pagination": true, + "latest_live_pr_and_claim_check_utc": "2026-10-22T21:49:30Z", + "terms": [ + "retained-center-extension", + "center output compression", + "624+j", + "n-k+j", + "T S^-1 B", + "center observation compression" + ], + "limitations": "Sparse local README/TASK coverage; all-main distinctive README grep separately performed. No arbitrary code-diff or unpublished-work coverage. Merged searches are term-scoped." + } +} diff --git a/research/center-output-compression/VERIFY.json b/research/center-output-compression/VERIFY.json new file mode 100644 index 0000000000..ac6c5deb01 --- /dev/null +++ b/research/center-output-compression/VERIFY.json @@ -0,0 +1,34 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-W", + "error", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Complete F2/F3 record/input/target census, exact ambiguity fibers, sharp minimum ranks and seven rejection controls." + }, + { + "argv": [ + "{python}", + "-I", + "-W", + "error", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Same scientific checks with Python assertions disabled." + } + ] +} diff --git a/research/center-output-compression/verify.py b/research/center-output-compression/verify.py new file mode 100644 index 0000000000..6a1bb94f5a --- /dev/null +++ b/research/center-output-compression/verify.py @@ -0,0 +1,190 @@ +#!/usr/bin/env python3 +"""Exact finite evidence for the coupled-center observation theorem. + +Produced by Nick Petalas. Apache-2.0. Standard library only. +The all-field proof is in README.md; this does not replay a native supplier. +""" + +from collections import Counter +from itertools import product +import json + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def rank(rows, width, p): + require(p in (2, 3), "unsupported field") + require(0 <= width <= 6 and len(rows) <= 12, "matrix capacity") + require(all(len(row) == width for row in rows), "matrix shape") + work = [[v % p for v in row] for row in rows] + pivot = 0 + for col in range(width): + candidates = [i for i in range(pivot, len(work)) if work[i][col]] + if not candidates: + continue + index = candidates[0] + work[pivot], work[index] = work[index], work[pivot] + inv = pow(work[pivot][col], -1, p) + work[pivot] = [(v * inv) % p for v in work[pivot]] + for i in range(len(work)): + if i != pivot: + coefficient = work[i][col] + work[i] = [(a - coefficient * b) % p + for a, b in zip(work[i], work[pivot])] + pivot += 1 + if pivot == len(work): + break + return pivot + + +def dot(row, vector, p): + require(len(row) == len(vector) <= 6, "dot shape") + return sum(a * b for a, b in zip(row, vector)) % p + + +def action(rows, vector, p): + return tuple(dot(row, vector, p) for row in rows) + + +def observations(p): + """All matrices with two columns and zero, one or two rows.""" + vectors = tuple(product(range(p), repeat=2)) + for height in range(3): + yield from product(vectors, repeat=height) + + +def endpoint(vector, p): + """Two three-step chains: A=I, B=(I,0)^T, R=(0,I).""" + a, b, c, d, u, v = vector + return ((a + u) % p, (b + v) % p, c, d, + (c + u) % p, (d + v) % p) + + +def schur_inverse_output(y, p): + # S=I-BR, so S^-1=I+BR. This works in characteristic two as well. + a, b, c, d = y + return ((a + c) % p, (b + d) % p, c, d) + + +def target_noise(target, p): + # S^-1 B=B in this model, so C=T S^-1 B consists of T's first columns. + return tuple(tuple(v % p for v in row[:2]) for row in target) + + +def check_target_records(targets, label, zero_fiber, minimum, p): + j = rank(label, 2, p) + for index, target in enumerate(targets): + noise = target_noise(target, p) + predicted = rank(label + noise, 2, p) == j + literal = all(not any(action(target, x, p)) for x in zero_fiber) + require(predicted == literal, "target-specific recovery criterion") + if literal: + minimum[index] = min(minimum[index], j) + + +def check_fibers(label, inputs, p): + fibers = {} + zero_fiber = [] + for vector in inputs: + result = endpoint(vector, p) + seen = result[:4] + action(label, result[4:], p) + fibers.setdefault(seen, set()).add(vector[:4]) + if not any(seen): + zero_fiber.append(vector[:4]) + recovered = schur_inverse_output(result[:4], p) + recovered = tuple((v - result[4 + i]) % p if i < 2 else v + for i, v in enumerate(recovered)) + require(recovered == vector[:4], "full center decoder") + j = rank(label, 2, p) + require(len(fibers) == p ** (4 + j), "observation image size") + require(all(len(xs) == p ** (2 - j) for xs in fibers.values()), + "sharp ambiguity in every observation fiber") + require(len(zero_fiber) == p ** (2 - j), "zero fiber size") + return len(fibers), zero_fiber + + +def recoverable_dimension(label, p): + identity = tuple(tuple(int(i == j) for j in range(6)) for i in range(6)) + columns = tuple(endpoint(row, p) for row in identity) + m_rows = tuple(zip(*columns)) + observed = m_rows[:4] + tuple( + tuple(sum(row[i] * m_rows[4 + i][col] for i in range(2)) % p + for col in range(6)) for row in label) + old_rows = identity[:4] + return 4 + rank(observed, 6, p) - rank(observed + old_rows, 6, p) + + +def census(p): + targets = [(row,) for row in product(range(p), repeat=4)] + identity = tuple(tuple(int(i == j) for j in range(4)) for i in range(4)) + targets.extend((identity, identity[:2])) + minimum = [3] * len(targets) + inputs = tuple(product(range(p), repeat=6)) + counts = Counter() + strata = Counter() + for label in observations(p): + j = rank(label, 2, p) + fibers, zero_fiber = check_fibers(label, inputs, p) + check_target_records(targets, label, zero_fiber, minimum, p) + require(recoverable_dimension(label, p) == 2 + j, + "recoverable old-output dimension") + strata[j] += 1 + counts["observation_matrices"] += 1 + counts["input_executions"] += len(inputs) + counts["fibers"] += fibers + counts["collision_witnesses"] += len(zero_fiber) - 1 + counts["target_tests"] += len(targets) + for target, best in zip(targets, minimum): + require(best == rank(target_noise(target, p), 2, p), + "minimum center observations for target") + counts["targets"] = len(targets) + return {"field": p, **dict(counts), "rank_strata": dict(sorted(strata.items()))} + + +def rejection_controls(): + controls = 0 + zero = (0,) * 6 + collision = (1, 0, 0, 0, 1, 0) + require(endpoint(zero, 2)[:4] == endpoint(collision, 2)[:4], "collision") + require(zero[:4] != collision[:4], "old output changes") + false_claims = ( + (recoverable_dimension((), 2) == 4, "no-record full recovery"), + (recoverable_dimension(((1, 0),), 2) == 4, "one-record full recovery"), + (rank(((1, 0), (1, 0)), 2, 2) == 2, "duplicate record rank"), + (endpoint(collision, 2)[4:] == (0, 0), "discard dirty center outputs"), + (target_noise(((0, 0, 1, 0),), 2) == ((1, 0),), + "every target needs all centers"), + ) + for claim, message in false_claims: + try: + require(claim, message) + except ValueError: + controls += 1 + else: + raise ValueError("accepted false claim: " + message) + for rows, width, p in ((((1, 0),), 3, 2), (((1,),), 1, 5)): + try: + rank(rows, width, p) + except ValueError: + controls += 1 + else: + raise ValueError("accepted malformed matrix or unsupported field") + return controls + + +def main(): + result = {"claim_type": "scoped proof with finite corroboration", + "censuses": [census(p) for p in (2, 3)], + "rejection_controls": rejection_controls(), + "application": {"old_dimension": 632, "center_dimension": 8, + "recoverable_by_observation_rank": + {str(j): 624 + j for j in range(9)}}} + print(json.dumps(result, sort_keys=True)) + print("PASS_CENTER_OUTPUT_COMPRESSION") + + +if __name__ == "__main__": + main()