Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
164 changes: 164 additions & 0 deletions research/private-gaussian-header-cut/PROOF.md
Original file line number Diff line number Diff line change
@@ -0,0 +1,164 @@
# A private header is charged on the joint transcript cut

This contribution was produced by Nick Petalas. Apache-2.0.

Claim type: scoped written proof. The finite replay corroborates new private
protocols and boundary failures. It does not re-establish the cited geometry.

## Contract

Use the sixty Gaussian E8 ports and pairing price c(R,S) of ywz65's PR2641.
Port t supplies an independent uniform b_t-bit string X_t. Its receiver must
recover X_t on every input and initially knows only orthogonal-port inputs.
Source encoders and demand receivers are distinct roles. Source access and
encoding are free in this abstract message model. Bit delivery pays the
declared pairing rank. Put B=sum_t b_t.

Fix nonempty source and reader sets A,R. A deterministic header M=h(X_A)
has a finite prefix-free binary code. Deliver it only to receivers in R,
at price c(R,A) per bit. Put L=E[length(M)]. No other receiver observes its
value, length, presence, timing or routing. The protocol has these two parts:

1. A fixed finite ordered payload list, with source sets, reader sets,
functions and finite prefix-free codebooks independent of M.
2. For each M=m, a finite ordered private payload list. Every reader set
is contained in R. Each source set S_j(m) contains A. The encoder can
therefore compute h(X_A) from its declared original inputs and select
its branch without another uncharged delivery of M. It sends a function
f_j(m,X_S_j(m)) using a finite prefix-free codebook fixed by m.

The private list can change its length, order, supports and codebooks with m.
Its descriptions are fixed in advance as functions of m. Receivers in R know
m and the corresponding schedule. Receivers outside R observe only their
fixed-list payloads. Every additional input-dependent signal is excluded,
including an observable absence of a private message outside R. Payloads do
not relay earlier payloads. Arbitrary nonlinear encoding and decoding are
allowed. Fixed and private payloads pay c(R_j,S_j) per delivered bit.

The requirement S_j(m) contains A is sufficient, rather than asserted
necessary. It is deliberately explicit about encoder knowledge. The theorem
does not cover an encoder secretly supplied M or private schedules visible
at an additional reader. Prefix-free codes charge termination information.

## Theorem

Let Q range over the 640 retained nonorthogonal cliques, each of weight
1/192. Define

eta(A,R) = sum_Q [Q meets A and Q meets R]/192.

Under the contract above, with total charge C,

E[C] >= (2/3) B + c(R,A) L - eta(A,R) H(M)
>= (2/3) B + (c(R,A)-eta(A,R)) L
>= (2/3) B. (1)

Thus the expected and worst-case Gaussian charge for equal b-bit demands
remains at least 40b in this private-reader model. This is not a pointwise
bound and does not establish a positive private-header surcharge.

The cited geometric premises are incidence 128 at every port, and

sum_Q [Q meets T and Q meets S]/192 <= c(T,S). (G)

These are Sagar Thakrar's PR738 results retained in PR2641. They are premises
here, not fresh enumerations or independently verified geometric claims.

## Joint-cut simulation lemma

Fix a clique Q and fix X outside Q. Orthogonal side information of a receiver
in Q lies outside Q. For each payload retain its codeword exactly when both
its source and reader sets meet Q. Include M in the retained transcript only
if both A and R meet Q. There are three cases.

If Q misses R, no receiver in Q observes the header or private list. Its
fixed-list messages omitted from the retained transcript have sources
outside Q, so the fixed outside inputs determine them. The retained fixed
transcript consequently determines all receiver observations in Q.

If Q meets R but misses A, the fixed outside inputs determine M. They also
determine the entire private schedule. Every omitted message received by Q
has its source outside Q, so it is computable from those inputs and M.
Again the retained transcript determines all receiver observations in Q.

If Q meets both A and R, retain M first. It specifies the private schedule.
Every omitted payload received by Q is computable from M and the fixed
outside inputs. The receiver observations in Q can therefore be simulated.
Receivers outside R are simulated using their fixed list only; the argument
does not silently deliver M to them in the actual protocol.

