Skip to content

feat(ExactTriangle): implement native cyclic-Strassen modular counting - #2109

Merged
SamuelSchlesinger merged 154 commits into
mainfrom
work/three-sum-native-modular-counter-resume-20261031
Nov 1, 2026
Merged

SamuelSchlesinger merged 154 commits into
mainfrom
work/three-sum-native-modular-counter-resume-20261031

Conversation

@edemaine

@edemaine edemaine commented Oct 31, 2026 •

Copy link
Copy Markdown
Collaborator

Implements the complete native modular triangle counter for #1701. One fixed 128-register standard WordRAM program, at most 32768 assembled slots including halt and no width reads, starts from raw (n,p) headers and three canonical signed matrices, computes residues and its own Morton/padding/layout data, constructs P/Q, executes all seven-product Strassen recursion on an explicit native stack, then returns the existing Cslib.Algorithms.ExactTriangle.countZeroMod as raw register 70. The caller variant uses runtime pointers, permits aliased original arrays and dirty workspace, and preserves original inputs and outside memory. No multiplication, table/layout, count, run or time oracle is supplied.

The actual initialized prefix and charged halt use the same final state. All setup, signed operations, p coefficient arithmetic, copies/indices, recursion/control/returns and scan costs are included. The native charge is at most 3704*(p+1)^2*(n+1)^(281/100); the n exponent 2.81 is strictly subcubic and the quadratic p dependence stays explicit. With original modulus and weight bound p,A≤(n+2)^κ, width (κ+24)*clog₂(n+2) guarantees input fit and execution at every wider width. Every such prefix has words and support below (n+2)^(κ+25), independent of physical W. Empty matrices and every positive modulus, including one, are supported.

Source: selectively adapted CountPrime/cpProduct, cyclic ring operations, Morton indexing and seven-product recursion at that pin. The checked finite source conclusion is exactly countOf n p AB BC AC = (triOf n AB BC AC).countZeroMod p. Existing Cslib modular counts and the quotient ring are reused; reusable Morton arithmetic is added in a shared mathematical module. Source lists become bounded coefficient functions and original Fin coordinates; padding is zero coefficients and BC is transposed. Native setup computes K rather than accepting it. Original native programs and fits/frames/cost proofs replace Light execution; no source simulation is assumed and its 32p²/696q Strassen constants are not transferred. Anthropic credit is retained.

Review entrypoints: Cslib.Algorithms.WordRAM.ExactTriangle.CountPrime.exec (original caller arrays); Cslib.Algorithms.WordRAM.ExactTriangle.CountPrime.runs_input_subcubic (actual State.init/same-y Runs+halt); Cslib.Algorithms.WordRAM.ExactTriangle.CountPrime.bounded_reachable_polynomial (all wider prefix/support); Cslib.Algorithms.WordRAM.Strassen.exec and its phase/stack proof; Cslib.WordRAM.Signed.ArrayArithmetic.exec and its aliasing invariant. The independent whole-layer agent review approves source checkpoint 61c82 with no blockers, including the native execution and resource proofs. Unchanged #1713 kernel coverage was reused after blob comparisons. The final delta adds canonical imports and corrects two source locators; independent nonauthoring agent /root/counter_locator_delta_review approves that exact final delta at 02a78226ea480250771c8494c47ede4b1348eafb, verifying the 67-import inventory and both corrected locators against pinned primary source. No findings; no Lean validation was claimed by either reviewer. These are agent reviews, not human or platform approvals.

Fully admitted kernel clients cover signed positive/negative modular counts, nonprime modulus one, empty input, asymmetric positive-depth output, original-input frames, and aliased caller arrays with dirty scratch/outside sentinel. Interpreter regressions additionally exercise side-three padding/two recursion levels. No curated abstract, catalogue or rendering changes are appropriate.

Validation: targeted MCP source/client checks and a strict scoped build of all 69 changed library modules plus all 4 tests passed on pinned main20e dependencies. Canonical imports, full hygiene/simp and source/kernel/pin identities pass; all 69-library/four-test environment lints, changed-file checks and final name/diff audits passed. Durable candidate validation records exact coverage and the resource-limited redundant lint disposition. Hosted CI passed all six validation gates at exact head 02a78226ea480250771c8494c47ede4b1348eafb, including the global axiom audit and changed-file checks. No redundant local full run was performed. Final locator corrections are documentation-only, with hygiene and identity checks; the scoped compilation/lint evidence above is carried forward from the linked candidate.

Compatibility refresh: normal merge of current main preserves all 73 counter library/test files byte-for-byte and all inherited main source. The counter/client dependency closure is unchanged. Existing independent counter reviews carry forward on that limited identity basis; targeted umbrella/initialized/Strassen clients, canonical imports, hygiene and diff checks pass. Refreshed hosted CI passed all six gates at 4027bd980c5cb8d26257ef10f277d06cb328bc58.

Implements the complete counter milestone for #1701; required CI passes; maintainer review/integration remains pending. Prime enumeration/minimum selection (#2098), global parameter/outer ET/ordinary-host composition and #1394's full native 1.9992 endpoint remain open.

AI assistance: OpenAI Codex implementation, Lean proofs and tests; author responsibility and independent review retained.

Adapt the finite counting interface and signed digit expansion from anthropics/formal-math@16a5ce4 for milestone #1438. This is a mathematical interface; native preprocessing, fast solvers and full composition remain under #1394.
Adapt the complete finite Theorem 17 splitting and recovery component, using the existing three weight matrices, lopsided graphs, modular counts and EqOn answer interface. Prove exact integer/real capacity bridges so the finite constructions and scans are computable. Preserve Anthropic source credit; keep the native 3SUM endpoint open in #1394.

Validation: all six gates in scripts/check.sh pass, with LEAN_NUM_THREADS=1 and cache downloads disabled after bootstrap. Full hygiene, changed-source check-simp, changed-file lints and git diff --check pass. Curated abstracts and rendering are unaffected. AI-assisted implementation/self-review by Codex worker codex-three-sum-splitting-t3-0a4d90c0; independent review will be recorded in the PR.
Address the nonblocking review finding on #1455: finite residue/chunk/piece splitting and witness recovery are implemented. Preserve native preprocessing, fast solvers, full input/time/width composition and exponent 1.9992 as open work under #1394.

