From e7bf247ed11f2b2fb168e3d221e71b824636b102 Mon Sep 17 00:00:00 2001 From: Cinna Davis Date: Sun, 18 Oct 2026 21:36:52 -0500 Subject: [PATCH] Add physical Gaussian row norm transfer audit --- .../PROOF.md | 101 +++++++ .../README.md | 52 ++++ .../SOURCES.json | 18 ++ .../SOURCES.md | 16 ++ .../TASK.json | 54 ++++ .../VERIFY.json | 20 ++ .../inputs/PR3878-PROOF.md | 262 ++++++++++++++++++ .../verify.py | 46 +++ 8 files changed, 569 insertions(+) create mode 100644 research/physical-gaussian-row-norm-transfer/PROOF.md create mode 100644 research/physical-gaussian-row-norm-transfer/README.md create mode 100644 research/physical-gaussian-row-norm-transfer/SOURCES.json create mode 100644 research/physical-gaussian-row-norm-transfer/SOURCES.md create mode 100644 research/physical-gaussian-row-norm-transfer/TASK.json create mode 100644 research/physical-gaussian-row-norm-transfer/VERIFY.json create mode 100644 research/physical-gaussian-row-norm-transfer/inputs/PR3878-PROOF.md create mode 100644 research/physical-gaussian-row-norm-transfer/verify.py diff --git a/research/physical-gaussian-row-norm-transfer/PROOF.md b/research/physical-gaussian-row-norm-transfer/PROOF.md new file mode 100644 index 0000000000..39e4040284 --- /dev/null +++ b/research/physical-gaussian-row-norm-transfer/PROOF.md @@ -0,0 +1,101 @@ +# All-center contraction and unit-ball preservation for PR #3878 + +## Quantified interface + +PR #3878, exact head `1a86a8fb73bb7a0982fff99852a031832c191902`, states the +physical tile contract for integer `p > 100`, integer +`2 <= alpha < sqrt(p)`, `u = alpha^2`, `1 < t/s < 2`, and its production-halo +hypotheses. Its exact normalized map is + +```text +(A x)_v = (1/(2 alpha)) sum_(j in Z) + exp(-pi (j - c_v)^2/alpha^2) x_j, +c_v = (s/t)v. +``` + +The `x_j` are periodic source labels and may be any complex values with +`||x||_infinity <= 1`. PR #3878 proves a uniform per-output error + +```text +||T(x) - A(x)||_infinity < C 2^-p, +C = sqrt(2) + 2^-11. +``` + +This note independently proves the exact all-center row bound + +```text +for every real c and every alpha >= 2: + sum_(j in Z) exp(-pi (j-c)^2/alpha^2) <= 1 + alpha, + ||A||_(infinity -> infinity) <= 1/2 + 1/(2 alpha) <= 3/4. +``` + +It then derives the local domain-preservation implication. For every `p >= 3` +and every unit-ball tile input, + +```text +||T(x)||_infinity <= ||A(x)||_infinity + C 2^-p + < 3/4 + 1/4 = 1. +``` + +Thus PR #3878's stated `p > 100` is more than enough for the output of one +tile to satisfy the next tile's unit-ball numerical domain, if the caller +passes the values directly on a compatible grid. This is a local implication +only; it does not prove a full tensor schedule or any inter-axis precision +conversion. + +## Proof of the row bound + +Fix `c` and `alpha >= 2`, and put +`f(z)=exp(-pi (z-c)^2/alpha^2)`. Its values lie in `[0,1]`, and every strict +level set `{z : f(z) > h}`, `0 < h < 1`, is an interval. Any interval of +length `ell` contains at most `ell+1` integers. The layer-cake identity gives + +```text +sum_(j in Z) f(j) + = integral_(h=0..1) #({j in Z : f(j)>h}) dh + <= integral_(h=0..1) (length({z : f(z)>h}) + 1) dh + = integral_R f(z) dz + 1 + = alpha + 1. +``` + +The bound is uniform in the center `c`; no alignment of `(s/t)v` with the +source lattice is needed. With periodic labels, multiple terms can name the +same source coordinate, but all Gaussian weights are nonnegative. For any +input with `||x||_infinity <= 1`, the absolute output is at most the sum of +all those weights. Therefore the induced sup-norm bound for the periodic map +is the same row-sum bound. Dividing by `2 alpha` yields + +```text +||A||_(infinity -> infinity) <= (alpha+1)/(2 alpha) + = 1/2 + 1/(2 alpha) <= 3/4. +``` + +For the error constant, `sqrt(2) < 10/7`, so +`C < 10/7 + 1/2048 < 3/2`. If `p >= 3`, then +`C 2^-p < (3/2)/8 = 3/16 < 1/4`. Combining this with the row bound proves +`||T(x)||_infinity < 1` for every unit-ball input. The deduction uses only +PR #3878's pointwise error premise and the exact row bound; it does not use +the implementation's separate output-norm assertion. + +## Boundary controls and scope + +The bound `alpha >= 2` makes the sufficient contraction estimate at most +`3/4`. At `alpha=1` the same estimate gives only `1`, so this proof route does +not establish a `3/4` contraction. This is a limitation of the estimate, not +a counterexample to the actual Gaussian row sum at `alpha=1`. + +The error precision guard in the domain-preservation deduction also matters. +At `p=2`, the source constant obeys `C/4 > 1/4`; the abstract maps +`A(z)=3z/4` and `T(z)=3z/4+1/4` have error at most `C/4` on the unit disk but +`T(1)=1`. Thus a `<1` output bound does not follow from the row and error +bounds at that precision. For `p>=3`, the exact rational upper bound above +does imply it. + +The live handoff at discussion #1166 comment `19010279` claims the larger +physical Gaussian tensor join. This result stops at the local all-center norm +and domain-preservation implication. It does not prove tensor-error +recurrences, tile routing, disjoint output coverage, coordinate moves, +precision conversion, tape/hosting costs, chirp composition, CRT or integer +recovery. PR #3877 already states a separate all-dimension recurrence for its +positive coefficient-rounded operator; that recurrence is outside this +audit. diff --git a/research/physical-gaussian-row-norm-transfer/README.md b/research/physical-gaussian-row-norm-transfer/README.md new file mode 100644 index 0000000000..23fbbae102 --- /dev/null +++ b/research/physical-gaussian-row-norm-transfer/README.md @@ -0,0 +1,52 @@ +# Physical Gaussian row-norm transfer + +**Status: independently proved the all-center local contraction and its +unit-ball consequence; no tensor theorem claimed.** + +## Question and result + +At the exact normalized Gaussian interface used by PR #3878, does the row-sum +bound hold uniformly over every center and periodic source labeling, and does +the local tile error then keep its output inside the next tile's unit-ball +domain? Yes. For every real center `c` and `alpha >= 2`, + +```text +sum_j exp(-pi (j-c)^2/alpha^2) <= 1 + alpha, +||S/2||_(infinity -> infinity) <= 1/2 + 1/(2 alpha) <= 3/4. +``` + +With PR #3878's per-output error `C 2^-p`, `C=sqrt(2)+2^-11`, this alone +implies `||tile(x)||_infinity < 1` for every unit-ball input whenever `p>=3`. +The cited PR uses `p>100`, so its local precision is sufficient. The +all-center proof and exact guards are in [PROOF.md](PROOF.md). + +The result is a local independent check of a premise in PR #3878. It does not +replay the tile implementation or establish that a full caller applies the +tile to every source interval. The live handoff at #1166 comment `19010279` +claims the larger tensor join; this pass deliberately stops at the local +row-norm/domain implication and does not prove its error recurrence. + +## Reproduce + +From the repository root: + +```sh +python3 -B research/physical-gaussian-row-norm-transfer/verify.py +``` + +The verifier checks exact rational endpoint constants and the retained PR +proof snapshot hash. The all-center result follows from the layer-cake proof +in `PROOF.md`, not a finite Gaussian sum search. See +[SOURCES.md](SOURCES.md) for source heads and digests. + +## Open next questions + +The active full tensor-join handoff at discussion #1166 comment `19010279` +owns the next larger question. No distinct local follow-up is justified until +that caller is published; its per-axis source and grid contracts can then be +checked against this lemma. + +Credit: Jose Manuel (`jmbarrancoml`), PR #3878, for the physical tile and local +error theorem. The row-sum proof and exact precision implication here are +separate work by OpenAI Codex (`macbook-11`). No independent human or formal +kernel review is claimed. diff --git a/research/physical-gaussian-row-norm-transfer/SOURCES.json b/research/physical-gaussian-row-norm-transfer/SOURCES.json new file mode 100644 index 0000000000..0839f4876a --- /dev/null +++ b/research/physical-gaussian-row-norm-transfer/SOURCES.json @@ -0,0 +1,18 @@ +{ + "schema_version": 1, + "base_commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81", + "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "67f085acd86acd7d4e03922d9cf4b26bca66fed5", + "sha256": "47b42433f5a85809a3aadd29c2c339da2c6ed728e4f7762df6b88bccb7874cf0" + } + ] +} diff --git a/research/physical-gaussian-row-norm-transfer/SOURCES.md b/research/physical-gaussian-row-norm-transfer/SOURCES.md new file mode 100644 index 0000000000..dc5de107c1 --- /dev/null +++ b/research/physical-gaussian-row-norm-transfer/SOURCES.md @@ -0,0 +1,16 @@ +# Source records + +Base repository and task-card provenance are in `SOURCES.json`. + +| Source | Exact commit | File | SHA256 | +|---|---|---|---| +| [PR #3878: physical Gaussian expansion tile](https://github.com/CrocSwap/integer-mult-bounds/pull/3878) | `1a86a8fb73bb7a0982fff99852a031832c191902` | `research/physical-gaussian-expansion/PROOF.md` | `5452f3e2191824b4a8451c83fbdf58b3b2228f4e1966a6f22c3e60bd152e56b0` | + +The exact PR #3878 proof bytes are retained in `inputs/`; the local verifier +checks their hash. Its local tile error estimate is used as a conditional +premise. This package does not independently replay the source construction +or certify its analytic error estimate. PR #3877, head +`5e7bdfa3c53bbb5a8d6e81f0efe7005c89184e6a`, was read as live overlap: its +Theorem 2 already gives an all-dimension recurrence for a different +coefficient-rounded operator. That recurrence and the active full tensor join +are explicitly outside this package's result. diff --git a/research/physical-gaussian-row-norm-transfer/TASK.json b/research/physical-gaussian-row-norm-transfer/TASK.json new file mode 100644 index 0000000000..cd93b18de9 --- /dev/null +++ b/research/physical-gaussian-row-norm-transfer/TASK.json @@ -0,0 +1,54 @@ +{ + "schema_version": 1, + "task_id": "uniform-transfer-audit", + "priority_revision": 6, + "base_commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "original_card": { + "id": "uniform-transfer-audit", + "question": "Can one exact all-size/compiler, precision, hosting or restoration implication be proved or falsified?", + "starting_points": [ + "certificates/selected-result.json", + "docs/audit.md" + ], + "methods": [ + "Prove one missing implication with explicit quantified hypotheses.", + "Find an exact counterexample at the claimed interface boundary." + ], + "acceptance_gate": "Identify the proposition and what would change downstream; do not equate a finite replay with a universal proof.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read the selected review scope and choose one exact all-size or precision implication.", + "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay." + }, + "first_experiment": "Write its quantified inputs and conclusion; find a missing hypothesis or construct a minimal exact adversarial instance.", + "bottleneck_link": "Finite supplier improvements are useful only under the retained transfer obligations.", + "allowed_variations": [ + "Choose one tape, precision, hosting or restoration lemma." + ], + "scope_change_triggers": [ + "Replacing a quantified obligation with another finite smoke test." + ], + "overlap_terms": [ + "uniform transfer", + "all-size", + "precision" + ] + }, + "scope_status": "refined", + "scope_change_reason": "After the required source-bound baseline and live overlap check, I selected PR #3878's normalized Gaussian tile boundary. A live #1166 handoff (comment 19010279) claims the full PR #3877/#3878 tensor join and its error recurrence, so I narrowed this pass to the independent local all-center row-norm and unit-ball-preservation implication.", + "actual_scope": "Prove that the exact normalized Gaussian row mass at PR #3878's tile boundary is at most 1+alpha for every real center and alpha>=2, then derive the exact p threshold at which the tile's local error implies unit-ball output preservation.", + "bottleneck_link": "The exact row contraction plus the tile's uniform local error gives the numerical domain guarantee needed before another tile may consume the output. The active full tensor caller remains a separate obligation.", + "budget_minutes": 60, + "stop_rule": "Stop after the all-center row bound and exact unit-ball implication are proved with their parameter guards. Do not implement a tensor caller, derive its error recurrence, or run the PR's full replay.", + "outcome": "completed", + "evidence": "PROOF.md independently proves the all-center Gaussian row-mass bound by layer cake, transfers it to the periodic sup-norm operator, and derives that the local error C*2^-p preserves the unit ball for p>=3. verify.py checks exact rational endpoint and precision constants and the pinned PR #3878 proof snapshot. PR #3878's local numerical theorem remains a conditional premise; its implementation was not replayed.", + "author": "OpenAI Codex (macbook-11)", + "ai_assistance": "This proof, verifier and prose were prepared by OpenAI Codex. No independent human or formal-kernel review is claimed.", + "open_questions": [], + "no_open_questions_reason": "The larger full tensor-join question is already claimed in live discussion #1166 comment 19010279. This pass has no separate continuation that avoids that scope." +} diff --git a/research/physical-gaussian-row-norm-transfer/VERIFY.json b/research/physical-gaussian-row-norm-transfer/VERIFY.json new file mode 100644 index 0000000000..dbbaf24442 --- /dev/null +++ b/research/physical-gaussian-row-norm-transfer/VERIFY.json @@ -0,0 +1,20 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/physical-gaussian-row-norm-transfer/inputs/PR3878-PROOF.md" + ], + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Checks the retained PR #3878 proof snapshot by SHA256; exact rational alpha=2 contraction endpoint, alpha=1 boundary of the sufficient estimate, C upper bound, p=3 minimum precision control, and p=2 counterexample to deriving strict output preservation from the error estimate. The all-center row bound is the layer-cake proof in PROOF.md, not a finite sum search." + } + ] +} diff --git a/research/physical-gaussian-row-norm-transfer/inputs/PR3878-PROOF.md b/research/physical-gaussian-row-norm-transfer/inputs/PR3878-PROOF.md new file mode 100644 index 0000000000..89642f4740 --- /dev/null +++ b/research/physical-gaussian-row-norm-transfer/inputs/PR3878-PROOF.md @@ -0,0 +1,262 @@ +# Complete physical Gaussian expansion tile + +Jose Manuel (`jmbarrancoml`), with substantial OpenAI Codex assistance. +I give a scoped implementation argument under the retained word, interval and +analytic source premises. The finite checks support the listed interfaces; +they do not establish a complete integer-multiplication theorem or independent +human review. + +## 1. Quantified boundary and sources + +I use the original global integers `s,t`, with `1100`, +integer `2<=alpha100`, `b²/u<5p/4`, `b=22`, `|h|<=2b+1`, `0<=z=2sigma+p+ceilLog2(32(n+1))+12`. The production values satisfy it with +room to spare. Thus internal complex error is below `2^(-p-12)`. + +Every omitted source index lies beyond distance `b` from the target center. +A monotone integral estimate bounds the two normalized tails by + +```text +(1/alpha + alpha/(2*pi*b))*exp(-pi*b²/u) + < exp(-pi*p) < 2^(-3p) < 2^(-p-12). +``` + +I charge final component truncations separately, with complex error below +`sqrt(2)*2^-p`. For the complete tile, use the maximum over its disjoint +target blocks, rather than summing over the number of blocks. The result is + +```text +||returned-Sx/2||_infinity + < (sqrt(2)+2^-11)*2^-p < p²*2^-p. +``` + +The shifted Gaussian sum is at most `1+alpha`, by its maximum plus its +integral. Hence the exact S/2 operator norm is at most +`1/2+1/(2alpha)<=3/4`. Before final truncation, the computed norm is below +`3/4+2^(-p-11)<1`; component truncation toward zero cannot increase it. +The consumer also checks its returned disk-grid values. + +Reduced-radius fixtures exercise the complete implementation and rounding +order. They do not satisfy this production tail proof. Their independent +reference reports bound the **maximum component error**, not complex modulus. + +## 4. Production halo and complete stream + +The production wrapper retains the paired compression domain: + +```text +A=4096p³, L=2^ceilLog2(p^8), t dyadic, +u>=ceilLog2(8p), u*d<=p, +1/(4d)<(t-s)/s<1/(2d-1), +w=ceil(sqrt(ceil(16p/u)))+2, d>4w+2, +L>=64dA, s>2(L+2A+2w). +``` + +For tile `k`, I use target core `[kL,(k+1)L)` and target halo +`[kL-A,(k+1)L+A)`. I invoke the retained `ProductionPlan` on that halo and +the source core `[floor(kappa*kL),floor(kappa*(k+1)L))`. For target endpoint +`v`, its source-window endpoint is + +```text +ceil(s*(2v-1)/(2t)), +``` + +because `q_j=floor(t*j/s+1/2)` belongs to an integer target interval exactly +between those two ceilings. I retain the principal complement, locality +margin and paired precision checks. Both positive and negative lifts use +this same endpoint convention. + +The entire expansion stencil is +`[floor(kappa*kL)-b-1, ceil(kappa*((k+1)L-1))+b+2)`. +Each side has clearance greater than `kappa*(A+1/2)-b-3>A/2-b-3>0` +inside the source halo. The ratio and `L>=64dA` bounds imply source count +at most L, including endpoint discrepancies. The implementation checks +that inequality and pads the supplied source halo to capacity L. + +For consecutive short blocks, their source left and right endpoints are +nondecreasing. Since `kappa<1` and each target step is at most b, the next +source window overlaps the previous one. The consumer validates the entire +capacity once, then scans it once in increasing order. It copies the first +window; for each next block it copies the retained suffix from one short +bank into the other and appends only newly reached source records. Equal +left endpoints and equal right endpoints are legal. It skips the remaining +source tail and padding once. It checks the complete ordered page catalogue, +common axis/precision, target positions and clipped final block. + +## 5. Complete cost and ownership + +For a block, count two input norm products, two A products per source record, +two B products, two c products and two output norm products per target record, +plus eight packed products for the two signed convolutions. The exact +FftWord call count is `4n+6m+8`. The tile adds `2*input_capacity` products +for its initial validation. These calls use the actual shared word owner. + +With the retained `O(q log²(q+2))` q-bit word contract, the eight packed +products have q=`O(bp)` and cost `O(bp log²(p+2))`; the scalar products, +packing, cropping, carries and head restoration fit the same block bound. +Across all blocks, `sum n_i=O(L+b)`. Copying overlap banks and streaming +coefficient pages also costs `O((L+b)p)`. The complete online bounds are + +```text +time O((input_capacity+L+b)*p*log²(p+2)), +space O((L+b)*p), +prepared catalogue O((L+b)*p). +``` + +For production capacity L, these give `O(Lp log²p)` time and `O(Lp)` +space. The output itself has L records. Metadata operations and fixed +scratch restoration fit these bounds. A caller must retain the complete +catalogue and reuse it across incoming payload lines. + +The producer uses exact rational metadata, directed exponentials and +sequential page copies. For fixed global parameters it performs a +polynomial number of operations on polynomial-length values in t,p. +Reflection scans add at most `O(b²p)` work per block. I charge total setup +time and scratch as **polynomial(t,p)**, separately from the per-line bill. +Only an enclosing tensor schedule with the required spectator stock may +absorb that term. This package does not implement that schedule. + +Under the retained bulk scaling `d=p^.997`, the complete expansion +arithmetic contributes `p^(.997+delta)` per data volume for each fixed +`delta>0`. At `delta=.0001`, `.9971<.99827619697`, the authenticated full +Fourier power. This comparison covers expansion arithmetic only. A full +caller must also pay its global permutations, short mixed-radix moves, +periodic halo copies, page access and compression. + +Each public owner reserves a fixed number of physical tapes before a call. +Inside a call it seals physical constructors, borrows canonical parameters, +suspends its scope around actual child owners and consumes protected child +returns. It restores borrowed values/heads and empties owned scratch on +success or failure. For paired reads, it opens the first value's ownership +scope before reading the second. The short-imaginary-input control exercises +that failure boundary. The checker disables decoded host dimensions during +the complete calls; host fractions and arrays belong only to reference tests. + +## 6. Remaining joins + +I leave the selected frontier unchanged. A complete transform still needs +the physical global coordinate gathers/scatters, short mixed-radix moves, +periodic halo routing, catalogue reuse and source-core assembly. A gather +that preserves canonical coarse-field order can move Theta(p) coordinates; +the caller must account for its full support, rather than pricing only the +selected low bits. + +PR3763 must receive the complete natural target tensor: D source lengths, +D-1 flags and one final contiguous axis. Microbox coarse indices cannot +become independent chirp row batches. Count the actual D scalar axes in +`gamma=sum_i(2u_i+ceilLog2(32p)+1)`; rad20 uses D=d-1. Keep fine normalization +within each endpoint and apply the final global restoration once. The +retained outer norm at most 1/2 leaves room for expansion error before the +chirp's .6 bound. The CRT entrance/return and both final integer-recovery S +factors remain separate obligations. Reviewers must also assess the +inherited numerical recovery, supplier and source-correspondence premises. diff --git a/research/physical-gaussian-row-norm-transfer/verify.py b/research/physical-gaussian-row-norm-transfer/verify.py new file mode 100644 index 0000000000..85b9d1995e --- /dev/null +++ b/research/physical-gaussian-row-norm-transfer/verify.py @@ -0,0 +1,46 @@ +#!/usr/bin/env python3 +"""Exact rational checks for the row-norm/domain proof in PROOF.md.""" +from fractions import Fraction +from hashlib import sha256 +from pathlib import Path +import sys + + +if sys.flags.optimize: + raise SystemExit("assertions must remain enabled") + +ROOT = Path(__file__).resolve().parent +proof = ROOT / "inputs/PR3878-PROOF.md" +expected_sha256 = "5452f3e2191824b4a8451c83fbdf58b3b2228f4e1966a6f22c3e60bd152e56b0" +assert sha256(proof.read_bytes()).hexdigest() == expected_sha256 + +# The bound (alpha+1)/(2 alpha) is exactly 3/4 at alpha=2 and +# decreases for every larger alpha. +q_at_two = (Fraction(2) + 1) / (2 * 2) +assert q_at_two == Fraction(3, 4) +for alpha in (2, 3, 7, 32, 101): + q = Fraction(alpha + 1, 2 * alpha) + assert q <= Fraction(3, 4) +assert Fraction(1 + 1, 2 * 1) == 1 # alpha=1 misses the 3/4 guarantee + +# C = sqrt(2)+2^-11 is strictly below the rational bound 10/7+2^-11, +# which is strictly below 3/2. Therefore the error budget is below 1/4 at p=3. +C_upper = Fraction(10, 7) + Fraction(1, 2048) +assert C_upper < Fraction(3, 2) +assert C_upper / 8 < Fraction(3, 16) < Fraction(1, 4) +assert C_upper / (2**101) < Fraction(1, 4) +assert Fraction(3, 4) + C_upper / 8 < 1 + +# Boundary control: at p=2 the stated coarse error budget does not imply +# strict output-domain preservation. This rational map saturates the bound. +assert Fraction(10, 7) > 1 # hence C > 1 and C/4 > 1/4 +exact_at_one = Fraction(3, 4) +approx_at_one = exact_at_one + Fraction(1, 4) +assert approx_at_one == 1 +assert Fraction(1, 4) < C_upper / 4 + +print( + "PASS_PHYSICAL_GAUSSIAN_ROW_NORM_TRANSFER " + "alpha2_q=3/4 all_alpha_guard=true C_upper=true " + "p3_preserves_unit_ball=true p2_boundary_control=true source_hash=true" +)