In every case equal retained transcripts imply equal demanded X_Q, by exact
decoding. No conditional independence after observing M was used.

## Entropy accounting

Let P be total payload charge and write B_Q=sum_(t in Q) b_t. The simulation
lemma, entropy subadditivity and the prefix-code bound give

B_Q <= [Q meets A and Q meets R] H(M | X_outside_Q)
+ E[sum_j length(Y_j) [Q meets R_j and Q meets S_j]]. (2)

For the case missing R there is no branch-dependent received list. In the
other cases condition on M before applying subadditivity to the finite list.
Each conditional distribution uses a subset of its specified prefix-free
codebook, so its entropy is at most expected codeword length. Varying list
length is known from M only to R; the simulation cases justify this use.
The same argument applies to the fixed list, whose distribution can be
conditioned on M when M is retained or already determined by outside inputs.

Multiply (2) by 1/192 and sum Q. The left side is (2/3)B. Bound each header
entropy by H(M), and apply (G) to every realized payload support pair. This
gives (2/3)B <= eta(A,R) H(M)+E[P]. Adding c(R,A)L proves the first inequality
in (1). Kraft's inequality gives H(M)<=L, and (G) for the header gives
eta(A,R)<=c(R,A), proving the rest. Finite alphabets justify every sum.

## Why a strict surcharge is not obtained

The retained PR738 certificate already gives source F=(0,1,2,11,12,45) and
reader G=(0,3,4,5,6,7,8,9,10,54,55,56,57,58,59) with pairing rank one and
192 joint clique hits. Thus c(G,F)=eta(F,G)=1, a cited datum.

Give the six ports of F independent bits and use their parity as M. For
each clique meeting F, this parity has conditional entropy one after fixing
outside-Q inputs. Consequently the joint-cut header term is exactly
eta(F,G)H(M)=1. The comparison c-eta can have zero gap. This proves sharpness
of that entropy comparison, not attainment of a complete 40b communication
code or impossibility of stronger private-header lower bounds.

The replay implements parity, a nonlinear Boolean header and a variable
prefix header on these six active inputs. Only active recipients at lines
0 and 45 learn M. Remaining active demands receive their fixed direct bit.
Private payload sources declare F, including any additional demanded source;
their singleton reader price is one. Header price one is the cited pair's
price. These are exact small protocols, not a claimed optimal code.

## Failure boundaries

An outsider can learn a hidden bit from the presence or absence of a
zero-bit message. Its payload bit charge is zero, but its schedule observation
has two values. This violates the private-list recipient rule. The replay
keeps this literal leak, and rejects a branch-dependent message outside R,
an encoder without A, a changing fixed schedule, non-prefix codebooks and
an actual missing-demand message.

Removing these premises is a different communication model. No physical
primitive, native source, restored helper, stock/precision/tape bill, supplier
admission, selected-frontier change or multiplication theorem follows from
(1). All five selected framework assumptions remain.

## Sources and credit

ywz65 PR2641 supplies the public-header theorem, conditional transcript
argument and open localized/private-header question. Sagar Thakrar PR738
supplies the Gaussian geometry, joint support inequality and cited sharp
support pair. ToikY PR888, Alexander Templeton PR785, Michael Fischler PR814
and Jerry Chen PR912 retain the transcript and paid-header lineage, alongside
Joel Pulikkan, Douglas Colkitt and DreamingOfClouds.

Nick Petalas PR4897 studies localized sources with public readers and proves
a strict surcharge in that different contract. Its theorem, construction
and flat-census transformation are not used here. The new step is the
private schedule simulation and the joint A,R cut, derived directly from
the source observation contract. Entropy and prefix coding are classical;
global literature priority is unclaimed. Independent human and formal
proof-kernel review are unclaimed.
134 changes: 134 additions & 0 deletions research/private-gaussian-header-cut/README.md
Original file line number Diff line number Diff line change
@@ -0,0 +1,134 @@
# Gaussian private routing retains the nonlinear copy floor

This contribution was produced by Nick Petalas. Apache-2.0.