Documentation only. Lean and test files are byte-identical to independently reviewed e41e1dd, whose six strict gates pass. Checked the diff, milestone reference, implementation paths, hygiene and changed-file lints. Abstracts and rendering are unaffected.
Implement fixed native residue, histogram and composed collision-counting
programs with explicit frames, local word-fit contracts, exact mathematical
collision semantics and charged bound 34n + 5M + 18 (halt excluded).

Implementation layer for #1454 under #1446/#1394, not full preprocessing.
Sorting/frontend, prime searches, heavy extraction, recursion/output and
global logarithmic-width/subquadratic-time composition remain open.
Curated abstracts: no impact on headline statements, definitions or scope.

Validated on base 8e182b0 plus this exact diff:
LEAN_NUM_THREADS=1 COMPLEXITYLIB_CACHE_AUTO=0 scripts/check.sh: all six gates
passed, including strict test/global axiom audit. Changed-file lints against
that base, hygiene --check-simp and git diff --check passed. Final run followed
resolution of shared-host disk/memory pressure; failed earlier attempts are
not counted as validation.

Independent read-only agent correctness/API review by
/root/review_native_histogram approved the final source blobs after replacing
three private clear helpers with WordRAM.clear. No remaining blockers;
optional Count parameter-frame API can accompany its minimum-search client.
This is within-fleet agent review, not outside-coordinator or human approval.
Outside coordinator review is required before integration.

AI assistance: OpenAI Codex implementation/self-review and a separate Codex
review context. Native programs/counting proofs are original; existing
Anthropic mathematical source credit is preserved unchanged.
Implement the complete finite mathematical milestone of #1463 above #1464:
valid layouts, batch-product correctness/error exclusion, arbitrary-N tiling,
exact requested signed products, order/cardinality estimates, geometric tails
and the derived sparse bounds. At D=4^m, L=19m, D^18<=N and |W|*2^m<=N^2,
encoding entries are bounded by4*N^2/D^(1/18), contributing leaves by33
and passed-set cardinalities by(19m+1)*33 times that scale. Add finite
magnitude and auxiliary object-count bounds. None are native instruction costs.

All six final local gates pass: strict build, aggregate check, strict tests,
environment lint, style lint and init-import check. Hygiene --check-simp,
changed-file lints (14 library modules,1 new test) and diff --check pass.
Tests kernel-check signed results3,20,0,-8, true padding, empty/sparse and
negative-order boundaries, and instantiate all aggregate bounds with jointly
satisfiable m=1 parameters and symbolic matrices without resource overrides.

Read-only math/API review by /root/thin_product_review is clear after fixed
doc references/magnitude wording/quotation hygiene. Focused final delta review
by /root/thin_product_final_delta_review is clear for tree
b021e2d, reusing the prior mathematics review.
These are internal agent reviews, not outside coordinator or human approval.

Source: anthropics/formal-math@16a5ce4,
selective Section2 finite mathematics; Anthropic credit/NOTICE retained.
Abstract assessment: no impact on selected headlines, catalogue or rendering.
Full native tensor/sparse-product/Exact Triangle code, native Chan-He #1446,
whole input/time/width composition and improved1.9992 remain under #1394.

AI assistance: implementation and reviews with OpenAI Codex, worker session
codex-thin-product-math-20261028.
Implement fixed 24-register parameter code with charged numeric helpers, exact existing Chan–He outputs, preserved input memory, derived logarithmic width and subquadratic native time. Add executed boundary and input-init contract examples. Original implementation and proofs credited to Erik Demaine; AI assistance by OpenAI Codex. Part of #1446; independent complete parameter subtask #1458.
Restack #1463 above repaired #1464 without changing the reviewed mathematics.
Rewrite 149 documentation blocks in 14 modules as standalone descriptions;
replace operation-cost and word-size narratives with the exact entry, leaf,
passed-set and specified-value quantities proved. Preserve pinned Anthropic
credit, source locators, statements, definitions, proof bodies and imports.
An independent comparison with original ee288fb confirms that all code bytes
outside comments are identical, including code whitespace.

Validation of this final tree: all six gates pass together (strict build,
aggregate check, strict tests, environment lint, style lint, init imports).
Citation-aware full hygiene --check-simp, changed-file lints (14 library modules,
one test) and git diff --check pass. Lean MCP FiniteMagnitude diagnostics finish
without errors or warnings. Serial Smoke/Axioms warmups avoid the shared-host
memory failure previously seen when these import-heavy clients run together.

Tests and substantive math/API review evidence are retained from the original
reviewed tree b021e2d in ee288fb. This change
is documentation-only; /root/draft_thin_docs authored the scratch map and the
continuation worker inspected/applied it. That drafting is not independent review.
Earlier math reviews are inside-fleet agent reviews, not outside or human approval.
Outside coordinator review will be requested on the final PR. No selected abstract,
catalogue or rendering is affected.

