From 73b5f0d8c0a6410c3ab4bf45643c54f8802b84e3 Mon Sep 17 00:00:00 2001 From: Cinna Davis <1337isnot1337@users.noreply.github.com> Date: Fri, 23 Oct 2026 07:50:35 -0500 Subject: [PATCH] Research active p2 feedback and its retained output coupling --- research/coded-active-feedback/PROOF.md | 161 +++++++ research/coded-active-feedback/README.md | 97 +++++ research/coded-active-feedback/RESULT.json | 412 ++++++++++++++++++ research/coded-active-feedback/SEARCH.json.gz | Bin 0 -> 23057 bytes research/coded-active-feedback/SOURCES.json | 42 ++ research/coded-active-feedback/TASK.json | 114 +++++ research/coded-active-feedback/VALIDATION.md | 40 ++ research/coded-active-feedback/VERIFY.json | 40 ++ research/coded-active-feedback/search.py | 335 ++++++++++++++ research/coded-active-feedback/verify.py | 161 +++++++ 10 files changed, 1402 insertions(+) create mode 100644 research/coded-active-feedback/PROOF.md create mode 100644 research/coded-active-feedback/README.md create mode 100644 research/coded-active-feedback/RESULT.json create mode 100644 research/coded-active-feedback/SEARCH.json.gz create mode 100644 research/coded-active-feedback/SOURCES.json create mode 100644 research/coded-active-feedback/TASK.json create mode 100644 research/coded-active-feedback/VALIDATION.md create mode 100644 research/coded-active-feedback/VERIFY.json create mode 100644 research/coded-active-feedback/search.py create mode 100644 research/coded-active-feedback/verify.py diff --git a/research/coded-active-feedback/PROOF.md b/research/coded-active-feedback/PROOF.md new file mode 100644 index 0000000000..9716baebb4 --- /dev/null +++ b/research/coded-active-feedback/PROOF.md @@ -0,0 +1,161 @@ +# Active coefficient recovery and the remaining coupling + +Cinna Davis, with substantial OpenAI Codex assistance. Apache-2.0. + +This is a conditional component construction on the inherited physical ABI. +It supplies neither four autonomous Gaussian jobs nor a profitable caller. + +## Source and conventions + +Use Dugongue's PR4948 backward involutive producer, Dillon's signed PR4933 +normalizers and the mixed p2 chronology retained in the passive saved-query +package. There are four independent 112-owner main banks and two disjoint +408-owner helper inventories. Original helpers are never scratch. Rightmost +operators act first. On each main pair the inherited FULL is + + B_s = diag(D_s,D_s) [[I,-Q C_s],[0,I]]. + +Here Q is the central Gaussian, D1 and D3 are the two fresh eight-axis +Gaussians, C1 and C3 are the actual normalized F-transpose codes, and + + C_s^2=I, [C_s,D_s Q]=0, [C_s,D_t]=0 (s != t). + +Q commutes with D1,D3, which commute with each other. C_s need not commute +with Q or its own D_s. Q^4=I, and P=Q^2 is the physical monomial Pauli. +The source's all-width phase, chart and helper-autonomy results are premises; +this package does not independently replay their native words. + +The original thin inputs are X at query0, C1 X at query2, and C3 X at +query4. Their paid response is Q^-1 times that input; query0's response is +subsequently multiplied by C1 before addition. Retain the two FULLs, paid +IDLE, all bridges, signed swaps, scalar boundaries and all three queries. + +## The changed inputs + +Save h, the first FULL's Y output, before the subsequent IDLE and bridge. +At query2 replace its argument C1 X by C1 X+h, obtaining response r2. +At query4 replace its argument C3 X by C3 X+C1 Q^2 r2. +Both additions use owned query copies before the destination is updated. +No extra Gaussian query is introduced. + +Let x0,y0,x1,y1 denote the four original independent input banks, before +the scalar right boundary. After query4, before the last scalar operations, +the second pair's Y bank is exactly + + D1 Q^-1 x0 + + Q^-1 C1 Q (I-Q) D1 y0 + + [(Q^-1 C1 Q C1-Q^-1)D1 + Q^-1 C3 D1 D3] x1. + +Its y1 coefficient is zero. `verify.py` checks this complete four-block +row against chronological multiplication. No selected-column substitution +is used in that equality. + +For a short independent derivation of the x0 coefficient, restrict the +input to x0 only. After FULL1, X vanishes and h=Q^-1 C1 D1 x0. +Query2's response is Q^-1 h. Bridge-minus sends this response to the +second pair's Y input. FULL3 produces + + X=-D3 Q C3 Q^-1 h, Y=D3 Q^-1 h. + +The old part of query4's response is -Q^-1 D3 h, cancelling this Y. +Its new part is Q^-1 C1 Q h=D1 Q^-1 x0. Thus the previously absent +rank-nine coefficient has appeared through active use of two paid responses. +The finite passive trace's missing-grade invariant does not apply to this +changed trace. This observation is not independent-job credit. + +## The output is coupled at every positive width + +The y0 coefficient is an invertible left factor times (I-Q) times an +invertible right factor. It is nonzero whenever Q != I. At every positive +digit-column width, Q has an eigenvector of eigenvalue i (one column has +odd central frequency and the other columns have even central frequency). +Consequently an arbitrary y0 input changes this output. The old autonomous +job has not been recovered. + +There is also an exact size for the contamination. At column count f, in +the common 17-axis ambient address space, define + + b0(f) = sum_{0<=k<=f, k=0 mod 4} binomial(f,k). + +Q has eigenvalue i^k on a central Walsh frequency of Hamming weight k. +Hence, including the sixteen spectator axes and all 112 owners, + + rank(Q^-1 C1 Q (I-Q)D1) + = 112 * 2^(16f) * (2^f-b0(f)). + +The fraction of the full owner-bank dimension is 1-b0(f)/2^f, tending +to 3/4: the root-of-unity filter gives +`b0(f)=(2^f+(1+i)^f+(1-i)^f)/4` for f>=1, and both extra terms have +magnitude 2^(f/2). For example the rank fraction is 1/2,3/4,7/8 at +f=1,2,3. This is ordinary +complex linear rank, not a lower bound on recursive calls or free circuit +cost. It does not price a correction or exclude a changed caller. +The checker independently compares binomial sums, a four-residue recurrence +through f=64, and central frequency enumeration through f=12. + +## Inventory and ordinary work + +The attempted complete caller still invokes exactly two source FULLs, +one IDLE on two 112-owner banks, and three 112-query banks. Its recursive +paid histogram is the inherited + + {1:4754,2:824,3:1020,4:254,5:80,8:224}. + +All 816 original helper jobs remain autonomous once; no owned copy earns +a productive target. The old proposed main rewards cannot be retained. + +For the explicit component, one extra owned 112-field bank can first hold h, +then be reset and reused for r2. One extra eight-field mode workspace +implements C1. The additional field-level upper ledger is: + +| Added operation | Count | +| --- | ---: | +| Two feedback additions | 224 scalar ADDs | +| One inherited F-transpose recoding | 896 ADDs, 224 monomial passes, 16 mode CLEARs | +| Q^2 on the saved response | 112 monomial passes | +| Captures of h and r2 | 224 COPYs | +| Initial, intermediate and final reset of the saved bank | 336 owned resets | +| Extra owned capacity | 112 saved fields plus 8 modes | +| Gaussian children | 0 | + +Query buffers already required by the three thins stay charged. Read h +before changing its source; save r2 before releasing its query buffer. +The native helpers and original inputs are never cleared. These are +field-level counts under inherited owned-reset and monomial implementation +contracts. A fixed-tape implementation, precise rounding budget, completion, +compiler and outer bill are not supplied. + +## Bounded synthesis and its limits + +The search uses the semidirect-product algebra of the inherited gauge engine, +adding C1^2=C3^2=I and Q^4=I. Its fresh D exponents are formal integers. +In particular D^4=I and other additional physical source relations are not +imposed. This is a sufficient algebra for a positive identity; a failure in +it is not a faithful physical impossibility proof. + +For each feedback, allow it to be absent, or use a reduced C1/C3 word of +length at most seven with coefficient in {-2,-1,-1/2,1/2,1,2}. There are +91 choices per edge and 8,281 policies. The second word is followed on the +right by Q^2. Keep both original thin-input coefficients equal to one. +The passive left decoder may use the thirty words W and W Q^2, for reduced +C1/C3 words W of length at most seven, and arbitrary rational scalar sums +across all 39 recorded bank observations. This is a restricted whole-bank +decoder grammar; arbitrary port-dependent controls are not included. + +After query4 only scalar operations occur. Thus the span of all observations +equals that of the thirty preceding observations and response4, with the +same thirty left controls. This justifies caching the pre-query basis. +All 8,281 policies attain only the positive first-pair job in this formal +span. `SEARCH.json.gz` retains every policy, exact rank and attainment mask; +the full registered replay recomputes all of them. + +The smaller 49-policy pilot uses code-word length one, coefficients +/-1 +and decoder length three with the same Pauli placements. For all 196 target +questions it checks either a constructive recipe or a rational separating +functional directly against every declared generator. These checks do not +trust the elimination pivots. Deleted recipes and false dual pairings reject. + +The finite span result excludes the specified recipes only in the declared +formal algebra. Different feedback sources, earlier active changes, input +weights, additional Pauli placements, port-dependent controls, native prefix +observations and further physical relations remain outside it. diff --git a/research/coded-active-feedback/README.md b/research/coded-active-feedback/README.md new file mode 100644 index 0000000000..bdd22ccce3 --- /dev/null +++ b/research/coded-active-feedback/README.md @@ -0,0 +1,97 @@ +# Active query feedback restores a missing coefficient, with high-rank coupling + +Two changed inputs to already-paid queries recover the first original input's +missing rank-nine Gaussian coefficient in the PR4948 physical p2 caller. +The complete output remains coupled to two other arbitrary input banks. +**No autonomous new job, profitable complete caller or higher kappa is supplied.** + +Save the first FULL's Y output h. Add h to the second query's old input; +then add C1 Q^2 times that query response to the final query's old input. +All FULLs, the IDLE, three paid queries and 816 independent helper jobs stay +charged. The new response path gives exactly D1 Q^-1 on the first original +input. It escapes the unchanged-input premise of the passive grade result. + +The same output has second-input coefficient +`Q^-1 C1 Q (I-Q) D1`, which is nonzero at every positive width. At digit +width f its ordinary complex rank on the 112-owner, 17-axis ambient bank is +`112 * 2^(16f) * (2^f - sum_{k=0 mod 4} binomial(f,k))`. +The fraction of the bank dimension tends to 3/4. This measures coupling; +it is not a recursive-call lower bound. The [proof](PROOF.md) gives the +complete four-input row, all-width argument, exact recipe and ordinary bill. + +The exact bounded synthesis tests 8,281 feedback policies in a declared +universal operator algebra, retaining only one of the four required jobs +in every case. This rejects that finite formal synthesis domain. It is +**not** a physical impossibility result: additional source relations, other +feedback inputs and larger decoder grammars are untested. + +## Reproduce + +Python 3.12, standard library only, from the repository root: + +```sh +python3.12 -B scripts/research_package.py --package research/coded-active-feedback +python3.12 -I -O -W error -B research/coded-active-feedback/verify.py +``` + +The registered normal command replays every full-search policy and rank +(about three minutes on the author's machine). The optimized command checks +the complete component row, rank counts through width 64, positive/negative +controls and 196 direct span certificates on a smaller 49-policy pilot. +Both authenticate four inherited source inputs. All guards remain active +under optimization; no scientific module is loaded from a bytecode cache. +Default verification writes only private temporary outputs. `--write` is +the explicit RESULT.json authoring option. + +`SEARCH.json.gz` is a compressed mathematical receipt. Replay compares its +parsed JSON with the regenerated receipt, including every case. Compression +container bytes are not a cross-platform mathematical equality condition. +[RESULT.json](RESULT.json) records the canonical payload digest. + +## Scope, sources and credit + +Base: canonical main `ec2780e8aeb1c88acaf5e9e470ef8c68e7fbbb6c`, priority +revision 7, selected conditional kappa 0.00302015. [SOURCES.json](SOURCES.json) +pins the gauge engine, exact original chronology and mixed derivation, and +the involutive physical ABI proof. Their all-width native implementation +and helper-autonomy claims remain inherited premises. No new phase audit, +native-word emission, precision/tape implementation, full multiplier replay, +independent human review or formal proof-kernel acceptance is claimed. + +The [canonical investigation](https://github.com/CrocSwap/integer-mult-bounds/discussions/4930#discussioncomment-19145683) +and its [scope refinement](https://github.com/CrocSwap/integer-mult-bounds/discussions/4930#discussioncomment-19145848) +precede the published package. [TASK.json](TASK.json) records the exact +bounded scope, overlap coverage and remaining questions. + +Credit Dugongue/mdumitrean PR4948/4935/4929; Dillon PR4933; the passive +saved-query authors and Chris R/Clear1nsight's packaging; Cao Yifan PR4610; +Cinna Davis PR4694/4698/4470; Rohan Arun PR1931 and Ali Romman PR1862 for +the involutive repair lineage; zxv, Jacob Alan Sussman and all retained +native, Clifford, compiler and precision contributors. The inherited +gauge engine is used unchanged except for its explicitly supplied word +reducer. The new active recipe, complete row, coupling rank and bounded +synthesis are by Cinna Davis with substantial OpenAI Codex assistance. +No subagents. Apache-2.0. + +The submission refresh also found [PR5200](https://github.com/CrocSwap/integer-mult-bounds/pull/5200), +head `40bb94aebbf591a99e2f48533f16efe8914fb1e2`. Its two-FULL ceiling has +dirty identity workspace and excludes additional paid operations and owned +COPY/CLEAR resources. This package retains three separately paid query banks +and owned captures; its output is coupled. It is neither a counterexample +to that ceiling nor a replay of its proof. Standalone active repair bounds +and the passive unchanged-input result also remain outside the new recipe's +declared source-sharing premise. + +## Open next questions + +- Can a changed query input or boundary remove the explicit y0 coupling + while preserving every original main and helper job? Start with the + complete row in PROOF.md and declare the extra work before expanding. + Another selected-column identity does not supply the missing caller. +- Can a physical source relation or port-dependent control absent from + the formal algebra yield a complete identity? First give one explicit + relation and an exact all-input check. The finite search is not a + reason to repeat the same unaltered grammar. +- If a complete caller survives, price its scalar work, owned storage, + rounding, completion, compiler, BIT and outer transfer before assigning + a new kappa. The preserved paid histogram alone admits no new targets. diff --git a/research/coded-active-feedback/RESULT.json b/research/coded-active-feedback/RESULT.json new file mode 100644 index 0000000000..f8dadc8214 --- /dev/null +++ b/research/coded-active-feedback/RESULT.json @@ -0,0 +1,412 @@ +{ + "autonomous_Gaussian_job": false, + "complete_active_output_row": [ + [ + [ + [ + -1 + ], + [ + 1, + 0 + ], + "1" + ] + ], + [ + [ + [ + -1, + 2, + 1 + ], + [ + 1, + 0 + ], + "1" + ], + [ + [ + -1, + 2, + 1, + 1 + ], + [ + 1, + 0 + ], + "-1" + ] + ], + [ + [ + [ + -1 + ], + [ + 1, + 0 + ], + "-1" + ], + [ + [ + -1, + 2, + 1, + 2 + ], + [ + 1, + 0 + ], + "1" + ], + [ + [ + -1, + 3 + ], + [ + 1, + 1 + ], + "1" + ] + ], + [] + ], + "coupling_ranks": [ + { + "central_eigenvalue_one": 1, + "complex_rank": "7340032", + "width": 1 + }, + { + "central_eigenvalue_one": 1, + "complex_rank": "1443109011456", + "width": 2 + }, + { + "central_eigenvalue_one": 1, + "complex_rank": "220676381741154304", + "width": 3 + }, + { + "central_eigenvalue_one": 2, + "complex_rank": "28924494707576576933888", + "width": 4 + }, + { + "central_eigenvalue_one": 6, + "complex_rank": "3520391986717800156744384512", + "width": 5 + }, + { + "central_eigenvalue_one": 16, + "complex_rank": "425930601676685078902892277006336", + "width": 6 + }, + { + "central_eigenvalue_one": 36, + "complex_rank": "53501426830342863884378234176283869184", + "width": 7 + }, + { + "central_eigenvalue_one": 72, + "complex_rank": "7012539017506699855053223909953879301685248", + "width": 8 + }, + { + "central_eigenvalue_one": 136, + "complex_rank": "939128981800521601736352167897767799739847278592", + "width": 9 + }, + { + "central_eigenvalue_one": 256, + "complex_rank": "125712524836654945412208154570923800218724693616623616", + "width": 10 + }, + { + "central_eigenvalue_one": 496, + "complex_rank": "16649031555967016557205082102960958970833981823402654040064", + "width": 11 + }, + { + "central_eigenvalue_one": 992, + "complex_rank": "2182221864103708794185984521399298814225151665557032670339268608", + "width": 12 + }, + { + "central_eigenvalue_one": 2016, + "complex_rank": "284553812088441518457774510801277508125654547772283698609148261302272", + "width": 13 + }, + { + "central_eigenvalue_one": 4096, + "complex_rank": "37103788360346070921249247515601288832377161834387998120553730227145015296", + "width": 14 + }, + { + "central_eigenvalue_one": 8256, + "complex_rank": "4850602988206948748915528293879566889915887951384099252965402855081485946322944", + "width": 15 + }, + { + "central_eigenvalue_one": 16512, + "complex_rank": "635778234870261186417856124535382591395055265563816657284681283021240525956440915968", + "width": 16 + }, + { + "central_eigenvalue_one": 32896, + "complex_rank": "83441514258879515054132727821883784078104658550967496716807846623105416858134115413655552", + "width": 17 + }, + { + "central_eigenvalue_one": 65536, + "complex_rank": "10951105408774197199779164020888816993812694084348073283419891055729153867527698132441944293376", + "width": 18 + }, + { + "central_eigenvalue_one": 130816, + "complex_rank": "1436317782467066973530502408542388200063156122252201696991263791159953876854619479856065568334413824", + "width": 19 + }, + { + "central_eigenvalue_one": 261632, + "complex_rank": "188261044383523402354590011692467906158677999255840580828038927634917474547088684463694226172728288739328", + "width": 20 + }, + { + "central_eigenvalue_one": 523776, + "complex_rank": "24667724364281214143130184139421596091737454740999447626359636762026048993769698353197084547975956821738258432", + "width": 21 + }, + { + "central_eigenvalue_one": 1048576, + "complex_rank": "3232195820797984622882265008214905819947947362030368671980133443317031864068130557967576528721028236159918702329856", + "width": 22 + }, + { + "central_eigenvalue_one": 2098176, + "complex_rank": "423581417112789750151802750836568884308058467092321168042111141168992570474037888375356215806576564367581452552795848704", + "width": 23 + }, + { + "central_eigenvalue_one": 4196352, + "complex_rank": "55519663503807578131897090157650756804025839398724720137615591495302194197173094105134689918199603444787636149000057481330688", + "width": 24 + }, + { + "central_eigenvalue_one": 8390656, + "complex_rank": "7277665640919102943648676317259597358668961072265582513850029853792815065400819525514073446490812407610428487047709955122016550912", + "width": 25 + }, + { + "central_eigenvalue_one": 16777216, + "complex_rank": "953975825637984043845987497853005951339154285902104954119455886424589065648834774365625754061814679798500809608224358537764164637556736", + "width": 26 + }, + { + "central_eigenvalue_one": 33550336, + "complex_rank": "125044607289091913843215118585244412085666106051285511772767292376838002487740865331114582173745170055508023454620426985507359329585236803584", + "width": 27 + }, + { + "central_eigenvalue_one": 67100672, + "complex_rank": "16389846766595855331257892023205155580892427852354094599080154546416910662073170700679850514677126929515547650244008605844420602047396158319362048", + "width": 28 + }, + { + "central_eigenvalue_one": 134209536, + "complex_rank": "2148206290911547526087395080904329047970451823089758577694521988510522559094911153360827682374317492017865624035746996292519360879896799227241134292992", + "width": 29 + }, + { + "central_eigenvalue_one": 268435456, + "complex_rank": "281563966528794539091054524962322768677066682232440260932194790318157044631544486512839360261504971981490669021916207067928831539050877968875106629127766016", + "width": 30 + }, + { + "central_eigenvalue_one": 536887296, + "complex_rank": "36904776802240119435023910623161620172348914751327433293890059296861055944552956876895530175715631014261969649148571871198143902377757942632439475950862376894464", + "width": 31 + }, + { + "central_eigenvalue_one": 1073774592, + "complex_rank": "4837182905023216934587454013199039879230116954285989336696757852158172324764445163768450931191399188301344885853201612301683117572457489056719106991831433464311185408", + "width": 32 + }, + { + "central_eigenvalue_one": 2147516416, + "complex_rank": "634022462548611018613413971012026864362246327231067593153360051819670411116703181827963845141482873678000281941859583835383833902142256583956303872937011291183647054364672", + "width": 33 + }, + { + "central_eigenvalue_one": 4294967296, + "complex_rank": "83103014894963123444328847062601455851804133298007178211125186847213467635794707369226310756577663116504817599141422818022058651527068406549095508114236104419979875441962909696", + "width": 34 + }, + { + "central_eigenvalue_one": 8589869056, + "complex_rank": "10892506069317571503802885418471652221892955294347496198214670865500246034448095815868354078923066319227558287293864285411393278925839752539338562804718526090570408893887443153977344", + "width": 35 + }, + { + "central_eigenvalue_one": 17179738112, + "complex_rank": "1427702555517592732146451797569916400027953436340715021692393339682848248227180814777496905832604148593794519832181379617442139855367668044836184103940066651743244634539614949078118432768", + "width": 36 + }, + { + "central_eigenvalue_one": 34359607296, + "complex_rank": "187131591406981132676239517075567546878518869150333457612963786467936371810838226092711327296490076141765855641024067950784921279855207717559925067406681928746156889901967076349405013005565952", + "width": 37 + }, + { + "central_eigenvalue_one": 68719476736, + "complex_rank": "24527680760336921495414938552244766162625996454968258186793738976226503298913849629855787273642188645209981056267643533702262476582114354678606307254826623476042723369360784371645531657517741899776", + "width": 38 + }, + { + "central_eigenvalue_one": 137439215616, + "complex_rank": "3214890128645484279503568874674946636737201055179228289704580055613712221519961189196988594881889479922575536175357884279128472142031177520238062687312363956699915500575242615761625488286527339808948224", + "width": 39 + }, + { + "central_eigenvalue_one": 274878431232, + "complex_rank": "421382078941820915483091779541394605570418416704451810388158717049400488299064352990427689108359017912411820677576508608233927100600310499932643352551406168532571324491398200133107776000691711483438461616128", + "width": 40 + }, + { + "central_eigenvalue_one": 549756338176, + "complex_rank": "55231409408660136430115099749145512364802225321964616607964344421660354211227155753677418348862755966849481666420589711142570665778406919205006742298731329123215518595292606584429585936874026269452912592087416832", + "width": 41 + }, + { + "central_eigenvalue_one": 1099511627776, + "complex_rank": "7239293595321358329581455772253074356735648455674209963177666082533761039744283263918866252551248771531842672786128409196849271750908961169452833844998274931035976308732548648928866396770846445580920965460879533408256", + "width": 42 + }, + { + "central_eigenvalue_one": 2199022206976, + "complex_rank": "948868840944577648169865770594416884025104013041472874839663948304575179788051023974274969097444207133237756387479105894591286014628300835672546201332318995891475216654365715107167895708931651374483422387408515971210543104", + "width": 43 + }, + { + "central_eigenvalue_one": 4398044413952, + "complex_rank": "124370136720287681500920646283351409822938433197371932650984433032177277965179423814356168749540207117367739205219661367815869040509360647133271975701029715429487439597321023010526710426361089408956291139162409005378508305727488", + "width": 44 + }, + { + "central_eigenvalue_one": 8796090925056, + "complex_rank": "16301441264679495404376477789253856409254744747885624186694939002833537590329477372334757521520261022883872742713213861733581588670424234925608620393508884411210277465559492568156771244067892190837990241863159097518673366306690957312", + "width": 45 + }, + { + "central_eigenvalue_one": 17592186044416, + "complex_rank": "2136662339637404476252393914873449916687620922372956411259787201645580779940342308074189395420877687158226442298310822286432874065193277995111549027999075789916966387478550807612985900942201149281437154218347452417228785839645472520667136", + "width": 46 + }, + { + "central_eigenvalue_one": 35184376283136, + "complex_rank": "280056595052504193899872128062407854180861533455909172044161519449364555417607318147950631216868845727465102295828142461691796927635127577160271396325243674440810212522055343337997165023994621631318878170222059062671363411174085126075380137984", + "width": 47 + }, + { + "central_eigenvalue_one": 70368752566272, + "complex_rank": "36707578026721829702844039569395922263193882913132926998172338677267111007696626404288185134857433347190305888118786288738867206898991441793551092459142338896305876175690837961997964414025023046460227999527345725462460945029409685644952225445838848", + "width": 48 + }, + { + "central_eigenvalue_one": 140737496743936, + "complex_rank": "4811335762711138572576764827648617594661300401057414316225304162547506763450050057416434379327285535377530085458148754705039737574926466772219546582893777010031383342920328573267909901801778127577400862868490730251886006996413350182117727163762335547392", + "width": 49 + }, + { + "central_eigenvalue_one": 281474976710656, + "complex_rank": "630631413619594819317577246422777576350187805858158297080943548824061051260015463467582456680747835991278537611515258860011346015969388433987962716157752033443337061497635816496276781390688214634878300505103820596963748479753507838018227566528126203950268416", + "width": 50 + }, + { + "central_eigenvalue_one": 562949936644096, + "complex_rank": "82658121467082185308107572496221675433696785295414229859470382155612575975415573989101435818806970828772605262127123857626567118978246472446478105887388661191224702203963253898179959686634011437748048076302755089305832176368132612357105121019541701721000576548864", + "width": 51 + }, + { + "central_eigenvalue_one": 1125899873288192, + "complex_rank": "10834165296933396192704275742224767442445505042240533936140501929900451558249670113899503395642667280468882916917526378266829405418716721636504778294871806599656204167277871614942243676046493147168512157457154715065494035020923877766870482422273369927974987569412702208", + "width": 52 + }, + { + "central_eigenvalue_one": 2251799780130816, + "complex_rank": "1420055706746161143982612085970240678269439424640822957778883127409805718357688591718134646449849103423251097714044589670512807033492628431234701537386909508679940699601385427279630041310500111668100181779747928621707167104589366230328429367969004596001708638075590721667072", + "width": 53 + }, + { + "central_eigenvalue_one": 4503599627370496, + "complex_rank": "186129540670117403976674750215696762578227902858539126158781105551926814319899629619410840299244423880492289063895061219093479455449837564609095109719933790811552927788476093726136771479369714702814955183442712910934822099473687898226374851151238797564822120753151310499304964096", + "width": 54 + }, + { + "central_eigenvalue_one": 9007199321849856, + "complex_rank": "24396371094124585187143537086614660812148031115040878215453051937090593609686707717049756976300598883620257746918436451122346965261062432364199315325021347467294251154622086542394303818200466946253366134314960042885124226527286151357236291786197108148622485595724847803765124700831744", + "width": 55 + }, + { + "central_eigenvalue_one": 18014398643699712, + "complex_rank": "3197681152049097629649277693016756821969866734310637989455862423498338285608856153889145746397672096873874423404093302521508261430697975134840332658281198055233192087338626127284706190059171603579321205956930442741039002619384450430695675237000427359256246432002847251335102424787418349568", + "width": 56 + }, + { + "central_eigenvalue_one": 36028797153181696, + "complex_rank": "419126464481835242480614197758414224521699568645505013134746860242294346531903223808699642012644587155107191130850870674666671409903549832814509079913023894881363072295688197912071965623375983866352997011770505514776467173451670734259401575519104643954465061389692981835944914510054369999716352", + "width": 57 + }, + { + "central_eigenvalue_one": 72057594037927936, + "complex_rank": "54935744020780306982219057691064545951634524037637221084762593153753349789120260186418862195140656788768281570480019734689770632323092272743084992448405779024078594548659387376426407887282664545760995562796380853187309757474456571958612407926664629200682403816264010136930914664234646514546220466176", + "width": 58 + }, + { + "central_eigenvalue_one": 144115187807420416, + "complex_rank": "7200537844762398690131188707793487044175158722652276665397427502814464886618925380940772612999782009320940172446084227596248805666350611466983285930253187096402051926198695929613394050001197903377358301695990750296745454276752987219229995202874822079915462945821307168069502380149446617270572791181082624", + "width": 59 + }, + { + "central_eigenvalue_one": 288230375614840832, + "complex_rank": "943788896388697121112875166307907933854126404095479207086971617648897541618915787530668947931107427525714270282853151879495523456299907346200433253450145739099609750070715472886286784921757011591477107319896899622895020182962567540798913931231208679658679559234690373133205815970948267018888516885686861692928", + "width": 60 + }, + { + "central_eigenvalue_one": 576460751766552576, + "complex_rank": "123704298189056440576950953015518554947817591147081902179777219377692284655881148430902129713069882843895881279221135245784132468249434168641970652073648776287544357063967327557181337621515403638774549238142938638535577519080111975205238063862287674557482253702186168411286985582049150738056749882816203221454815232", + "width": 61 + }, + { + "central_eigenvalue_one": 1152921504606846976, + "complex_rank": "16214169767202465001687630772007993499911078052699983541469301294616840861999138964581176978035658319087709942438709450299018796863943721825436711878797564347655738486510824541678638696990804836906567082397184930571755055053400217708512002825288202984455151316679131166835791423491823399261142264105095411413047266246656", + "width": 62 + }, + { + "central_eigenvalue_one": 2305843010287435776, + "complex_rank": "2125223659396883364299458281627578038066406152684806572729967849346016179098862420401083317508864689645027909716282947139117945960100091011011035681770399376173052820877747687749126966886081988196974167946014460378161476310095116128186207107108492992431203286567121586389199519499231160712878651583679748217019842995897237504", + "width": 63 + }, + { + "central_eigenvalue_one": 4611686020574871552, + "complex_rank": "278557315484468296325458595889489908605439987244702967100862345949481032626846095166810792592521912601153098182332638447418467412882239128995238468881009787033754379338088144928653569803692538356953798141020007350686381022916787061153622537942924393503942677176925760571205159419803226696958430620376071958301224861158242714124288", + "width": 64 + } + ], + "direct_span_certificates": 196, + "full_search_canonical_sha256": "52af1535ddff248377da4cf92141aca2b1fc8f733ffed71fb95c719cbdc05f10", + "full_search_policies": 8281, + "new_kappa": null, + "normal_form_fixtures": 1555, + "physical_impossibility_claim": false, + "pilot_canonical_sha256": "e736bb9605bf510c3d9cebf3fc78d1a8fc5fc5e8a4a645010f5b9326ad239e5b", + "pilot_policies": 49, + "status": "PASS_ACTIVE_FEEDBACK_COMPONENT_AND_CERTIFIED_PILOT" +} diff --git a/research/coded-active-feedback/SEARCH.json.gz b/research/coded-active-feedback/SEARCH.json.gz new file mode 100644 index 0000000000000000000000000000000000000000..f3c308dca0c3b914a1a6bedf25c6fc2b1defbfbc GIT binary patch literal 23057 zcmc$`XHZk^-o~pSpfn2-N&qQ>D7}ReKsqX2kQP9i6bYdOLPrq+r5B}z-a$Y@=uMCo zdXW}-FVdTe^{iy?Gy8e=p4sor`_7!>+#h~iUf1~Ho^`GNy4S)R5f{%9{*e3`pEHkP zn|#Z<_`&+XS8}jaMp5)2UChRY+^vPDM^!=UfUvp{k{oR?6`TO_%jGrei zF&_qQtoPg+dOX+Sd-SRB!=Js4`M~e%cm2QoJT|I5{{HU0%f{}9UtcnxN$3Rr`Z*q9 zG$bEzxNhWsy1bU86ZqZb_xeK1nS{lB;1_&^jz!a%^Zd_`I=|O@z6Nf7+Y6I#Z2omJ zIdu1IL-Oug-}}3Neh%GrmHlzLYcKSnA>hm7jAy^jB5I$VTt2QKon!f$vbpu1%|FB8 zn1APGQ&6c}6~*_!W0vVq*7sAZiF4yk53FC8c5Mi(^nwb|vo%hn+C)7SPP+GK+&@>^e9t~L$z zV?#}sO|tca#Nu?mlX;P(9IFlZ2Cp}Bh%Lm{yY%l!+WiJgkkY1-hV{QtUT@PA<3Lj_ z!8g~HCAdnY;|9Xv7B9te(ctl&qIGpC<&Vr)!_5!;Gi#wx{tAPfMyA4B5==3uouHnrh1# z(~7d@HZ>R~fyZ?A_G>OjQlFSF&56&dE_eM^k(u zw?(q2l8wj~*(pgdG~iI?E194$`YRwQ5{p?l)VIq?1 zkF*-_3)53+l9B4SwHinX)6@LZ3m~l~*#-SWVvI&Jgj9d2)j&a*{<5YjF$Ulj&5#TF zSKAC^2`b<{-)3-6nEt9}Cn+HY;5AJ$GJTOY0~LY_csbe(bcN~ZG*yW)0IzF?km>8S z8E6tzz^mA1U@S~eui1Hl5CagTNk*>k)@EQpPyw%1n}MY;J%gqyF$N%`W(c`{T$_Oz zK?S@)Z3Yg)^h}zaWB`th$`r^;jpXJOhn#8#*kBg7@X!iiJ zJ8ZZ+jM`mHbVl~ov^|-buXJ|C*VMpg{IF5Ah{A!Y)&$Y8BeiQcj?@!*`?m8NdeMm1 z%YE3;e`vM58aqV|qc9z_564~C!bER;Rrk8BvGcBB6s-I6o2(1J8}G3jg>A2BJ|D_9}4QZ`^5Gk&2Fx6(ldnDX|{7;6V!8!dmeED z<6RIvO?*|W(ik!-V1U55YIwqUW<uOMBwb{G;hXRkD zVss-sO@%+XzfBCUGRP&P6EJodQPB8eA~@vk35vv8qE$cfo7mM0_j#I#_vJhSMOVTT zxD)tIY)9B5z8Fh&S4t#CVjLnu?(_FqnNVto87H^q{G`u+FYFi6!#8N|__MgwC>oW0TTrZ^LH6LzsNU=F zUNM7=ERtW>iwf^SxqEL9Y56=27uU~AR%(7zoUg*i{owZK{kR8|5)TVvuLZm*%GCvj z^zu%q7T@U=*DH9XBzL_e+n6f<0q-Zp6v}W3-O}eTekHuiH29I%duu`t^Z61)r`-Et zb3#eF<@N=QThr1#y*(1z<*qLR=t|KJGdKHqCM7T>m$s8Cr}Ik@x64c@x8LTN<`-$- zF4d#lPFSAKs}j8Z?tbs*xR0iJ6|}d@6(4NJR8HrX?(vpOhi^xbz;c@gdCNo|Y)33l z=hT(+R^0C0em!cMQx(ly!9lqb#yOMSf#7}5)Vm!*0?TgI=B>Q?U?=!!I;%;LxAIc> zPLL8TtDlw^bN<23GtQYz+}^FKv!0!RYp~3Y!CO^_mv;TEXEMghZ(+B3c6^jz8N<=H zYL@QrdWp`Y_akoA;9u{0zJR6AYTv3Jxxb6Fo=KY$yj9oJv+MQ{mNrIvtFGU}PO{WM%k-RstkA1$@dYds2Ssynbsg(UWznI}KyFV5SqJ1PqtmJS!U zrr>V<`u+dYjf)~#Ahnay4)emK)D^^++8O=?V{KCEKty}YN0U-Z5MOdnfNNg& zsj-Gr_jjC11eDwDrZfBgNT69~WnDq(yV9BSdoyhUvu)0^OJ%cP3=t80wQX-_W_z6x zYmje=VAm~e@V};!m|YlXs=zb7cK%gns=XF*LWvPF1K~?O%Ou(BUv3PjYKO=l$GkTO z;VV7MYB|oNedo0UyZmny{AV=%zhB8pU--s2ZDR1#V*wB+rn65V% zEO3|a6uXn5e^y$u@d%2YuBRU=_YPbWE6uRk<#*b^Z|iKF7afdo^QRuOVPpHWldRS) zE4|((G7=R8kJPteVLt9pR_{^~A%7t<7~y87IcCiX5-Vf8->Gn$TuEf)^=r+31M8dD zNTV32=+b56eBZom}!QFt^Yj$iYU)g4Nt7Nf>T-K(K5gvW!6 zS^CE<`N@?97$3BmU0PQX#s{@gM?SLTCqdFAYqZ*)Cnpu2c!v3@G4WXRcjYdF)(6Wo zvUVYSK+jH};bZadF9sMiTi}OJf`#V%mS!U+EX2Q5mL+L5du)X$3r+jr`!$p;7!N-_ zXXtJepM5eSNQH7N)lfEP+ges&=&Bd)&({;AarcRgP&Q*+`gks>yH>V|dsN^G!VMmw z3}eF|wI<@K6-qnx1ZbbW*3?ij9uJYz%SF!D6OG% z>uC(!|6HGy??mZf2K3$c-^|K9@zNfN(sy0BJ`3UY((2LDM-5${6D9M~Y@^Ya^tz(| zLsP^Pne@&kvs)9f=WZ_hU6u;U;ll33vK!PgDH~Q}6;^9aQENj{V@pxsX2s+A*c2Dstfbu+u-Kod)bkVrLCSV*9LI}ADX{|~ zt`Lvo?9{8{X*fGoh|tHBk%6eED1&3JG>#>f`}X&xbsADe2j05YygcSk7gjhpaR~j0*0Cq^rO~f#2A2|tW~Rx6$K3M5mdk{B4B6`K|f|4LW}`8ZrxdJ zY$af*OHcu?o`9iQ1pS0H88HUnq_t{|agczaF+l~qZUTn35%g2mA;cJfc~y?e=r3x;c?89F11r z%5{C=jQFiL)P-<}YVPf1&3elRPMsfRFcoV2<(D;_+AA9>N_qIpC^Vefj$|t8$oWhE zP&$1WZFpa`&iDRnxKr~-nfDc4eDC*rof@w-mbVu0m2ZSQ)gQ@}H-++H7AWDh%ME39 zc6^x02k>f9Xcu=X@n-@vz#R+L&JF z-1x?#MV>n~Vd2i%?$DxH@;mj~jfGR|x9hzgAkr(Lg_~Ws>s%-i==jEh)q>lN z_Th+>7tn&m&|)<7Rk2IpC%S>L0dv8a53-*=h272jT25{GuM2kpnbST~qij}7I$IkI zs|%i~YlqeEmd%2U5W#%4^~5>rKtOVFG+lh`+7M+rW!h{1(S1KI>TfANqq-Whd>(gP zd5-RX_>;~qxaepjaNIOik1HOw|NZ-G@VDE()5d+WLMY-T`(ZUy0l8F%cb)Q=a!_Lt zzZIQIuRaj5V%KGbT*<<_4gZuvguX=HOy^#c-LiWiY4j0)Z7|8B>kYC1Eiu=0-(FkB zYZ?D(Fw>pfn*L;0 z_Q$zTopiQK7fhrSLAtR3j$AMiR|M%0@G6;!f+9#eHiXXh@Pdh~B1kWm?D{{wda