Claim type: scoped written proof with exact finite corroboration. No new kappa.

A localized header can remain private while preserving the Gaussian nonlinear
copy floor, provided its adaptive payloads stay inside its reader set and their
encoders can compute the header from their declared original inputs. This
answers a restricted private-reader part of ywz65's
[PR2641](https://github.com/CrocSwap/integer-mult-bounds/pull/2641) open question.
The new result is the private schedule simulation and joint source/reader cut.
The predecessor's geometry and public-header theorem are cited, not audited.

For M=h(X_A), delivered only to R, let c=c(R,A) be its pairing price,
L its expected prefix-code length and eta the retained weighted-clique
incidence meeting both A and R. With total independent uniform demand B,

```text
E[total charge] >= (2/3)B + cL - eta H(M)
>= (2/3)B + (c-eta)L
>= (2/3)B.
```

Equal b-bit demands retain expected and worst-case charge at least 40b.
[PROOF.md](PROOF.md) gives the full contract and proof. Every header-dependent
payload has readers inside R and declared sources containing A. Its encoder
computes the header locally. Outside R, both payload schedule and encoding
remain independent of the header. All additional routing, timing and absence
signals are excluded. Payloads may be nonlinear and prefix-coded, and their
number, order and supports may change within the private reader region.

The cited Gaussian support inequality gives eta<=c. The source certificate
already supplies a rank-one pair with eta=c=1. A parity header on its six
source bits attains the joint conditional-entropy term. Thus this argument
establishes no positive private-header surcharge. It does not produce an
attaining complete 40b code or rule out a stronger lower bound.

## Evidence and reproduction

From the repository root, CPython 3.12 and its standard library:

```sh
/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -I -W error -B research/private-gaussian-header-cut/verify.py
/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -I -O -W error -B research/private-gaussian-header-cut/verify.py
/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/research_package.py --package research/private-gaussian-header-cut
/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/check_research_commit.py --package research/private-gaussian-header-cut --check-source-history
```

Another CPython 3.12 executable may replace the displayed local path. Direct
replay prints `PASS_PRIVATE_GAUSSIAN_HEADER_CUT` in a generated JSON receipt
bound to all six package files by SHA256. It writes nothing into the checkout.
The registered runner additionally prints `PASS_REGISTERED_RESEARCH_PACKAGE`.

The new finite checks cover:

- All 316 choices of nonempty declared source support and Boolean header table
on three bits, crossed with all seven nonempty private-reader sets. The
2,212 resulting protocols pass 53,088 literal receiver checks and 15,484
exact cut inequalities, comprising 11,332 joint cuts and 4,152 other cuts.
Receivers have no side information in this generic finite model. The check
uses integer products of conditional fiber sizes, with no floating entropy.
- Three private protocols on six active Gaussian source ports. Their headers
are parity, a nonlinear Boolean function and a ternary prefix code. Only
two active recipients see the header. All 64 inputs per protocol pass
384 receiver checks and 63 cut checks. Their exact charges are 7, 7 and
29/4. The Gaussian support-pair price is a cited premise; this is not a
geometry census or an optimality claim for these codes.
- Seven rejected mutations: three invalid prefix codes, an adaptive payload
escaping R, an encoder lacking A, a branch-dependent fixed schedule and
an actual missing-demand payload. A separate two-input witness shows an
outsider learning one bit from the presence of an empty message despite
zero payload bits. It explains the visibility boundary.

These finite protocols corroborate the new simulation lemma. The quantified
statement rests on the written proof and retained geometric premises.
No predecessor executable, scientific replay or flat-pair census runs.

## Scope and credit

Base canonical main is `e54523517d0f03e58352e647c403a5af3e525a57`, priority
revision 8, selected #7000 unchanged. The `complex-new-helper-inventory` card
is explicitly changed to this observation-interface side obstruction. Its
binding-only selected baseline passed. [Advance claim](https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19592129).
[SOURCES.json](SOURCES.json) records immutable provenance. None is a live
scientific input to the standalone verifier.

Credit ywz65 #2641 for the public-header proof and localized/private-header
question; Sagar Thakrar #738 for the Gaussian geometry, weighted support
inequality and rank-one pair; ToikY #888, Alexander Templeton #785, Michael
Fischler #814 and Jerry Chen #912 for the transcript and paid-header lineage.
Joel Pulikkan, Douglas Colkitt and DreamingOfClouds retain their prior credit.
Nick Petalas #4897 concerns public readers and a strict localized-source
surcharge. Its theorem and construction are background, not steps in this
private-schedule proof. Entropy and prefix coding are classical. Global
literature priority is unclaimed.

The result excludes arbitrary private encoder knowledge, schedule leakage,
interactive relays, correlated demands and changed physical bit prices.
No strict surcharge, complete Gaussian communication optimum, physical
supplier, helper restoration, native/tape/precision/stock bill or selected
multiplication theorem is supplied. No selected cold replay, Lean or Docker
run is claimed. All five selected framework assumptions remain. Independent
human and formal proof-kernel review are unclaimed.

The family decision is narrow and finish. A new observer interface is now
bounded, but no new construction campaign follows from a favorable local code.

## Open next questions

1. Can the sufficient A-subset-S encoder condition be replaced by an explicit
factorization h(X_A)=g(X_S)? First specify each branch's actual knowledge
and routing. This could reduce declared source prices, but the full
simulation contract remains to be proved.
2. Can private routing attain 40b, or must a stronger argument impose a
surcharge? First produce a complete code on the cited F,G pair. The parity
witness here attains only the entropy comparison, not a full copy optimum.

## Engineering constraints

The verifier has no scientific imports, recursion, subprocesses, network or
external runtime inputs. Loops range over the fixed corpus, at most six
bits, 64 assignments, 63 cuts and three payload targets in the exhaustive
corpus. Functions stay below 60 physical lines. Explicit checks remain active
under optimized Python. Warning-strict execution and in-memory compilation
are the applicable diagnostics; no external static analyzer is claimed.

Power of Ten rule 3 requires a managed-runtime deviation: Python allocates
integers, tuples, counters and JSON while running. Live scientific collections
are bounded by the fixed six-bit domain, and exact entropy products have at
most 64 fiber factors of size at most 64. There is no growing cache or shared
mutable resource. If a future public API enlarges this domain, it must retain
explicit input, collection and arithmetic-size limits. Files are read only
for the generated source-hash receipt, with a per-file size cap.
36 changes: 36 additions & 0 deletions research/private-gaussian-header-cut/SOURCES.json
Original file line number Diff line number Diff line change
@@ -0,0 +1,36 @@
{
"schema_version": 1,
"base_commit": "e54523517d0f03e58352e647c403a5af3e525a57",
"files": [
{
"path": "certificates/selected-result.json",
"usage": "provenance",
"git_blob": "75d77b328ea02ded535e7f23aee5b1e55d0bb1a8",
"sha256": "154c3d30455d778fd3343b6b4851f0fa4665f0f7625b0adb3675e2bafbbf6bf1"
},
{
"path": "docs/research/agent-task-catalog.json",
"usage": "provenance",
"git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec",
"sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81"
},
{
"path": "research/gaussian-adaptive-header-tax/PROOF.md",
"usage": "provenance",
"git_blob": "317d8324c2e89e1073238b21f3801c723de00ee4",
"sha256": "af3c143c50a4290033ff5f585c58ddf205ce7c15a2faf1998c73282aed56ea34"
},
{
"path": "research/gaussian-adaptive-header-tax/README.md",
"usage": "provenance",
"git_blob": "4236d999ff30ef0a8e3eb2132e702b6b27904288",
"sha256": "f996f1cd8a06fe5d7189d4dd131deb0b8193e5dab42e9eea67b320ff579cc670"
},
{
"path": "research/gaussian-clique-copy-bound/certificate.json",
"usage": "provenance",
"git_blob": "cacb07d8e71177175c0702e5f455cc986dce5d42",
"sha256": "c50858aaab863b34c7533211ca07ae038ee000328bd5134b73219992ae078875"
}
]
}
Loading
Loading