PR publication remains held while native dependent restacks are repaired, per
root sequencing. #1394 remains open: native shared encodings/pruning/Exact Triangle,
Chan-He #1446, complete Convolution/ordinary input/time/width composition and the
improved Section4 route to exponent1.9992 are not supplied by these finite counts.
AI assistance: OpenAI Codex workers codex-thin-product-math-20261028,
codex-three-sum-continuation-t3-3dda8289 and /root/draft_thin_docs.
Complete the shared left/right encoder milestone #1493 above parent b4936ce
(#1496). Fixed standard-WordRAM code with 32 registers computes every public
encodingL/encodingR leaf from actual initialized flat signed inputs. The native
bound is 240*(L+1)*10^L instructions plus halt, with explicit magnitude/address
inequalities, two alternating buffers, charged initialization/copying and the
complete outside frame. The full ordinary native 3SUM objective #1394 remains
open; this component supplies no sparse-query or Exact Triangle solver.

Validation of tree b598513 against
b4936ce: all six gates pass together
(build --wfail --iofail, mk_all --check, test --wfail --iofail, lint,
lint-style, checkInitImports), full citation-aware hygiene --check-simp,
changed-file lints (13 library modules, one new test) and diff checks pass.
Tests execute both encoders at depths zero, one and two, compare all 100
depth-two leaves with the unchanged public encodings, preserve input/frame
sentinels, and cover adjacent word widths and all three copy block orders.
Kernel-checked concrete flat executions discharge every width/magnitude
premise. Selected abstracts, catalogue and rendering are unaffected.

AI assistance: OpenAI Codex implementation and self-review by delegated worker
codex-shared-encoding-t3-03b600bd. Independent correctness/API review is pending;
this is not an approval or a claim that the complete 3SUM objective is done.
Connect the zero-depth and two-stage regression memory witnesses to the
actual prefix Runs already proved by runs_left, rather than discarding that
conjunct. Bound the prefixes by 240 and 72000 instructions and expose the
same executions' charged halt at n+1. All library code is unchanged from
ad3e097 (tree b598513).

Validation of tree 8277017 against actual
parent b4936ce: all six gates pass together
(build --wfail --iofail, mk_all --check, test --wfail --iofail, lint,
lint-style, checkInitImports), full citation-aware hygiene --check-simp,
fresh changed-file lints (13 library modules, one test), strict PR-draft
declaration-name check and staged/unstaged diff checks pass.

Independent nonauthor agent review 8034f3da approved exact ad3e097/tree
b598513, covering full code/model/cost/width/source and ArrayCopy with no
blockers. It is inside-fleet review, not outside approval. This test-only
delta addresses its optional witness-connection finding; focused final
test/source-mapping review remains pending through the parent coordinator.
No selected abstract, catalogue or rendering impact. The full ordinary
native 3SUM objective #1394 remains open; this implements encoder issue #1493.

AI assistance: OpenAI Codex implementation/self-review by delegated worker
codex-shared-encoding-t3-03b600bd. Publication remains on hold for focused
review; this commit is not approval or a whole-3SUM completion claim.
Work in progress for #1526. Fixed native controller and initialized-input interpreter regressions, numerical child-set bridge, call-count potential, charged power/scan/clear/frame/arithmetic/return kernels. Individual current Lean modules have clean MCP diagnostics; the earlier strict targeted scan/count/value/test checkpoint passed. The complete global controller invariant, native evaluator theorem, actual initialized flat-run clients and sparse charged bound remain unfinished. No full six-gate or independent review claim; no PR submission. Full #1394 endpoint remains open. AI-assisted implementation by codex-three-sum-continuation-t3-3dda8289.
Address the bounded nonblocking review findings on #1496. Keep Nat.choose_le_exp_mul_div_pow unchanged while deriving it from Cslib.sum_choose_le_exp_one_mul_div_pow in the existing real binomial module; remove the redundant module and migrate its import. Preserve Anthropic, Samuel Schlesinger, OpenAI and Erik Demaine credit. Kernel-check an actual mixed inner/outer L2,m1 signed pruned result of -8, remove two signature-only tests and retain positive admitted-parameter checks. Paraphrase the identified source-derived sentence, shorten generic source boilerplate and record the generic naming follow-up. No public mathematical statement or definition changes meaning; no selected abstract or endpoint promotion. Final validation/source/review evidence is in PR #1496. AI-assisted implementation by codex-three-sum-continuation-t3-3dda8289.
Implement the complete bounded #1523 native component under #1394. A fixed
96-register standard WordRAM program computes valid subset/inverse tables and
a deterministic existing Layout, prepares all padded signed row/column bands,
calls the unchanged #1520 encoders once per shared band, collects every leaf,
and restores the entire initialized input prefix and outside frame.

The State.init and flat Runs/Executes clients bind the actual output memory to
public encodingL/R in the unchanged leafIndex order (P0 digit 9). All powers,
mask/popcount/root/table loops, indices, guarded matrix addresses, initialization,
copying, encoder calls, loop controls and halt are charged. The generic bound is
4096*(L+1)*(1+N*4^m+2^L+2*numBands*10^L), plus halt; at L=19m and N>=(4^m)^18,
the full charged run is <=81920*(L+1)*N^2/(4^m)^(1/18).

Width assumptions are explicit original-parameter inequalities: the wordBudget
fits target w+2 and 7^L*A < 2^(w-1), w>0, A>=0. Actual signed kernels use at most
15/17 instructions for add/subtract, already included through the unchanged
encoder's real cost. No all-state fit, callback, solver, assumed run/cost or source
machine semantics is a hypothesis. Symbolic positive-depth thin native examples
and concrete signed/padded/frame/width-boundary executions establish nonvacuity.

Pinned source: anthropics/formal-math@16a5ce4,
3sum-apsp/ThreeSumApsp/Programs/Sec2/Theorem5/Encode/AllBands.lean:230-239,262-271
and BandArrayFacts.lean:107-113. Verified checkout files equal their pinned Git
blobs and all PR-draft quotations match those exact line slices. The source's
row/column encoding predicates map to runs' quantified original matrices, all
bands and all leaves on computed MaskTable.layout; Light limits/program maps,
callee contracts and source time hypotheses are replaced by actual native code
proofs, not imported. The block index is beta*K0+(side? h:g), and row is block*N0
plus the compressed outer offset. Shared tile pointers and retained table words
are exposed by tileInputBases/tile_input_values/table_word_layout.

Reuse unchanged WordRAM control/rename/copy/signed APIs, Layout/bandArray/encoding
mathematics and Mathlib finite index/sorted-set APIs. New mask scans, dense inverse
lookup, direct base-seven decoder and native execution/cost composition are
original. Small native-power/ordered-filter/positional-digit/row-major lemmas live
in narrow topic modules. Retain Anthropic, PBC source credit and NOTICE.

Validation: PASS all six strict gates (build --wfail --iofail, mk_all --check,
test --wfail --iofail, lint, lint-style, checkInitImports), serial Smoke/Axioms
warmups and the global Axioms audit; full citation-aware hygiene --check-simp,
fresh actual-base changed-file lints, strict PR-name and diff checks. Validated
with LEAN_NUM_THREADS=1 and cache downloads disabled. Windows static metadata
reads used PYTHONUTF8=1; no Lean/source change was needed. New Lean files use ordinary non-executable file modes. Exact payload tree
bdfc5a1. Targeted Lean MCP endpoint/tests and pinned quote identity also pass.
No PR has been opened;
independent exact-revision correctness/API/source-mapping review is pending.

Abstract assessment: no impact on selected abstracts, models or scope; no new
headline or PDFs. Pruned queries, products, solvers and whole ordinary 3SUM remain
open under #1394. Base #1520 remains unchanged at 3b9234d.

AI assistance: Codex implementation/proofs, session codex-native-bandprep-t3-03b600bd,
under delegating-worker coordination. Existing unchanged encoder outside-review
evidence is PR1520#issuecomment-6477077023; final new-component review pending.
…tions

Work in progress for #1526, not a submitted component. Complete native parent accumulation loop (31N+3), internal sparse initialization (7N+8), computed child push (15), shared actual frame-word store, executable query-code inverse/requested-set bridge and recursive timestamp allowance. These current modules have clean targeted Lean MCP diagnostics; actual interpreter and kernel digit/request regressions pass. Changed-scope hygiene --check-simp and diff check pass. The general node/controller continuation proof, actual initialized full evaluator theorem and final sparse charged bound remain unfinished; no full six-gate or independent review claim. AI-assisted implementation by codex-three-sum-continuation-t3-3dda8289; full #1394 remains open.

Final current-tree checkpoint: strict build --wfail --iofail of Accumulate, Clear, Push, Frame, Powers, Leaf, Weight, Scan and SchonhagePruned tests passed together (3596 jobs); scope hygiene --check-simp and diff checks pass. This is a partial implementation checkpoint, not an all-six-validated PR or completed #1526 milestone.
WIP #1526. Factor root scan setup and root finish; prove the actual eleven-instruction root-frame initialization and exact memory/register frame. Current Root MCP diagnostics clean. Full node/controller composition remains unfinished; no PR or full-six claim. AI-assisted continuation by codex-three-sum-continuation-t3-3dda8289.
Address the sole P2 finding from the independent #1523 review of cb261f6:
remove duplicate Nat.ofDigits_ofFn and publicly import the existing radix
module. The finite-function numbering bridge uses Nat.ofDigits_ofFn_eq_sum.
Its statement is unchanged. Existing radix declarations, proofs and source
credit are unchanged; no native program, endpoint statement or test changed.

Validation on exact final tree 4807cb9:
PASS all six strict gates together (build --wfail --iofail, mk_all --check,
test --wfail --iofail including global Axioms, lint, lint-style,
checkInitImports), fresh actual-base changed-module lints (29 library/1 test),
full citation-aware hygiene --check-simp, strict draft-name and diff checks.
Serial LEAN_NUM_THREADS=1; optional cache downloads disabled. Lean MCP also
reports clean diagnostics for the changed bridge. Logs are in
.lake/codex-three-sum-continuation/band-review-six in the continuation checkout.

Original native implementation and all full correctness/API/source-mapping
review coverage retained. Review record:
#1523 (comment)
Original implementation/validation handoff:
#1523 (comment)
Focused final delta review pending before PR publication. No impact on selected
abstracts, models or scope; no new headline. Complete #1394 native 1.9992
endpoint remains open.

AI assistance: bounded reuse fix and validation by Codex session
codex-three-sum-continuation-t3-3dda8289. Original author credit remains on cb261f6.
Continue #1526 implementation under #1394; this is explicitly partial WIP,
not a complete component or PR submission. Full recursive node composition,
initialized input/flat clients, derived global fits and total-time theorem
remain open. No solver or all-state fit/execution/time certificate is assumed.

Check full root setup/scan/frame (20Q+19), report (9Q+3), leaf/return (24),
loaded leaf step (43), internal entry (7N+28), native nonempty child scan/push
(20N+42), empty-child scan/advance (20N+33), returned-child accumulation
(31N+29), and final return (26) against the actual standard fixed native Code.
KernelRegs describes only constant/pointer register values. Node footprints
preserve the ancestor rows. The zero-depth node matches existing Pruned.result
and the finite traceWeight; its continuation uses the existing ExecWithin.loop_iter.
No alternative machine or run semantics is introduced.

The reporting-body/controller names are definitionally identical Code trees.
ScanMemory.congr transports the existing representation across disjoint writes
and removes duplicate root proof plumbing; push exposes its four-store frame.

Validation: targeted Lean MCP diagnostics clean for every new/updated phase
and ComplexityTests/SchonhagePruned.lean. Native interpreter regressions retain
depths 0/1/2, both signs, repeated/empty/mixed queries and an outside sentinel.
New kernel examples discharge the general node/register/address/signed premises,
connect the same negative-product final memory to charged controller execution,
and prove an empty leaf preserves the prior value cell. Diff whitespace passes.
No aggregate/all-six validation claimed: root/native audit coordination hold
is respected. Exact partial checkpoint tree 7fa4da6.

Abstracts: no impact; no new headline or endpoint claim. Original 1.9992
objective and sparse-product/ET/final composition remain open under #1394.
AI assistance: Codex implementation/proofs by continuation worker
codex-three-sum-continuation-t3-3dda8289.
Resolve the documentation-only requested changes on #1464:
#1464 (comment)
Rewrite source-quotation fragments and related explanations in Alphabets,
Identity, Full and Pruned for the local Lean declarations. Preserve the
mathematical attribution, bibliography keys, source pin and copyright.

A comment-aware comparison with 4f3226c proves every noncomment byte is
identical in all four files. No declaration, proof, definition, program,
import or test changes. Existing checked source-statement quotations and
notation/quantifier/model/resource mapping in the PR remain unchanged.
The final source-comment screen compares against quoted fragments in the
actual pinned Sec2 and Statements/PaperStatements files, including the
known local renames; no substantial quoted fragment remains unmarked.

Validation is recorded for this exact tree in PR #1464. Source checkpoint
tree 8c3b87b. No abstract/catalogue/model/scope
or rendering impact; no new headline. The full native 1.9992 endpoint remains
open under #1394. Ancestor and descendant remotes are unchanged.

AI assistance: documentation repair and validation by Codex continuation worker
codex-three-sum-continuation-t3-3dda8289. Existing independent mathematical/API
and checked-source review coverage is retained; outside review of the bounded
documentation delta is requested, with no new review agent commissioned.
Finish bounded #1545 from exact #1536 head66036150a. Replace generic
level/inner/outer API vocabulary with order-embedding/subset/complement names.
Remove five redundant membership/range/congruence wrappers, using Mathlib's
orderEmbOfFin_mem/range_orderEmbOfFin and ordinary substitution directly.
Migrate every actual Levels/Batch proof client with no deprecated aliases.
Keep filter_glue's generic name and rename its predicate parameter to P.

The retained generic statement headers are identical after the documented
renaming and binder alpha-renaming. All 48 Levels and 13 Batch declaration
statements and all definition bodies remain unchanged. The entire native
Encoding module is token-identical after comment removal; every other native
library file is unchanged. Source credit and pin are retained. Thus existing
State.init, Signed.encode, width/frame/cost and encodingL/R meanings remain.

Put the sum/option-versus-flat-digit explanation at the actual leftDigits,
rightDigits and termDigits hover docs, preserving their enumeration bodies
and order (row-major P terms, P0 digit9). Update the UPSTREAM naming follow-up.
Add generic nonconsecutive signed/zero/Option reconstruction clients using
Mathlib's orderEmbOfFin_unique, plus the routed optional #1536 asymmetric
native L4,m1,N29 prefix tests. Those compute headers/count/tables/snapshot and
decode/read ranks1 and2 with K0=2, distinguishing quotient/remainder blocks
and signed values without a full10^4-leaf encoder run or native body edits.

Reuse unchanged outside coverage: PR1496#issuecomment-6477111644 atb4936ce28,
PR1496#issuecomment-6480746578 at68bbe40e3, and PR1536#issuecomment-6480852097
at66036150a12046b29986d8f108c0afaf49d01c61. These are agent reviews, not human
approval. No new cited mathematical result or machine model is introduced.

Validation: PASS build --wfail --iofail, mk_all --check, test --wfail --iofail,
lint, lint-style and checkInitImports, with serial Smoke/global Axioms warmups.
Full citation-aware hygiene --check-simp, fresh changed-file lints against
actual base66036150a, strict PR-name and diff checks, and source/native identity
checks PASS. One thread, no cache downloads, PYTHONUTF8=1 on Windows.
Targeted MCP checks, full hygiene --check-simp and source/native identity
checks pass. Final source tree: 0c21b60. No source/ancestor merges or restacks.
Abstract assessment: no impact; no selected theorem/model/meaning/scope or PDF
change. This is generic ergonomics/testing only; full #1394 remains open.

AI-assisted implementation by codex-native-bandprep-t3-03b600bd, under parent
continuation-worker coordination. No new review agent commissioned; ordinary
outside coordinator review is requested when the bounded PR is ready.
WIP checkpoint for #1526; no PR and no completed component claim. The actual fixed native controller now has a depth-inductive execution proof with original Pruned.result values, stored queries/frames, concrete spatial preservation, input-derived signed fits and traceWeight charged continuation. Root loop exit discharges the continuation.

All new library modules through Recursive.exec_ready have clean targeted Lean MCP diagnostics. New concrete entry/result client reports no diagnostics, but the complete existing test file is still elaborating its VM regression commands; no final test-pass or all-six claim. Initialization/root-list/report/flat State.init composition, global width/fit clients, full component validation and independent review remain open. Aggregate checks are held for the coordinated root validation slot.

GenericRAM/Signed/Fits.lean is the unchanged blob from independently owned PR #1552, commit f276db1; credit retained. No native program body changed in this checkpoint. All proofs and invariant definitions are original native work; existing mathematical pruning/encodings retain their source credit. No selected-abstract impact or whole-3SUM endpoint claim. AI-assisted implementation by codex-three-sum-continuation-t3-3dda8289.
Mode-only source checkpoint correction: all sixteen new Lean files are 100644. Every source blob is unchanged from ffa8337; targeted MCP evidence remains scoped there. No aggregate/static validation or endpoint claim.
…ages

Development checkpoint for active #1701; not a review/publication handoff.
The full CountPrime/Strassen code now reuses the existing native Power.program
for runtime padding/array powers instead of adding duplicate power-loop proofs.

New actual native execution proofs: original-parameter Strassen root setup
including Power and all frame stores (4L+30), six-instruction child layout,
26-instruction frame push with actual parent/child readback, quadrant address
computation (at most3), actual source-quadrant copy (7q+9), signed operand forms
(26q+12), exact-alias output accumulation (26q+10), and the actual scalar
controller iteration (42p^2+9p+26). Every argument/access/store/return is charged.
Counter preparation proves dirty spread-table construction in11(2^k-1)+5,
whole monomial blocks in7p+3, real Morton-table lookup in6 and transposed
residue reads in4. Original numerical envelopes derive intermediate fits.

All nine new primary stage modules have final clean targeted MCP diagnostics;
record .lake/native-countprime-3dda8289/development-checkpoint-mcp.json.
Native full-counter and Strassen suites still have clean targeted diagnostics.
The Strassen suite now also has a fully admitted complete initialized scalar
controller proof (same-y prefix Runs, charged halt, bounded state, nonzero
signed result and sentinel), including actual Power/frame/loop execution.

All-depth native controller composition, full matrix/count-loop composition,
original-input logarithmic width and independent-W prefix/support envelopes,
and the derived charged subcubic counter theorem STILL OPEN. Finite seven-
product/countZeroMod identities were proved in the preceding source checkpoint.
No oracle/cubic substitute/new instruction/supplied multiplication was added.
No imports generation, global/static/all-six, new review/agent, push or PR:
root retains the audit slot and published suppliers remain untouched. The
complete native #1394 1.9992 objective and root prime/outer-host remain open.
AI assistance: personal Codex implementation; Anthropic source credit retained.
…case

Source/MCP checkpoint only for active #1701. Adds the seven operand/sign phases,
finite prefix-accumulator invariant, derived child/partial magnitude bounds and
formal equality of completed accumulators with existing finite multiplication.
Native numerical envelopes now derive original-input, form, child and
accumulation fits, plus the actual scratch/frame address relations.

Internal state invariants contain actual registers/memory only, with no run,
answer, multiplication or time fields. Native setup constructs root readiness.
The actual scalar controller node now proves its real result, protected
memory/older frames, return registers and charged continuation/base budget.
Positive-depth native induction is STILL OPEN; the defined recursive proof
budget asserts no execution by itself. General matrix/count-loop composition,
original-input logarithmic width and independent-W prefix/support and actual
charged subcubic counter theorem remain open under #1701/#1394.

Targeted Lean MCP diagnostics are clean for Phases, Bounds, State and Zero.
No all-six/global/static/import generation, push, PR, new review/agent or
ancestor changes; root retains the sole audit slot. Earlier fully admitted
initialized controller and complete VM counter clients remain development
coverage, not a substitute for the missing general native theorem.
AI assistance: personal Codex implementation, preserving pinned source credit.
Source/MCP checkpoint for active #1701. The recursive budget uses conservative uniform native-form bounds (692 quarter words plus900 local instructions); its arithmetic potential is bounded by (42p^2+240p+178)7^k. This is not a proved positive-depth execution bound: native all-depth controller composition remains open. State and scalar Zero MCP diagnostics are clean. No global/static/all-six/import generation, push, PR or review. Root retains the audit slot.
Source checkpoint for #1701 by codex-three-sum-continuation-t3-3dda8289. Actual copy/arithmetic operand production, all seven static child calls, complete child frame creation, one/two-quarter partial accumulation, saved-parent protection/reload, phase comparison/tag costs, and the first complete positive-depth controller iteration are proved with derived fits and footprints. Shared header/cursor invariants factor proof plumbing. Program changes factor the existing seven literal prepare calls without changing their underlying instruction sequences.

Targeted Lean MCP diagnostics passed for State, Child, Form, Prepare, QuarterUpdate, Progress, Receive, Dispatch, Restore, Entry and the scalar Zero case. Current WordRAMStrassen complete VM/kernel clients passed. A dependency output readonly failure on four exact unshared LeafStep artifacts was resolved by clearing only their readonly bits; the refreshed dependency and Zero/Entry subsequently passed. This is source/MCP evidence, not full validation.

Positive-depth recursive controller composition and full native matrix-building/count-extraction/width/time composition remain unproved. The recurrence arithmetic is not a charged whole-counter theorem. No aggregate/import generation, all-six/static validation, push, PR, review or endpoint completion. Root retains sole global/static slot. #1701 and #1394/full native1.9992 remain open. AI assistance: OpenAI Codex.
…ution

Source checkpoint for #1701 by codex-three-sum-continuation-t3-3dda8289. The all-depth controller theorem proves every recursive child execution by depth induction and every remaining phase by finite induction. Actual parent resumes reload saved fields, recompute pointers, dispatch the saved phase, accumulate the real returned product and push the next child or pop. Child writes are proved inside the parent footprint; every original input and older frame remains protected. There is no assumed recursive execution, multiplication or time field.

Strassen.exec derives root readiness from real Power/setup/frame writes and closes the real controller exit. The actual pre-halt bound is traceBudget p k + 4*k + 32, where traceBudget p 0=42*p*p+9*p+28 and traceBudget p (k+1)=7*traceBudget p k+692*(4^k*p)+900. The already-proved potential bounds this by (42*p*p+240*p+178)*7^k+4*k+32. Canonical signed magnitude and numerical address envelopes, dirty output/workspace, original input separation and complete frame are explicit.

Targeted Lean MCP diagnostics are clean for Dispatch, Receive, Next, Finish, Pending, Resume, Traversal, Exec and the whole updated WordRAMStrassen test module. Its new fully admitted positive-depth generic-execution client proves actual State.init prefix Runs, same-y halt, bounded state, all four signed output values and an outside sentinel within 2188 total instructions. Existing scalar, positive-depth and depth-two cyclic VM regressions remain. No all-six/static/import/aggregate, push, PR or independent review was run.

Remaining #1701: complete native CountPrime matrix preparation/extraction composition, initialized original-weight execution, original-input log-width and width-independent prefix/support plus final subcubic-in-n polynomial-in-p count bound. Native Strassen completion does not yet prove the counter or fast prime selection. Root retains global/static slot and prime/outer-host scope. #1394/full native1.9992 remains open. AI assistance: OpenAI Codex.
…stages

Source checkpoint for #1701 by codex-three-sum-continuation-t3-3dda8289. The real 128-register product call copies six arguments and invokes the complete native Strassen kernel in the low64 bank, charging traceBudget+4k+38 and preserving every upper metadata register. Unit monomial bounds derive recursive signed fits 2*(p+4)*16^k. No multiplication/run/time contract is assumed.

The actual logarithm stage computes ceil log2(original side) using NatClog within5K+11; actual power/layout computes every residue/spread/coefficient/workspace pointer within4K+20, with original-parameter physical fits, complete memory frame and exact register readback. Actual guarded residue reads charge both padding tests and avoid source access for padded cells. Code change only factors the same literal guards into matrixResidue; underlying native instructions are unchanged.

The finite CountPrime bridge exposes each original product coefficient as the existing cyclic matrix-product coefficient and proves nonnegativity/at-most-n for subsequent native unsigned extraction; count_eq now reuses that exact lemma and its existing statement is unchanged. Both monomial coefficient bounds are proved. Strassen State/Entry doc wording is updated to reflect the completed traversal proof.

Clean targeted Lean MCP diagnostics for finite CountPrime, Product, MatrixResidue, Logarithm and Layout; the complete current WordRAMCountPrime native VM/kernel suite passed after the native guard factoring and finite API/proof change. Strassen doc-only updates follow the already-checked complete execution proof without changing statements, definitions or proofs. No all-six/import/aggregate/static, push, PR, or independent review.

Remaining full-counter work: whole padded matrix loops, selected-coefficient scan, original-weight initialized/caller composition, original-input logarithmic width and width-independent prefix/support, and the charged subcubic-in-n polynomial-in-p total. Root retains global/static slot and prime/outer-host scope; #1701 and #1394/native1.9992 remain OPEN. AI assistance: OpenAI Codex.
Source checkpoint for #1701 by codex-three-sum-continuation-t3-3dda8289. Each actual padded cell executes runtime division/remainder, computed-table Morton reads, both guards and true transposed/nontransposed source read, every canonical coefficient store, and the cell increment. The complete dirty-matrix loop costs (7*p+24)*4^k+5 instructions. Its invariant uses injectivity of existing Morton projections to preserve earlier noncontiguous blocks and protects source/table below the destination. No precomputed matrix, index, residue answer, run or cost is assumed.

Program change factors the same cell instructions into matrixStep for proof composition; no native operation is added. MatrixCell and Matrix have clean targeted Lean MCP diagnostics. The complete current WordRAMCountPrime native VM/kernel test module passed after factoring, including signed/asymmetric/transposed and padded/empty cases. All new source is mode100644. No import generation/global/static/all-six, push, PR or review; root retains its audit slot.

Remaining: bridge all computed matrix coefficients to the existing pCoefficients/qCoefficients specs; prove the final coefficient scan; compose original-weight initialized inputs with residue/table/matrix/actual Strassen/extraction; derive original-input logarithmic width, independent-W prefix/support and complete charged counter bound. #1701 and #1394/full native1.9992 remain OPEN. Prime selection/global parameters/ordinary outer host remain root scope. AI assistance: OpenAI Codex.
…efficients

Local source checkpoint for #1701, saved at the user's explicit pause request. MatrixReadback.exec_matrix_coefficients composes the complete native padded matrix loop with actual residue/table readback and proves every occupied word equals the canonical encoding of existing pCoefficients/qCoefficients. It includes zero padding and real BC transposition, with no new matrix/problem notion or supplied result/run/time contract.

Final targeted Lean MCP diagnostics for MatrixReadback.lean were success=true, partial=false, no warnings/errors. Earlier local checkpoints prove complete all-depth native Strassen execution, real CountPrime low64 product call, runtime logarithm/layout and full padded matrix loop; current CountPrime VM/kernel tests passed after the matrixStep factoring at18ea3365a. No import generation, global/static audit, all-six, push, PR or independent review was run. Root retains the audit slot.

PAUSED by explicit user request. No active request remains. Next: prove the selected-coefficient scan and its finite row-major count bridge, then compose original-weight initialized inputs/residues/table/matrices/actual Strassen/extraction and derive original-input log-width, width-independent prefix/support and total subcubic counter bound. Full #1701 and #1394/native1.9992 remain OPEN. No further work until explicit resume. AI assistance: OpenAI Codex.
Normal merge of pinned main20e3ba720 into preserved counter4419dca359. Retains landed supplier docs, alias regression and roadmap; retains own additional convolution_congr needed by Strassen. No intended counter or Strassen semantic changes. Current-pin targeted compatibility remains to be checked; no new all-six claim.
Internal #1701 source checkpoint, not the complete counter or #1394 endpoint. Native residue calls charge23*n²+8 including argument delivery and preserve original metadata/outside memory. Actual scan cell charges20, full scan22*n²+4; exact original row-major coefficient readback yields existing countZeroMod. Its nonnegative coefficient bound derives unsigned extraction and all prefix accumulator fits; no answer or execution oracle. General integer negated-residue lemma lives in Int.Residue. Count code is factored into a stage with the same actual operations.

Current pinned20e dependencies: targeted Lean MCP clean for Int.Residue, Extraction (via ScanReadback), ScanCell, Scan, ScanReadback, ResidueArray and the complete existing WordRAMCountPrime initialized/interpreter regression module. Initial MCP server timed out after cold preparation; no old worker survived; targeted command-line fallback reached source errors, which were resolved through restored MCP. Optional bootstrap permission failures and failed checkpoint log retained in tmp/native-countprime-3dda8289. No aggregate/import generation/global static/all-six run or independent review. Remaining: complete caller/State.init composition, original-input width and independent-W polynomial prefix/support, full charged subcubic-in-n polynomial-in-p bound.
Internal #1701 source checkpoint. CountPrime.exec now starts with only original runtime scalar/pointer registers and canonical signed AB/BC/AC arrays. Actual logarithm/layout, three signed residue calls, computed spread table, both padded monomial matrices, complete native seven-product Strassen and raw selected count are composed without layout/table/multiplication/run/time oracles. Arguments remain128-bank64..69, rawresult70; original arrays and outside explicit dirty workspace/stack survive. Numeric signed/address admission is in original dimensions/pointers/weight bound; initialized/log-width/wider-prefix/subcubic envelopes remain next.

All new setup, three-residue, both-matrix, solve, complete tail and original-caller execution modules have clean targeted Lean MCP diagnostics on pinned20e dependencies. Existing complete WordRAMCountPrime actual native interpreter/kernel regressions are clean after code-stage factoring. Whole preserved Strassen execution elaborated under the new pin. No aggregate/import generation/static/all-six or independent review; no completion claim for1701/1394.
Source-complete #1701 checkpoint. Fixed128-bank standard program from raw(n,p) and3canonical signed matrices returns existing countZeroMod. Complete caller/State.init/same-y prefix/halt semantics and original arrays/outside dirty-workspace frame. Every setup/residue/index/table/padding/coefficient/Strassen-stack/copy/control/return/scan/halt instruction is charged: <=3704*(p+1)^2*(n+1)^(281/100). Runtime p factor remains explicit. Original p,A<=(n+2)^kappa imply sufficient physical width(kappa+24)*clog2(n+2), guaranteed input fit, and all wider prefixes have words/support below(n+2)^(kappa+25), independent of physicalW. No multiplication/layout/table/count/run/time oracle.

Targeted Lean MCP clean for the complete umbrella, every new execution/width/prefix/time module, existing signed-array/Strassen/counter interpreter+kernel tests, and new fully admitted initialized clients: positive false-positive736steps, negative1454, signed asymmetric positive-depth4596, empty412, modulus-one354, and aliased-source dirty caller726prehalt with outside sentinel. Same-y Runs and charged halt are connected. Pin20e dependencies; bootstrap/initial failed target/MCP restart logs retained. Eight primary-source files verified byte-for-byte against pin16a5ce41304fcdaea4e0be7c132e1c361dc26da5; exact countOf_eq quote/locators checked. Source packet tmp/native-countprime-3dda8289/counter-{source-mapping.json,pr-body.md}.

Canonical imports, final full static audits, hosted six gates and required fresh whole-layer nonauthoring review remain pending root coordination. No new-head all-six or review approval claim. No selected abstract/catalogue/rendering impact. Full1701 awaits validation/integration; prime selection2098, global ET/ordinary-host composition and1394/1.9992 remain open. AI assistance: OpenAI Codex. Original Anthropic credit retained; original4419 checkpoint preserved.
Register 67 canonical imports for the source-complete #1701 counter at
61c82f6. No library/native/proof/test/doc
source changed after that checkpoint. Final source tree including modes:
86adfee; pinned main20e3ba720ca7939a2ab65c1ada315d547551524e.

Final validation: strict scoped --wfail/--iofail build of all69 changed
library modules and4 tests PASS; the native counter umbrella environment
lint covered all69 modules/1404 declarations and passed, and4 separately
run test environment lints exited0. mk_all --check, full hygiene --check-simp,
6 strict PR-body names, complete base/staged/unstaged whitespace, and
changed69-library/4-new-test documentation/restatement checks PASS.
The standard changed-file driver encountered an unrelated missing global
WordRAMUniformProbing.ilean; its unmodified checks passed with fresh own
outputs and the available root inventory. No cold unrelated build was run.
The redundant multi-root library lint remainder was stopped by exact owned
PIDs after complete umbrella coverage passed, under resource pressure;
its full-command successful exit is not claimed. Logs/dispositions preserved
under tmp/native-countprime-3dda8289/final-*. No full-local-six claim:
hosted exact-head CI must supply all six before integration.

Source/supplier audit: 36 retained Strassen/array modules exactly match
preserved4419; five native cyclic-kernel modules and its test exactly match
landed20e; eight primary source files match pinned Anthropic Git blobs at
16a5ce41304fcdaea4e0be7c132e1c361dc26da5 and the countOf_eq quotation
was checked. All76 changed paths are100644; policy/toolchain/dependency
pins and abstract catalogue unchanged. No abstract/rendering impact.
Fresh root-arranged whole-layer review is in progress; its bounds/width
subreview approves61c82. Root reserves two nonblocking finite-source
locator-only doc corrections after handoff. No review/integration approval
or PR publication is claimed by this author.

The actual fixed128-bank program computes existing countZeroMod, with
original signed inputs/dirty caller frame, actual State.init and same-y
prefix plus halt, charged <=3704*(p+1)^2*(n+1)^(281/100), original-input
logarithmic width and physical-width-independent polynomial prefix support.
The quadratic p dependence remains explicit. Selection2098 and global
ET/ordinary-host/full1394/1.9992 composition remain open. AI assistance:
OpenAI Codex; retained original Anthropic source credit.
Coordinator fixes the two optional source-reference nits from the independent
whole-layer review of 61c82f6. Only two module-doc line ranges change:
recurrence 81-96 and block identity/proof 105-126. No declaration, proof,
native instruction, attribute, test, import or source-credit change.

The parent 7bc9b1c adds only canonical imports to the reviewed source.
Targeted/scoped compilation and audits remain recorded in that commit.
Exact-head hosted six-gate CI remains required before integration; this
documentation-only commit claims no new full local validation.

Independent whole-layer review: #1701 (comment)
AI assistance: OpenAI Codex.
Normal merge of pinned current main bc2e6c2
into approved source 02a7822. Git merged
the aggregate and ROADMAP automatically; no manual conflict resolution.

Identity audit: all 69 own library files and four tests are byte/mode-identical
to the reviewed revision. Every other main source is retained exactly; only
the canonical aggregate and preexisting counter ROADMAP/UPSTREAM additions
differ from main. The 103-module local dependency closure of the counter and
representative clients has no source delta. Aggregate imports exactly match
the sorted 3586-module tracked inventory.

Targeted MCP: counter umbrella, initialized execution tests and Strassen
clients all clean (no errors/warnings/partial). Canonical mk_all --check, full
hygiene --check-simp, body-name audit and staged diff --check pass. No full
local validation rerun; hosted six-gate CI is required on this merged head.
Original full six-gate coverage remains run41251234639 at 02a7822.

Carry forward the independent whole-layer approval and locator/import delta
approval only for the identical counter source. No new math/API/attribute
or automation changes are introduced here. Full #1394 remains open.
AI assistance: OpenAI Codex coordinator integration.

@SamuelSchlesinger SamuelSchlesinger left a comment

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Non-author coordinator codex-algorithms-review2109-20261101: APPROVE at 4027bd9. No blocking findings. I reused the whole-layer source/API review after verifying source identity: all 73 counter library/test files match the final locator-reviewed 02a78226; the 104-file Complexity dependency closure and dependency pins are unchanged. Against reviewed checkpoint 61c82f66, the only counter/closure differences are the two documented locator corrections. I independently checked those and the finite countOf_eq mapping against the pinned primary source.

Direct inspection covered the fixed native program and its actual seven-child stack traversal, signed-array unread-entry/alias invariant, residue and Morton/padding construction, BC transposition, nonnegative coefficient extraction, and composition into the existing countZeroMod. The initialized prefix and charged halt use the same final state. The recurrence charges native coefficient, copy, access, control and return work; 3704*(p+1)^2*(n+1)^2.81 is a unit-cost standard word-RAM bound with quadratic runtime-p dependence, not a bit-cost or unrestricted-p subcubic endpoint. Logarithmic admission depends on the original modulus/weight bounds, and the wider-prefix word/support bound is independent of physical width. No intermediate multiplication, table, answer or execution oracle is assumed.

I inspected all four test suites, including fully admitted signed positive/negative counts, modulus one, empty input, positive-depth asymmetric transpose, and aliased original arrays with dirty scratch and an outside sentinel; interpreter regressions additionally cover padding to side four/two recursion levels. Hosted CI passed all six gates. Its actual checkout ad6f341b (base bc2e6c25 + this head) has exactly the reviewed head's tree. I did not run Lean, a local build, or re-execute the regressions; validation relies on that checked CI and the preserved earlier coverage.

This completes the concrete #1701 counter component. Prime enumeration/minimum selection (#2098), global parameter/outer-host composition, and #1394's full native ThreeSum endpoint are not covered by this approval. No curated abstract/catalogue/rendering impact. This is agent review, not human approval.

SamuelSchlesinger commented Nov 1, 2026 •

Copy link
Copy Markdown
Collaborator

Coordinator logsQ-queue-20261101: #2109 actually landed as exact 16fdf907fed6b05fbb4df611b1b115fab6cc395d at 20:30:23 UTC. All 73 reviewed code/test entries, original documentation changes, Anthropic/source credit, pins and unrelated accepted-prefix entries are retained. Current outside-source-fleet approval and source all-six CI carry forward; no source edits or repeated review/build.

The shared exact cumulative MQ receipt validates landed descendant 37e23f9c with all six required gates and one saved finalized log. Individual unfinished jobs are not claimed successful or cancelled. Usable-publication closeout is complete through that same shared fixed-main receipt: exact 37e23f9c, all six passed, public map and all 113 new references verified. Its unavailable-handoff/rebuild limits are recorded there; no separate main log/map/artifact-body retrieval.

This completes #1701’s concrete native modular counter, with explicit quadratic modulus dependence, unit-instruction costs and stated width/prefix hypotheses. #2124/#2133 now follow their actual-parent gates; outer-host composition, ordinary bit costs and #1394’s full endpoint remain separate. No curated abstract impact. Agent coordination, not human approval.

@SamuelSchlesinger
SamuelSchlesinger added this pull request to the merge queue Nov 1, 2026
Merged via the queue into main with commit 16fdf90 Nov 1, 2026
5 checks passed
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

3 participants