vMiY24B9tsR{qWj8EAuPwplTzYFTMSE4Ig2#TqpzCdj(LtD1u7f`fB(&T0S|Qi!@b0tz((YX>QuefHiLe1Q*Z+2Z`|M5S zCqcHby9=M0jE3s{C)SP;itDGy_Zb1FKmC54seB5CByr;6}>s9vS;^H z@>*li1Wg_y$Ac~#y)}Dpo&1jEmHL#fft!dDSLGn^*37+myU!51+Tt3TeCIqkmlgW+ zw86xB2?SJ~T|mR_T;iawh~CB<4~9O4T*uZY4&=itZG$<$+f&9}>vtdwn4VA?9(bvx z&3W|Bq-~4cwgmJ0HWW>PQ>9tLQtIx6Lk;;m3C1$K-2jhMgK>Ks^X|Aqxt)^)_}!Kv zP2p4EkR&^GZ_J}$olkQMvV?L_VpuSrm!~g$Pg=jssz1c&5!UaYDi(m z;I`|Up_Zbg*sF|Mt(ND=kA=X`@FyB!kEMR(j4)`mzz?1vg;@QT#v(#3M30Y{adp2% z$^)o(*p5@XtL8<@Jo~pgL8A{DCrJ6FWO9b>d*3R-Ehm9OO>+@@UvkjRI~GEX;~M)XAHmI=@lKyvU)%Z5 zFZRIj49JA&P(*q}8fCz`P(8=6nG^!T0=Yq(dX-|}b*^2f-tlr>irdtzlmm)I{BAV* ze>p?n&d@td>$QI*_kKEMe6Y+L)p^X9X?4otWN!i;l5h0@x)>;HZ9?k;2$Z!Jp{xM} z3Rss=)9)_@9>wLYPt z6^Uj2kbru`0yZR+HJ}3CM}&s9B9^rQ0o{lNY)mL?Kn2R$h|thM#IiOdU>vc4O$lWU zs6bhp5E?q0Sk}e_#E_YID1yugWeuo6S;Jyg8Eo5#9S@5Ys0i5!R+g*bgjvwx)&KHl z!6pJtRugaTcuMR3mDcr)*7XOi+pn6sz!|d-TICDmlPM*6S&dz6wmR85AT7^?N{8b=CddY(1G zVtszizO#QU_s8Oyd|Y$TXBrikJRiCq^sRZ>10G+=xW<&}s18JyCuuR7cTQ!~PDV1m zKB$*Q1ySH8_8NU>R(DbDJ0!j~rD34Mxx`u75qx{*-c&&YRJM7pc=(1CA{hGFF*Tk+Q2Q~F~JmC@0w_@t; zy=R~nFG}|&B~7!_mY180gQ*8+pi*#6lpz-5Pu*$5%c{SW+}mX)-W4x$Ju=&@ztdU} zD0asF4&$3$*F=DGep$^fD`6TNE5^Q$w%2(QguyRISg5-!g~<{)lKWfX7u4v48K1ZP z?CW|A`8B%4FxcX7qM9HC_Q%g^bX!QB=42=JH#L!qmOqPhx;2=QlU-_zbXdp=qDGczDwvJu;Tc>!0YbpAj&nG}z7s-Wd z{zN$ciEsR{x-QiCH3ISL1@yyWmr(t_2I5C$W6NfNP~8R<;;a(dvJ)!Qyg=phHK(z8 z(@v;yvJY`O3T-}66KWWWKpZ#J2OsK^Oj5$oa?R$#^guH5=SG;ziPuG|Ed4;%~!d6+~Wiyh)gBd88bnn^qp(1bXHEcxSCce|iB--V-SCqxwvU0cwF?#MXRHLv7ZcKpr6mV9}mHxgXW`{0pL5;urCGez~Ex zVo#um5CgDoPoUC|YG?ix_)+c7lMvNPzlfcA>&DvQ zJ%I{B48W;9fd)USy?G^~TH_b7JD<~7ySOJ%MTh~oxhK%#N3}oyf~Yq5MeNNlH`X5P z3Dgk~g#Y%X4a2t3B7iyF<?X`@_=&7@MScd8ERzhwj}t0{L$-k1q@PCg_a5H~;$#BU{+mTAm^MvWeK3b> zV+13%HC*qp2$yk{XNBf2OTQf|@wKQHdzTJ7+zH<>l5hVkJuz5`%2*Q<$aJErEX#B` zjeNIZCck~;Q_Ft*z20aD_`*Q|*GeW`$4Mo*YIT?HM|~YTm|=A#JaRTR;aBO-#@e=y zgSFh~=QxAQZ+&^j=+ZNACz|>8oO0uv*(x#DeQyqn1!VLb8>ELV%Z>uYr}Nh5PCwF| zt?x+pZCH-%_-gUZA$lKvoU$BS@1a@LhP5nyx$Sz)TW|gjBx^?Bfo%u{m+ZtM=7J8$ zTeKDXi*;b%GJs+Qil6T}8BFvNZwj7c?calY+UG*&W|vl@L0;l@*yi+sT@U9l8|d`( z$e4B#N~Y>Kopor(^+^~PbZ%;^V~_zQThSiCI=Jm`zOm9k4l`2N_BQEmmsuD;D=k+X zr_Yj^A3Mv_zTnATNGig5e@o@whKS7Nk=HM^FL>}|avieV+fb0YRVjUSAjLNN0+Kz6 z6q9y;O_R4!RQh^PoJ#Zscb*tAx3mWJsn!)2#8Cr8(4G3a*78F zVXDUGMUguT+XsuFweWCUff$4ZGx9Qu91eMmJxtY}bgfgvN-&pg*=kWZ$s4U;n6<}U ziweXfSc}h8q9~q9>0sSbr@oM*nuD}lY=_WON9&$VJ~S@YAJ9{KcBsa<0fgmy@YH7> zRKx2igk2^WzfO*-57I)|#h~%a1*p1g8iegLFn-<+Rhu&4{L}?JJ*|eSiHmZ6`WQVu zv5u<7XgNFRfTu?bP*ue=&WO9x)q;zP}x5EbBuGsat9k1b-kc(;3@Cg=(OLW@* z@|co8)A7s<7VG@W|DC;=+{Tef(oiE=%H&Y9@0ao8ebRo0k!CUvm-BP5dtX5#&7DY> z!&#UL5j|Wu=3ok6LBq|e9xhksV47b+qyO{*_^Dad(?yXO8*T3Na1oh<8GHqeHHQ#m z0FF0zdb(K6!E^~K;MJRhnSBLKG?Niy08TcmqFjRJV8#R$@Vd>xY`=o0nnQ>&0P)S8 zD3|Oxm?c34ym50d_*c+$GZ`@k;7qfsmrL6m%z>Z+Ud$ZK<11*kIfNJkaIU%2%VlW} z=1Ncj@5mg?|0`&|nT&uloZtm{sfm@DTJD;b0NWDPj6|74sW)eJcUx#pZAoXxCk_<8 z95!T14<`vMvymsP|=R)vBp4fFg$bZsJTl zR%K;SJghQFv}sxtgM~Ks2C{`mCXa^Rq3o)Wd>Q74KYQ(s<+`U$CI+$o1#3uW#hTOO zvJAJ=v_5-t`F)VB#oe!;@kT=*$e8NbDU58FLS=XCt?x20*si?rH;an{yH{qu{nh0E z>ylQfx~W|J=j?|=FMV@9(WPV*pJ?V4GRwW$j8lra;9D>x=95u!ted7jEgQdHEUFXY zQ{HD|!d7ym`=&5e_U&ptXAGH7QMa;m#=Aqa$XhVk4D|TZf4oU z#U2tJa_^cCxo51U`8(-iFjNb6C55$o$JMqF3{9Up`xs4us(at=lm33&-)z!yo6><*XxrO(qfsVv zT%xFf#Go53lR5S}i+0t6y@2a>`o%3-wG9rLxZ&5&2Un3dGf1~sE^eqmZskZP^v7A! zuDY`)iWR3_S~K7YrN1hPg~5ilMXd%xf1E6Tb2VGPh|~( zX9?PIkAea&iOixy1)2>D_f&ncbKVhp**#*995+9%pWEwcnWVo4h1C&Z(ops=?ChKP!~{S-AEevVMQYox;rFSaMw2_5W||CKby@Yy;8GVMMTl@XOrJs;e+M|+y^rD`P64{-wD zu{~fj^Yv@3NAB!Md;EVsW>F*y7fetUpDI0V&N3A$n20Dk<$T(lOvIAY7f+jGO@;C% zB8pF~pEehn3Kjj+3t-7a#Jkgv#8}ZpM9FE+)8;x;q0$K|Vhq6YiHOou5~t=0f(m$- zpEl!6g(@bfh%o>wCnCyDm7JPe2`b>_bZVY56{?z`BE|r$nTRMqec{wROi%%@wNvw^ zsZiYn6)^^2!$idU(~nNgiv$($<~TKfGZku@pd!WqY?;sqp3n%Ipd#A-E-X7WhtzBb zxC$%o2w<)DxsU=U9kXrym@$gSv6@uQGmXm+*mktpHXpKW8nS&hMR*F-HYTFY`=ZL% z)F$1rE`3%E$A8&G#x6%pl>el^U-Sg!aoS_}{xRMww%u+R%H9+nu@hVqwntIfB z7!(X)9BXDDBy$wFXQMbr`PpDN>4og|j&%0H3!dCXT#5@9k5sNOypXzb5|A}S3ihx( zPrK^Ou0tBYwAtQD&S2b1;zN(iZ6&9hQXqkjc zf;bcV>vQ)>UXdsy{CWLNC+`{0PceLE_;1}K^%r;Jf22$e`scmnLXx|0 zzt-2qWK2cp;y7oSl3*-(PSQ$&?xS&GKV6iG1RIz4uVQpXh8bo(=ef zu<};0TncbrA5-8fJQkdi5qV;pV^1oVy3rZh zZ&yCHnb+Nr<@x|`1UO?hghFx&Bj*jL%9sthCAom2%bvA%Pa-pZ$%Y8e2&PQEx zzAeDZbtZkz(_V6JOU}!?k9E#XU2+!x3x#S-pLY(EoEd3GdAv)XcPx~gJ_|tkqgm&l zgh}GJ?ud(ie<2YR4r!#_7e!59K`l zHRc9bHRo=)#L;QZ0WTj@KFCi3vv%oMLC{}juE)aTR*0qS@};1?B}KtyMZ~gI`7*@F z?cKY&kw>$u#Hs7MA&Upo-+Fo$6buZ~;(r^Y$2w)5tJX5Wa>VE1q&e2lw{{(K1-{O1 z;-`8R6F<-@M3jp=DRmXfqi1=um zY}}Wl+TvargZ_5sn6F;7h3-GS02-7r7;T4)6Jmh+Xj^sM*R9&ZxQxMo5ChPxjKO4^ zY{J)ys2Xi|j{C+{TUeGc7!qOt+LkfEwnHX-gNUlhw(5j0rrN@xjKP=?0}x)uV7^T@ z>6=YdVcVS(z9ZEZu4N3SgcyJxWektELneLOh^qOv>ZI>swS{*XgBc+Ppnq8sd07%k z8G{AE_IIIk(wEA4^2eg(iz%30`@H(P>E`SD;1rwU%Ps6Fpy?W~&bP8t>9WK5vcqMv zW7V@jd3y;+HYS3J~BNzC!~CKKv_ z1?rK=Dl-(F@n0U7TolO#ac%S_bsU!oP1H$-uVcSqWV;%gwqyU~u8@)Kdibnad^+?9 zsT_*HjnJDkaOx!4evUSqi!B2mou1koyymz=t!Ih*uJo26wPCm;q(s2LF`JLd#Q0T% z(i{4c5?$4h^4qreIqp#E>2CTeCDHY!Ug>&S%58f)o9~kOJzl6%^3}@lSk;%69B(dV z3tV(mxcEac`EswXZdY&(Yu*++KZTW)L!%;^=JV4l>cLe^c|BPIz#&1ApJE!-sA+81 ziw63!;w&LDAKq6`#k5PGALy#TXt}!jnqBaM8~f%Dg-i;_W-AE`Zbl)4{JZFISP+e1 z#dETwJF)6PG&~hS7f`QSDX$nWo~M$s3?_%SK4%40ydVMHYbC$vAgXZfeEfwgWY2m2 z&>d#p`=j~IzVa^puk6*B3(szT6~koS|7EZlCVKbUSzLz>S>T<0q}vURAG%XvmGbnb z#d$+y0sI@vA~znKnc+4><(UrKUdE95^DiI|Gc>;1)=^;PK)V=Q9dbX>Ni2p<>(sJ{ zLQIZnt4C#s+*f=k*o{r|7@lm8m1SL9x*0?6Bi@Y_$cxCz;6 zF&*cA&N$^Chr=k@TJVr_SAyT+qM>XJU5s-F^2fm} zM7EylGUB6+-@z0}ww_c6(Te@Czxf4P_k$MElHj+$Ist7wjz%;E|JYlsfi`XrA{svV z?HwdS8&;wbb=V)fJ1A)L46RE|uHWvaA+-6EwoBFVkDYH2Xj31pOXVlOof8oBLwmGK zMf;EKgD)~48V6msCnv zy3tI`D`f|mxu^V+sKh3fboyEQSu_F;gi^P4C68Q76q1ej!zOI7Qh5VE z@_#tJ4DUCKLu*tb)dLZ@VH)WMP7R~gt$5A3xOd=6Pvw@t=S;cG?O9#IMIzKr)Bq-T z2^WY&J|$pXmvE^F^;7C#=Juj4;S!NZC+hZpdI4NvZpU>AR}f-=3V6#!BH`4e;Pwha z3_vb$`&5^3l?XLa1-z9akG1*FcHlV5zQdt`Zpz5 z#0;LWM4>L0w)Aj@`mQM6T1Sgbi?!eUyt27K4gR2H+o$!1PX(241=zQauVIdU?kF7L ztt#1=gEk+b`JhT+G5RSKc7$L0)P@}aXM2~D)!wl9S|)Q;xNky~mR^;rN^)5IpwST8 z^*J8-wA8q?S*lvgY4O8Z;~86~wbSXpNh+b zp{Memv1$YFLy5RMuRT=rs5qZozJ$DIs9ec7S{*AG@`n2+HHQgBkLW!U#omjfkXZ4c zmt;4o*`NI3JywU^9sPE-CPp}*YAu)MhUeE;Sl|F=baMm}1MwN_G>KA;zGiC^;P0>9$bHvwRxlh zx|Jh-HRQFRhKF8`<~6HWoVyB$tKs@c$SYChmsdG8u9!UMJyvGAF?|vn8YT>VIg+hO z`^41&smu&~OmQVN6e3m?m#t0hW_j;eiJ4)#YB)4RhOa}9LyOW;w+N}kO85OuY}iXF zu8ynO+7~?)HjfqAE-!mr2@947pNv?NGVz}amStGQWa*Fv@J_W}po(SJx!}V-)k+F> zwWOdaeI7){UvZ8M65C3CWvcBwpRnb5vJ;N1Y3o-g#vGbZ__OS33kMWK>Oja-m+WcN zO%$jyD#YP2$FyM)ioQfE1fjz*^Y9hwdJatp;%@egHm?`m$AOn{A&!{`o2Y9IQ7_$Z zaLlUVP**FpUbg-2x-v@h()ADftURyR<=%l{)IR&1%tbHSk5R#>g{(P9kr&Of zRCefco=bYgK7aPROy>ucx>UZ}wznE2xE6$1%PwCtoOEw=s>fH)ZW7Dwg%t=~L=CC6jD7qJPfDW`o^5R1?c_pSV*R zxQrxiw?qAZofA`&2vv--(zRinU<6Pk%1YCQah!l|QC7w_jAM-C5}|rgRt7eVlZ>JN zuXmEMOCmHb%F2=u1606kX2XbQB!`4r5o35pHApBX%F4lpaf+Y?r z!`KB09f`7XwPBnlsDKx4!#KxCE*Y9ljLk8sNroOqS$W$q&Jt9>>tVyVz!)kS+D42m zFm_3XItqv077kq^+WuWgCbuChTAO4_n`9E=`ZtB#rf!O-{c^OORC|66Q=n~SXGW@Q zs!VbtNoa#99J};r^7#4JV@rk;OUV;gBacSDhBf-RgKz|jQ0Cyk2->E+LYmrDYkp->h-urA6-2v&3rB#1-@S*#ic(O2POiaTVbndU;PdA6?rDzsI1`%XV!& zwlvgMB+rS%obtBDJw~NU+W052l`r00&2wgVB)LR&k5Qrbx88b8O<>+37yO3RcZWW8 zu>9w}tM)NfzIh|L&TP&{MG@*OvZM2H>(LFUF-)!ttIy|G8tN=Ep9l5qqg&ipNlhy-?~WVaocKalHY4a3ZrN$G3Ovh<#F~=G$okx5~$=Z%28u>W-0}nV0-vt zBx@>$L=0ryMbbOP!31TuiLl|filh(6kcgldyJ$a7aWZP0vk7^;vlwy5LS>7SlEI{= zC`UDcKh;uiE&Pt5M=>WAJ@A`~oT_hmOB6=dUh`|KIC4_bnI~@MsHEKd$R4-$ieJs+ zb`I6mC!rU)R1(=M&*`m)iON@PanM}0LS4*NPGRX?99|Cv3BIpu`T`}Y0kwQff1!S?6mf83`DV4G1c}h5Y5Dj}pFsY$s zD+%SMvO;y|m0e*KFg532&iP^LBXmrU&@an!Hk7RO~LNE&Adbn^Jwq@E&^}_~O!U z#kv69J+?P!irsm|2G1*dEHA+nyDf^1&bs@|9cc2c48?{g!+VTXVDi&I#U}IEJy0H+ z?9@WB`O)zH^;Iz0p}b;~mhS$wG4zFBY>F+aSN5-TfG_;|t?)svA{$zfB^|p@vkD{q zHK_1Gq#|3WB1<54pK=vV0`?^Vo033fNcfmZsJ@@4nm!M1I1f%e5A{9IXL_DW<~$Yi zd6zx*^9#QQbgBqV?y(1%0h+w(YdN#Szb<74ZB*Ti5AJ^+$`bxHlmRs@dSJhQ|1Tr> zPr*2bFI9($0f9gLPdvUM%mUxzGP??+YIlxTHV9YtO7|?kcRB0b8QM%2ilMsTjoA_G z-lmV&&wi-?9;@sR+Kgx2L;v-of&XFb7VMegmTu&6s$JcU?w^Zm)Ts2j|GT_rQ9!zh zE5d8_kRn;MJd&D^tGyT3Dhgoa9j@G7Tpbblxk&qP6{4c0k&%2{E4?_JsA$DMy#Q85 zMhb8#_YqpHhs8FQPH|cYGMq)hR8@E zuJ%6MB0&YbxqY~AqM}Wa)WjHoEs>hRk(xn~)I{5V2;w*#usm=$103!;aREO9%i}K! zz`&});ocBM1LBW=RRAWdRSR^LQdJkMl|JIa3Vd7LS(+VLeWLqv>ILlP`=%0#=64iL zr4&tNVNK;Qi%IAA+Xa)J?b{7Yo^vNNo|_?Z&P`7;Z`>tL*wL&ok58-B3pF;t&@J(g zp_>iny}b$y-QP$uB{}48eBh413G*ghJ6-tr?beA8-SY7v%-W=~vsO>O1B@SPZ?|7w zLLPp@d;j#8rD5`+bU!*U@%h#yOY`4v%jWSI4R@5*1fpk#HKmcuE6H|0{-=3D8_eBX z9kh>Ikw|IcNn&_%oZ&woKLT_2)iQkFv#pxae5UyL}9$<4LPrd~?2VSJJWN(zX_(%QWg!0lHzfV~J-M;#lMOP7Cb( z*^cfOx@sz~tzb{WvwX`*i_K}-kghPbVQehBU|-y);5DBXi{p2-Pq$KOl(6RDXe#}Bu_xe{Uq^tc2Tf`U08SNVlo*s_M8pMxSuv0 z&ncq8ZWq#CYMIPRi6ynFVeG&5!h}PZ@0?x42l!Hw-1kcI$B9#Y*L?AuLa@arF^#2G zN!*_+$;=y8acAxeB zvPwL8ym-u*Tb?#o0AmmK9*gSo&4(0mGGQkoH+4ANF1{AKcSG^}h05~^paXTbyGJJ@ zVKMT4aD^DM)i{b6Suc2NG|d=>RK`%an`G5kfd%~BhSX)JHHy9pxT%3Ex@gCy6q#WP zHka&6TO;Y;U`Rz#!d;*aVFs-WfZ4VJ)f?vY_EBSK)?XItE#p`B zJvzXwr}FB}10(zHt7w)(Hua{?k$u+_FbnuQm}(k)wx`xoKeF$90t16(z*NlOvlg|M zGEDY6Om;CQw-A$)kIBl#WMyNrGcnoem|Qd_Ck2z0gvok~$xXoI#$obfFnLj!oCr+L zYfNq!CN~6=AB@Qh!sI-|E#3;3q&w?7)h1KTO?$t@19 z=W|`M4QosfYs#Q#%A{z_qG-$xYs{H39}#%J8EWK#dmy zd^KtQCh4;;8RCDNzG#Jui-x({inVA!wN-+0q6 zX>~u9dOp4#TIsFM_U!p>ptFhf4OB9KMWUi5|Jmeq|6cX~-sJyL_5a@FQ~zG||K8;P zQT0MxD}98bzK+8k5DFi-4g6go)IPAnA~iz@{ZCl`sQ`ZqtcXa>*F+oO{5K^m(#+Lq zl_E^vW7Qqabysxeh0Y+`Agh)Ix#}x{I@P1zcfP}ozO8+}tuwy3?S?haxi1X}UvtT( zaXgturFta|2R&W!l+7W0mmuOFB^v@M2TYy6H=>f@n;}H=-?kc&UwEw zL{it{k3i%zrGJ)vA~(z*yr$d~_e)mRpNCDJAtp1bd#L+UY+NDxt;?Bj!-o1k#isDN zBk!a3a6>dq4IJu5wp-z{=JCZ)cTeRS1a6X>sqv=$r0s5E(_CCV)ZOd;7r~wd38p6Q zFfZG~XjzMd9w&DnJ;;8~h5%DDcj2V%X=;j;@%0d05~q>D*AhtaB$T zS>PJ>g0-PkKV>LBTNrx9E~1T}BblBAOJZ5`tq&B4&lPeyc=EcLKRZd_sFKX$OI;r` z$|Oe+Hk_{^XyV%AuE7Xv7<(9!cn9kdm#@M9#Pa_s=3JwaPPadvHQ6c4rke@gY8o>~ z%@P6)5uN^d$&?%#OHHl3L8(~a6@|*OX*9>uu~Y(0lboC>M?wchw9LFEiJE!ATPlKp z7cPp59CV$t&YWqjIWPZf?H7A}_h-L+_OpNcd4A7E=?T3vztg$5em?jt%gglSH$JDD zuATs(nzOhmS>VE(+e}X$2yrx*x)~t3`0Xi~hcq`#iahp5AG(8c1G;lhb5rg^GCS{m z?fErkkDJuh$VCX|-o9s_TJQC>=U35Rmf&1Xj?M1eemlc9S+=bRxyN8luoh`_W*^cd zX?~*ot+wo}qjCInBkrxX=%b?%EI(*H&eAb`eSMjhEo8buxBsk@fsW?4rpqG7yGBK2 z>%rMk4VzleI<0(~YzPW>N;AD#w)PNY`gq0R`{LB#zOROVbFDD{PJHLI-&eeJ*NVO0 zNp9cl+uIZA$^dZ1xA1;@$2?stx7`;f2lwq6JLvkyMy}*~k>8$SUDryj?+<)b|++esf_8+9mOHKVx~iOZD(QNo-M{kv!6c)zdx|J?dvP z@!pybg60DHg%=m&rqf7!mcYTV3*~y?oCCG<{794oY^nS3d+m!%kE8G z9_<4fFo6cSKv)9M!WXD>6sQ9P8Y}<|dI2ydz#&_Q>awDe`yEjD&skA-`|hMFWba> z9JFp8hbya13oAxtxupS_-KjPNWF)ppVx?pqc)fdU{uj%^EIz>|3Hh6Kv*Nh2=9^E@ zu_a3BVCLL&M9JM#nB)^XPM^!~UGu$yW`lSsFS(11Cj8ie@}+R6J7Z`NSXY;Mx+eyA zA`|6L77lgJ728AKyfjbuh`#&_3Kf_;`+jF^u`NjcbIDI94bm`LhsSQ2Z#|h5D3o%w z{e7>w$NM#RaJ7AU*SN#ZVb)t%oqDqVDZMTWlEKyW^3^(_V~^1?6TdGqdPskBKl>DS zlbf%W8_W>1VPAw-k?9ZgR~g=4a`l{g*SZpx&|6Hb+6ztN=x@>)@7s;-eAl_S_oFu& zh`kEoXnIqc-o19#yQn=heG0dKt8ywf=!qV-biX&d6ol3NE7NbD7LI8%=*>+8(k z!7-u|6w)YRp*7QmVmniRoz@16?iX};8pn*3?r?eJAdoqQt>atPlI_Pv_tH4FN%cLB zwmNIfIMDd&9!IFbQ0RufQpddY!R2ehAyMzNOM9G-SmcLlbyzy)8vS4SIy7UtbvxO| z31o3TbVG~CF~{ob@-KqDqgpqm^?ZBSZ%^pf*QHJmO}{Ar;yh!zMK7`EnDynMkd0L$ z#|KwoX8rFrLUCLc`Kkr2uSo#8+MGnbYCz+?af4oY1t&-8(E97lp;5i6JpAJRe%3}P zwwIL`Gg&SXO%-7ayc{Af^cXhO>GJ-;oF-@}L>2;} zhs5ARyul%QvS2-WFa#eA0SCv(g1qTLdiWqca8QiwVhsHv1Aj3ae9>EW!JB>|27e(2 ze1Rc5pG`mSjX&=VKF^Q^GU$N{eBcLgV74qEn;yWx2Qa_^3Yq^0x_>s_KO5{n(C_3= zR97IpG~U=z<|H0zvOF|Ub>nG|UgA|nlmtC%bI!hRFIITrxzK4!sAWB=g`M2{d@{Q` zx^I#xh~`bN)_YZqQNjfz@Xt+p^LuK;pUb~y{-T(rK!&)S7w5lCbRfDDTdjgf4%9y@ z{qWcPAxz^dRL1Swoch=Nk(u(Dd1V~XW_IW3=y3V$bbLJU@9&)buXC~gvG`S5<7pzh zb%eHB3W(0vxStZ*Dk-4fSKJ^%+j|P=1%I>1ZXcnokpg1yH;ezpGWcm?yFx^k9H&59mucp=T)28e?hU`#7cCS~l z&x9=$kj9KCpj{Nu`c?Z}(L^<7MFE+vVjA*uMHAH+oB}$sifPEdC{`3)`<6#0hMdEX z+#>}`jrddtc#?g*Ey2q09b=-Q?b&nj^(nEFwZsW4x$s=VI1@YhtZJrV23cNrd9<-yYAE1-jA{6 z>N@v6c6I*}b8GLfdy1@X(AQ@u=G%b|zK>npr_rfK5e0?tt90%3?8^4-klsRP!h3Wk z!0M~QBNyq~X^OaZh%so*7g5ACi)^z5BvWG;dG5k;dM zmC16 z*x9)9>yeP!ce)Ip>kysBP_2*QL%CbdmM35Gc6_(C*ykD;_Cx4~_u<1irncobLcMES zb+db}+xWSLZfw+ytaj;_-@3?fY&A~tNj~KMkI;>^n(36){O`8|KGe2skLl5z5yp5{ z=Iw|aFCy5Dd3#o5c0`P3E!vJjJgZVOBS&r$Y=`wc|42qf4$&8(0)(qz5~mZ5x^?FcPYB>ZfJYdATqHWSrte%-kLJddgH^%8c-&-HGHBa9Ni+CXf8!J zTTV1tqMO1e8pF|zqKUVq=(m;=4VLHz(Zm}O`c1f?-V#$^I`O&`{aQ5fN`!tDE~vA_ z)Rj)umZEFJ1?+GPTO_C{#ne~|Se6)8xS%>5Q!Nrym13$a11(wD2~sM;SgLL~X^FFl zL|me4Po5IPEe=ASJTrKrzUP$9gsL9-_2Q`FGVa4 zT9Z`ccN*=LvzmvARZ{7oN}}}p7KRKU%15BqHHpj0aXF*2_|a>Md0@ n+ha{!ma^4zh{Y=Pw1}-*3RBBs)zhO})g}eEL++ct+Og)J7U!^0 literal 0 HcmV?d00001 diff --git a/research/coded-active-feedback/SOURCES.json b/research/coded-active-feedback/SOURCES.json new file mode 100644 index 0000000000..d31da7727d --- /dev/null +++ b/research/coded-active-feedback/SOURCES.json @@ -0,0 +1,42 @@ +{ + "base_commit": "ec2780e8aeb1c88acaf5e9e470ef8c68e7fbbb6c", + "files": [ + { + "git_blob": "c35482cd9035843b15a634cc8276a7e1e40e8395", + "path": "certificates/selected-result.json", + "sha256": "6fe0a099b89aa2aed796a13c3a21dafc63f3388ebf397464e44e0451893b9375", + "usage": "provenance" + }, + { + "git_blob": "f126dd2e2dad2b669e75d1d0d0bd05c600725602", + "path": "docs/research/agent-task-catalog.json", + "sha256": "f7a48bfa2659b88378282a8eee7d9fe52cdf505594124c4d1686b58510fffd72", + "usage": "provenance" + }, + { + "git_blob": "44ae72b314cccf677b44d75c374be6dcac1c8167", + "path": "research/coded-native-caller/gauge.py", + "sha256": "390391d291353741c89daea999d483660ca185987ed96a15b82576280c487cad", + "usage": "input" + }, + { + "git_blob": "bee0ff7c400dd91dc7d05f893c7a211a28f7028f", + "path": "research/passive-saved-query-ceiling/evidence/frozen/pr4948-mixed-thin-gate/check.py", + "sha256": "fe7db972d7ae238b21f8a453c21243360d131d728a76b91a469dacf447629582", + "usage": "input" + }, + { + "git_blob": "513be55ff4c630dda408244223a0bfed6b76ad49", + "path": "research/passive-saved-query-ceiling/evidence/frozen/pr4948-saved-query-macro-gate/bank_span.py", + "sha256": "55c5d1761812d847188fa893988decc491a40151ad45f3fb806e7f8c3337229d", + "usage": "input" + }, + { + "git_blob": "9db00720d92638b5b7f212412f139b354d3cf42e", + "path": "research/native-involutive-dual/PROOF.md", + "sha256": "9dcfdec3a4e4d97d30eecc173976f1561ff7b1742b2c73d25b9e197ca9ece9de", + "usage": "input" + } + ], + "schema_version": 1 +} diff --git a/research/coded-active-feedback/TASK.json b/research/coded-active-feedback/TASK.json new file mode 100644 index 0000000000..6c629f059d --- /dev/null +++ b/research/coded-active-feedback/TASK.json @@ -0,0 +1,114 @@ +{ + "actual_scope": "Two active feedback edges in the PR4948 p2 caller: recover one missing original-input coefficient, calculate its remaining full-input coupling, and search an explicit finite formal decoder domain.", + "ai_assistance": "Substantial OpenAI Codex assistance; no subagents or independent human review.", + "author": "Cinna Davis, with substantial OpenAI Codex assistance", + "base_commit": "ec2780e8aeb1c88acaf5e9e470ef8c68e7fbbb6c", + "bottleneck_link": "Avoid adding the standalone 112-call code repair by sharing already-paid query responses. The component escapes the passive invariant but remains nonautonomous.", + "budget_minutes": 60, + "coordination": { + "claim": "https://github.com/CrocSwap/integer-mult-bounds/discussions/4930#discussioncomment-19145683", + "overlap": { + "discussions": 4395, + "fetched_utc": "2026-10-23T12:25:56Z", + "limits": "Titles, bodies and indexed local notes; not arbitrary diffs or unpublished work.", + "open_prs": 315, + "tracked_local_notes": 6996 + }, + "scope_update": "https://github.com/CrocSwap/integer-mult-bounds/discussions/4930#discussioncomment-19145848" + }, + "evidence": "PROOF.md, RESULT.json, SEARCH.json.gz, verify.py and search.py", + "open_questions": [ + { + "blocked_by": "No such full caller is supplied; the current coupling is nonzero at all positive widths.", + "first_step": "Give an exact all-four-input replacement for the row in PROOF.md and charge every new query and boundary.", + "question": "Can the explicit second-input coupling be removed at a favorable complete bill?", + "why_it_matters": "Only autonomous main jobs can enter the productive inventory." + }, + { + "blocked_by": "No additional physical relation or broader control family has been constructed.", + "first_step": "State one additional source-bound relation or port-dependent control and test a complete all-input identity.", + "question": "Does an additional physical source relation evade the declared formal search?", + "why_it_matters": "The universal formal algebra is not asserted faithful to all physical identities." + } + ], + "original_card": { + "acceptance_gate": "Name the changed premise of the fixed F0/B1 observation obstruction. Show exactly which query is recovered, legal native reads and restoration, and a full favorable budget including cover maps, helpers and endpoints. Local inverse identities alone do not close the global controller. 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.", + "allowed_variations": [ + "One paid query, one changed first pair, or one precisely specified affine helper state.", + "A counterexample or lower bound for that exact proposed repair.", + "One unresolved obligation of a newer local decoder, with exact source heads and a distinct claim/domain." + ], + "bottleneck_link": "The native local words exist; retained query information and its physical access are the missing link to a composed recursive interface.", + "existing_checks": [ + { + "evidence": "research/qq16-caller-install/README.md", + "remaining": "Complete matched physical protocol bill, or changed source-compatible demand/circuit; no affordable supplier yet.", + "scope": "PR #4166: author-checked installed producer/service/return/bridge connection; native-component comparison loses.", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129", + "source_commit": "0b082d22a0e9a442d264ab0633e35ef26c790630", + "status": "author-checked" + } + ], + "first_experiment": "At the actual installed cut, compare matched complete parent park/restore and external input/return protocols at the same bank/packet geometry, including every later root call and service cost. Alternatively pin both bridge observations and derive a genuinely smaller source-compatible demand. Stop if the complete necessary inequality fails or an essential cost is unknown; no larger decoder scan from a local tape-action saving.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read #4166 COST.md and ADMISSION.json. An actual caller connection is now proposed. Its native-component profile loses; parent park/restore versus external-call costs remain unresolved. Retain the producer and recovery lineage rather than rebuild it.", + "scope": "Source-binding orientation only; no scientific replay, theorem acceptance or supplier admission. Budget any heavy replay separately." + }, + "id": "joint-query-controller", + "methods": [ + "Derive the matched whole-caller physical bill for installed and baseline protocols.", + "Change the actual demanded observations and prove a cheaper legal producer/consumer contract." + ], + "overlap_terms": [ + "QQ16", + "joint-query", + "changing-chart controller", + "selected observation", + "1969", + "2540", + "early record", + "output-bank retention", + "complete native decoder", + "2965", + "producer defect", + "dirty-helper range", + "F17 consumer", + "4166", + "qq16-caller-install" + ], + "question": "Can the installed QQ16 caller win a complete matched protocol bill, or can a changed demand eliminate actual paid work?", + "scope_change_triggers": [ + "Retaining the fixed first pair and ordinary schedule while allowing only homogeneous selected-only control, already excluded by the witness.", + "Treating cover-map counts as zero-cost physical address operations.", + "Recreating the pending complete local decoder or early-record/output-bank coalescing already under investigation without a distinct audit or changed premise.", + "Treating a completed-output defect inequality as a producer-interior, dirty-range or physical-cost certificate.", + "Recreating completed-output recovery or caller wiring already supplied by #4166 without new independent coverage.", + "Dropping retained later root calls or claiming native-profile dominance from the isolated publication saving." + ], + "starting_points": [ + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "research/qq16-caller-install/README.md" + ] + }, + "outcome": "partial", + "priority_revision": 7, + "related_open_work": [ + { + "head": "40bb94aebbf591a99e2f48533f16efe8914fb1e2", + "pr": 5200, + "scope_difference": "Two FULLs with dirty identity workspace; this experiment retains three added paid query banks and owned captures, and recovers no autonomous new job." + } + ], + "schema_version": 1, + "scope_change_reason": "The card predates the involutive coded producer. Standalone eight-mode extraction and unchanged-input passive recovery are already covered; this changes two actual paid query inputs.", + "scope_status": "changed", + "stop_rule": "Stop this grammar after the exact full-row obstruction and the declared 8281-policy search; another construction round must change a feedback source, physical relation, control alphabet or endpoint and give a complete budget.", + "task_id": "joint-query-controller" +} diff --git a/research/coded-active-feedback/VALIDATION.md b/research/coded-active-feedback/VALIDATION.md new file mode 100644 index 0000000000..f5fdd9139d --- /dev/null +++ b/research/coded-active-feedback/VALIDATION.md @@ -0,0 +1,40 @@ +# Executed validation and remaining obligations + +Local verification on 2026-10-23 used CPython 3.12.15, standard library only. + +Passed: + +```sh +python3.12 -B scripts/research_package.py --package research/coded-active-feedback --check-only +python3.12 -B scripts/research_package.py --package research/coded-active-feedback +``` + +The registered replay executed the normal isolated, warning-strict verifier +with `--full-search`, followed by its optimized component/pilot verifier. +Every one of the 8,281 regenerated policy records and exact basis dimensions +matched the decompressed receipt. Both modes passed the component identity, +four-input contamination formula, binomial/recurrence coupling-rank checks, +196 directly verified pilot certificates, normal-form fixtures, source hashes, +and positive/corruption controls. No package source or receipt changed. + +The initial full search and the registered replay are separate completed runs; +the optimized replay does not repeat the full 8,281-case synthesis. Gzip +payloads are compared as parsed JSON, including all proof-relevant fields. + +Canonical main was refreshed before submission and remained +`ec2780e8aeb1c88acaf5e9e470ef8c68e7fbbb6c`. Priority revision 7 and the +selected conditional kappa 0.00302015 were unchanged. The submission overlap +refresh completed at 12:49:20 UTC: 334 open PRs, 4,438 Discussion records, +and complete coverage of the 6,996 tracked local notes, plus this untracked +package's two indexed notes. Coverage is titles/bodies and indexed notes, +not arbitrary diffs or unpublished work. Related PR5200 is scoped in README. + +This validates the stated component and bounded formal experiment. It does +not independently validate the source native ABI, physical phase conventions, +all-width helper contracts, a complete changed caller, scalar tape tariff, +rounding, compiler, BIT, outer transfer or a multiplication theorem. There is +no autonomous new job or new kappa. Human and proof-kernel review are absent. + +Committed-byte/source-history preflight and portable-export replay are +reported separately in the PR after the commit exists. Hosted status is +likewise reported there only after observing the exact published head. diff --git a/research/coded-active-feedback/VERIFY.json b/research/coded-active-feedback/VERIFY.json new file mode 100644 index 0000000000..23463e4024 --- /dev/null +++ b/research/coded-active-feedback/VERIFY.json @@ -0,0 +1,40 @@ +{ + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-W", + "error", + "-B", + "{package}/verify.py", + "--full-search" + ], + "checks": "Four source hashes, complete active output row, retained nonzero coupling, rank counts through width64, uncoded positive and corruption controls, 196 direct pilot certificates, all8281 full-search policies/ranks.", + "timeout_seconds": 600 + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-W", + "error", + "-B", + "{package}/verify.py" + ], + "checks": "Same complete component and 49-policy certified pilot under optimization; full receipt domain/digest is checked without repeating the8281-policy synthesis.", + "timeout_seconds": 120 + } + ], + "inputs": [ + "research/coded-native-caller/gauge.py", + "research/passive-saved-query-ceiling/evidence/frozen/pr4948-mixed-thin-gate/check.py", + "research/passive-saved-query-ceiling/evidence/frozen/pr4948-saved-query-macro-gate/bank_span.py", + "research/native-involutive-dual/PROOF.md" + ], + "python": "3.12", + "requirements": [], + "schema_version": 1, + "status": "ready" +} diff --git a/research/coded-active-feedback/search.py b/research/coded-active-feedback/search.py new file mode 100644 index 0000000000..60de5a87d3 --- /dev/null +++ b/research/coded-active-feedback/search.py @@ -0,0 +1,335 @@ +#!/usr/bin/env python3 +"""Bounded active-query synthesis in a declared universal operator algebra. + +Prepared by Cinna Davis with substantial OpenAI Codex assistance. Apache-2.0. +The symbolic algebra is a sufficient identity model, not a faithful model of +every additional relation in the physical source. +""" +from collections import Counter +from fractions import Fraction as F +from hashlib import sha256 +import argparse +import json +from pathlib import Path +import sys +import types + +sys.dont_write_bytecode = True +HERE = Path(__file__).resolve().parent +ROOT = HERE.parent.parent + + +def need(ok, message): + if not ok: + raise ValueError(message) + + +def reduce_word(word): + """Normal form in C4(Q) * C2(C1) * C2(C3).""" + out = [] + for letter in word: + if abs(letter) in (2, 3): + letter = abs(letter) + if out and out[-1] == letter: + out.pop() + else: + out.append(letter) + else: + need(abs(letter) == 1, 'Unknown formal generator') + exponent = letter + while out and abs(out[-1]) == 1: + exponent += out.pop() + exponent %= 4 + out.extend((1,) * exponent if exponent <= 2 else (-1,)) + return tuple(out) + + +def algebra(): + path = ROOT / 'research/coded-native-caller/gauge.py' + raw = path.read_bytes() + need(sha256(raw).hexdigest() == + '390391d291353741c89daea999d483660ca185987ed96a15b82576280c487cad', + 'Changed inherited group-algebra engine') + module = types.ModuleType('feedback_inherited_gauge') + module.__file__ = str(path) + exec(compile(raw, str(path), 'exec'), module.__dict__) + module.reduce_word = reduce_word + return module.Algebra(2) + + +def words(length): + return [()] + [tuple(2 + ((j + start) % 2) for j in range(n)) + for n in range(1, length + 1) for start in range(2)] + + +def scaled(a, scalar, row): + return [a.mul(a.term((), (0, 0), scalar), entry) for entry in row] + + +def replay(a, feedback1, feedback2, coefficient1=1, coefficient2=1, + codes=True): + q, qi = a.gen(1), a.inv(a.gen(1)) + c1, c3 = (a.gen(2), a.gen(3)) if codes else (a.one, a.one) + d1, d3 = a.D(0), a.D(1) + rows = [[a.one if i == j else {} for j in range(4)] for i in range(4)] + observed = [] + responses = [] + + def snap(label): + observed.extend((label + ':' + str(i), list(row)) + for i, row in enumerate(rows)) + + def plus(dst, src, op): + rows[dst] = [a.add(x, a.mul(op, y)) + for x, y in zip(rows[dst], rows[src])] + + def left(index, op): + rows[index] = [a.mul(op, entry) for entry in rows[index]] + + def query(pair, argument, label, after=None): + response = [a.mul(qi, entry) for entry in argument] + observed.append((label, response)) + responses.append(response) + rows[2 * pair + 1] = [a.add(x, a.mul(after or a.one, y)) + for x, y in zip(rows[2 * pair + 1], response)] + return response + + def full(pair, code, stage): + plus(2 * pair, 2 * pair + 1, a.neg(a.mul(q, code))) + left(2 * pair, stage) + left(2 * pair + 1, stage) + + def bridge(dst, src, sign): + plus(2 * dst, 2 * src, scaled(a, sign, [a.one])[0]) + plus(2 * src + 1, 2 * dst + 1, scaled(a, -sign, [a.one])[0]) + + rows[0][2], rows[3][1] = a.neg(a.one), a.one + snap('right') + query(0, rows[0], 'response0', c1) + snap('query0') + full(0, c1, d1) + snap('FULL1') + late_y = list(rows[1]) + left(2, d1) + left(3, d1) + snap('IDLE') + bridge(0, 1, 1) + argument = [a.add(a.mul(c1, x), a.mul(feedback1, y)) + for x, y in zip(rows[0], scaled(a, coefficient1, late_y))] + response2 = query(0, argument, 'response2') + snap('bridge_query2') + bridge(0, 1, -1) + snap('bridge_minus') + full(1, c3, d3) + snap('FULL3') + argument = [a.add(a.mul(c3, x), a.mul(feedback2, y)) + for x, y in zip(rows[2], scaled(a, coefficient2, response2))] + query(1, argument, 'response4') + snap('query4') + bridge(1, 0, 1) + for x, y in ((0, 1), (2, 3)): + rows[x], rows[y] = rows[y], [a.neg(entry) for entry in rows[x]] + plus(0, 2, a.one) + plus(3, 1, a.neg(a.one)) + snap('left') + targets = [a.mul(d1, qi), a.mul(d1, q), + a.mul(d3, d1, qi), a.mul(d3, d1, q)] + targets = [[target if i == j else {} for j in range(4)] + for i, target in enumerate(targets)] + return observed, targets, rows + + +def vector(row): + return {(source, word, powers): value + for source, entry in enumerate(row) + for (word, powers), value in entry.items() if value} + + +def axpy(x, scalar, y): + out = dict(x) + for key, value in y.items(): + out[key] = out.get(key, F(0)) + scalar * value + if not out[key]: + del out[key] + return out + + +class Span: + def __init__(self, a, controls): + self.a, self.controls = a, controls + self.basis, self.generators = {}, [] + + def clone(self): + out = Span(self.a, self.controls) + out.basis, out.generators = dict(self.basis), list(self.generators) + return out + + def add(self, label, row): + a, basis, generators = self.a, self.basis, self.generators + for word in self.controls: + op = a.term(word, (0, 0)) + value = vector([a.mul(op, entry) for entry in row]) + index = len(generators) + generators.append((label, word)) + recipe = {index: F(1)} + while value: + pivot = min(value) + if pivot not in basis: + factor = 1 / value[pivot] + basis[pivot] = ({key: v * factor for key, v in value.items()}, + {key: v * factor for key, v in recipe.items()}) + break + base, base_recipe = basis[pivot] + factor = value[pivot] + value = axpy(value, -factor, base) + recipe = axpy(recipe, -factor, base_recipe) + + def test(self, targets, certificate=False): + basis, generators = self.basis, self.generators + results = [] + for row in targets: + value, recipe = vector(row), {} + while value: + pivot = min(value) + if pivot not in basis: + break + base, base_recipe = basis[pivot] + factor = value[pivot] + value = axpy(value, -factor, base) + recipe = axpy(recipe, factor, base_recipe) + answer = {'attained': not value, + 'recipe': [{'observation': generators[i][0], + 'word': list(generators[i][1]), + 'coefficient': str(v)} + for i, v in sorted(recipe.items())] if not value else None, + 'residual_terms': len(value)} + if value and certificate: + functional = {min(value): F(1)} + for pivot, (base, _) in sorted(basis.items(), reverse=True): + v = -sum(coefficient * functional.get(key, 0) + for key, coefficient in base.items() if key != pivot) + if v: + functional[pivot] = v + else: + functional.pop(pivot, None) + need(all(sum(v * functional.get(key, 0) for key, v in base.items()) == 0 + for base, _ in basis.values()), 'Dual annihilates basis') + pairing = sum(v * functional.get(key, 0) for key, v in vector(row).items()) + need(pairing != 0, 'Dual separates failed target') + answer['dual'] = [[i, list(w), list(d), str(v)] + for (i, w, d), v in sorted(functional.items())] + answer['target_pairing'] = str(pairing) + results.append(answer) + return {'dimension': len(basis), 'results': results} + + +def span(a, observations, targets, controls): + out = Span(a, controls) + for label, row in observations: + out.add(label, row) + return out.test(targets) + + +def verify_answer(a, observations, target, controls, answer): + """Direct dot products/recipe replay, independent of elimination pivots.""" + if answer['attained']: + rows = dict(observations) + value = {} + for term in answer['recipe']: + op = a.term(term['word'], (0, 0), F(term['coefficient'])) + value = axpy(value, 1, vector([a.mul(op, entry) + for entry in rows[term['observation']]])) + need(value == vector(target), 'Positive recipe directly reproduces target') + else: + dual = {(i, tuple(w), tuple(d)): F(v) for i, w, d, v in answer['dual']} + for _, row in observations: + for word in controls: + op = a.term(word, (0, 0)) + value = vector([a.mul(op, entry) for entry in row]) + need(sum(v * dual.get(key, 0) for key, v in value.items()) == 0, + 'Dual directly annihilates every declared generator') + pairing = sum(v * dual.get(key, 0) for key, v in vector(target).items()) + need(pairing == F(answer['target_pairing']) != 0, + 'Dual directly separates target') + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--length', type=int, default=3) + parser.add_argument('--decoder-length', type=int, default=7) + parser.add_argument('--coefficients', default='1') + parser.add_argument('--certificates', action='store_true') + parser.add_argument('--output', type=Path) + args = parser.parse_args() + need(0 <= args.length <= 7 and 0 <= args.decoder_length <= 7, + 'Declared bounded word lengths are zero through seven') + a = algebra() + c1, c3, q = a.gen(2), a.gen(3), a.gen(1) + need(a.mul(c1, c1) == a.one and a.mul(c3, c3) == a.one, + 'Code involutions') + need(a.mul(q, q, q, q) == a.one, 'Actual Gaussian fourth power') + need(a.mul(c1, a.D(0), q) == a.mul(a.D(0), q, c1), + 'Own full-Gaussian commutator') + need(a.mul(c1, a.D(0)) != a.mul(a.D(0), c1), + 'Own partial-Gaussian noncommutation') + controls = words(args.decoder_length) + # The Q^2 factor is a physically free Pauli, required to turn Q^-1 + # response2 into Q response2 before the second transverse query. + controls += [reduce_word(w + (1, 1)) for w in words(args.decoder_length)] + controls = list(dict.fromkeys(controls)) + coefficients = [F(value) for value in args.coefficients.split(',')] + need(len(coefficients) == len(set(coefficients)) and all(coefficients), + 'Distinct nonzero feedback coefficients') + choices = [(None, F(0))] + [(word, coefficient) + for word in words(args.length) for coefficient in coefficients] + cases, best, histogram = [], 0, Counter() + for v1, coefficient1 in choices: + op1 = {} if v1 is None else a.term(v1, (0, 0)) + fixed, targets, _ = replay(a, op1, {}, coefficient1, 0) + third_index = next(i for i, (label, _) in enumerate(fixed) if label == 'response4') + before_third = fixed[:third_index] + base = Span(a, controls) + for label, row in before_third: + base.add(label, row) + for v2, coefficient2 in choices: + op2 = {} if v2 is None else a.term(v2 + (1, 1), (0, 0)) + observed, targets, _ = replay(a, op1, op2, coefficient1, coefficient2) + response4 = observed[third_index] + need(response4[0] == 'response4', 'Last paid response index') + bounded = before_third + [response4] + candidate = base.clone() + candidate.add(*response4) + result = candidate.test(targets, args.certificates) + if args.certificates: + for target, answer in zip(targets, result['results']): + verify_answer(a, bounded, target, controls, answer) + score = sum(entry['attained'] for entry in result['results']) + histogram[str(score)] += 1 + row = {'feedback1': v1, 'feedback2_before_Pauli': v2, + 'coefficient1': str(coefficient1), 'coefficient2': str(coefficient2), + 'attained': [entry['attained'] for entry in result['results']], + 'basis_dimension': result['dimension']} + if score > best: + best = score + print(json.dumps({'new_best': row}), flush=True) + if score >= 2 or args.certificates: + row['recipes'] = result['results'] + cases.append(row) + receipt = {'status': 'FINITE_FORMAL_FEEDBACK_SEARCH', + 'feedback_length': args.length, 'decoder_length': args.decoder_length, + 'decoder_controls': [list(word) for word in controls], + 'feedback1_source': 'saved_FULL1_Y', + 'feedback2_source': 'modified_response2', + 'feedback2_Pauli': 'Q^2 before the code word', + 'original_query_input_coefficients': ['1', '1'], + 'coefficients': [str(v) for v in coefficients], 'cases': cases, + 'attainment_histogram': dict(sorted(histogram.items())), + 'maximum_attained_jobs': best, + 'physical_emission': False, 'new_kappa': None} + if args.output: + args.output.write_text(json.dumps(receipt, indent=2, sort_keys=True) + '\n') + print(json.dumps({key: value for key, value in receipt.items() if key != 'cases'})) + + +if __name__ == '__main__': + main() diff --git a/research/coded-active-feedback/verify.py b/research/coded-active-feedback/verify.py new file mode 100644 index 0000000000..b7822d6045 --- /dev/null +++ b/research/coded-active-feedback/verify.py @@ -0,0 +1,161 @@ +#!/usr/bin/env python3 +"""Exact active coefficient, retained coupling, and bounded search replay. + +Cinna Davis, with substantial OpenAI Codex assistance. Apache-2.0. +""" +import argparse +import gzip +from hashlib import sha256 +import itertools +import json +import math +from pathlib import Path +import subprocess +import sys +import tempfile +import types + +sys.dont_write_bytecode = True +HERE = Path(__file__).resolve().parent +ROOT = HERE.parent.parent +m = types.ModuleType('active_feedback_search') +m.__file__ = str(HERE / 'search.py') +exec(compile((HERE / 'search.py').read_bytes(), m.__file__, 'exec'), m.__dict__) + + +def canonical(value): + return json.dumps(value, separators=(',', ':'), sort_keys=True).encode() + + +def serialized(row): + return [[[list(w), list(d), str(v)] for (w, d), v in sorted(entry.items())] + for entry in row] + + +def rejected(action): + try: + action() + except ValueError: + return + raise ValueError('Corrupt certificate accepted') + + +def run_search(directory, full=False): + out = Path(directory) / ('full.json' if full else 'pilot.json') + flags = ['-O'] if sys.flags.optimize else [] + command = [sys.executable, '-I', *flags, '-B', str(HERE / 'search.py'), + '--length', '7' if full else '1', + '--decoder-length', '7' if full else '3', + '--coefficients=-2,-1,-1/2,1/2,1,2' if full else '--coefficients=-1,1', + '--output', str(out)] + if not full: + command.append('--certificates') + subprocess.run(command, capture_output=True, text=True, check=True, timeout=540) + return json.loads(out.read_text()) + + +def run(full=False): + sources = json.loads((HERE / 'SOURCES.json').read_text()) + inputs = [entry for entry in sources['files'] if entry['usage'] == 'input'] + m.need(len(inputs) == 4, 'Four source inputs') + for entry in inputs: + m.need(sha256((ROOT / entry['path']).read_bytes()).hexdigest() == entry['sha256'], + 'Changed inherited source: ' + entry['path']) + a = m.algebra() + q, c, e = a.gen(1), a.gen(2), a.gen(3) + qi, d, f = a.inv(q), a.D(0), a.D(1) + m.need(a.mul(q, q, q, q) == a.one and a.mul(q, q) != a.one, 'Q has order four') + m.need(a.mul(c, c) == a.one and a.mul(e, e) == a.one, 'Source involutions') + m.need(a.mul(c, d, q) == a.mul(d, q, c), 'Own DQ commutation') + m.need(a.mul(c, f) == a.mul(f, c), 'Other-stage D commutation') + m.need(a.mul(c, d) != a.mul(d, c) and a.mul(c, q) != a.mul(q, c), + 'Forbidden commutations remain absent') + fixtures = 0 + for n in range(5): + for word in itertools.product((-3, -2, -1, 1, 2, 3), repeat=n): + reduced = m.reduce_word(word) + m.need(m.reduce_word(reduced) == reduced, 'Reduction idempotence') + for k in range(n + 1): + m.need(m.reduce_word(m.reduce_word(word[:k]) + m.reduce_word(word[k:])) == reduced, + 'Concatenation normal form') + fixtures += 1 + observed, targets, _ = m.replay(a, a.one, a.mul(c, q, q)) + row = dict(observed)['query4:3'] + coupling = a.mul(qi, c, q, a.add(a.one, a.neg(q)), d) + expected = [a.mul(d, qi), coupling, + a.add(a.mul(a.add(a.mul(qi, c, q, c), a.neg(qi)), d), + a.mul(qi, e, d, f)), {}] + m.need(row == expected, 'All four original-input coefficients') + m.need(row[0] == targets[0][0] and coupling and row != targets[0], + 'Recovered coefficient is not an autonomous output') + for first, second in (({}, {}), (a.one, c), (a.one, a.mul(e, q, q))): + variant, _, _ = m.replay(a, first, second) + m.need(dict(variant)['query4:3'][0] != targets[0][0], + 'Unchanged input / omitted Pauli / wrong stage code must fail') + _, plain_targets, plain_rows = m.replay(a, {}, {}, codes=False) + m.need(plain_rows == plain_targets, 'Full uncoded four-job positive control') + residues = [1, 0, 0, 0] + coupling_ranks = [] + for width in range(1, 65): + residues = [residues[k] + residues[(k - 1) % 4] for k in range(4)] + b0 = sum(math.comb(width, k) for k in range(0, width + 1, 4)) + m.need(b0 == residues[0], 'Independent central eigenvalue count') + if width <= 12: + m.need(sum(x.bit_count() % 4 == 0 for x in range(1 << width)) == b0, + 'Direct central frequency enumeration') + rank = 112 * (1 << (16 * width)) * ((1 << width) - b0) + m.need(rank > 0, 'Coupling at every checked positive width') + coupling_ranks.append({'width': width, 'central_eigenvalue_one': b0, + 'complex_rank': str(rank)}) + retained = json.loads(gzip.decompress((HERE / 'SEARCH.json.gz').read_bytes())) + choices = [(None, '0')] + [(list(w), z) for w in m.words(7) + for z in ('-2', '-1', '-1/2', '1/2', '1', '2')] + policies = {(json.dumps(w1), z1, json.dumps(w2), z2) + for (w1, z1), (w2, z2) in itertools.product(choices, repeat=2)} + actual = {(json.dumps(x['feedback1']), x['coefficient1'], + json.dumps(x['feedback2_before_Pauli']), x['coefficient2']) + for x in retained['cases']} + m.need(len(actual) == len(retained['cases']) == 8281 and actual == policies, + 'Exact full search policy domain') + m.need(all(x['attained'] == [False, True, False, False] for x in retained['cases']) + and retained['attainment_histogram'] == {'1': 8281}, 'Retained search outcome') + with tempfile.TemporaryDirectory(prefix='active-feedback-') as tmp: + pilot = run_search(tmp) + m.need(len(pilot['cases']) == 49 and pilot['attainment_histogram'] == {'1': 49}, + 'Forty-nine exact certified pilot policies') + baseline = pilot['cases'][0]['recipes'] + obs, t, _ = m.replay(a, {}, {}) + controls = [tuple(w) for w in pilot['decoder_controls']] + rejected(lambda: m.verify_answer(a, obs, t[0], controls, + dict(baseline[0], target_pairing='0'))) + rejected(lambda: m.verify_answer(a, obs, t[1], controls, + dict(baseline[1], recipe=[]))) + if full: + m.need(run_search(tmp, full=True) == retained, 'Every full-search policy and rank') + print('PASS_FULL_ACTIVE_FEEDBACK_SEARCH 8281 policies') + return {'status': 'PASS_ACTIVE_FEEDBACK_COMPONENT_AND_CERTIFIED_PILOT', + 'normal_form_fixtures': fixtures, 'complete_active_output_row': serialized(row), + 'coupling_ranks': coupling_ranks, + 'pilot_policies': 49, 'direct_span_certificates': 196, + 'pilot_canonical_sha256': sha256(canonical(pilot)).hexdigest(), + 'full_search_policies': 8281, + 'full_search_canonical_sha256': sha256(canonical(retained)).hexdigest(), + 'autonomous_Gaussian_job': False, 'physical_impossibility_claim': False, + 'new_kappa': None} + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--write', action='store_true') + parser.add_argument('--full-search', action='store_true') + args = parser.parse_args() + result = run(args.full_search) + if args.write: + (HERE / 'RESULT.json').write_text(json.dumps(result, indent=2, sort_keys=True) + '\n') + else: + m.need(json.loads((HERE / 'RESULT.json').read_text()) == result, 'Changed result receipt') + print(result['status']) + + +if __name__ == '__main__': + main()