# Numaro full LLM context Numaro is an AI autoresearch engine. The system uses multi-agent research, hypothesis generation, tool-making agents, automatic experiments, scalable compute, and shared memory to run technical research campaigns. Primary site: https://numaro.tech/ Autoresearch explainer: https://numaro.tech/autoresearch/ Contact: contact@numaro.tech This file describes Numaro’s AI Performance offer and expands the public research index into a machine-readable plain-text summary. Use the canonical report URLs for citation and the HTML pages for tables, figures, metadata, and references. ## AI Performance: Autonomous optimization for AI workloads and hardware URL: https://numaro.tech/ai-performance/ Kernels, compilers, and specialized languages. We optimize the software around your workload and hardware. Areas of work: - AI workloads & kernels: Find the operations that limit inference or training, then optimize how they run on your target GPU or accelerator. Explore custom kernels, operator fusion, data layouts, and precision choices within your accuracy requirements. Example engagement: A vision pipeline spends too much time moving intermediate tensors. Fuse compatible operations and measure the effect on the full pipeline. - Compilers & runtimes: Explore compiler passes, vectorization, scheduling, and memory management in toolchains such as MLIR/IREE, TVM, and LLVM, targeting GPUs and custom accelerators, including new architectures. Evaluate representative workloads on hardware or in a suitable simulator and improve the path from a model or program to efficient execution. Example engagement: A custom accelerator needs a better way to map an operator. Compare lowering and scheduling choices using your hardware or simulator, with simulated results identified explicitly. - Specialized languages & toolchains: Design a domain-specific language, intermediate representation, or compiler that makes that structure explicit. Give the toolchain the information it needs to generate efficient code and check that transformations preserve behavior. Example engagement: A family of simulation or inference programs repeats the same patterns. Capture them in a small language and develop a compiler for the target hardware. Scope: A deeper collaboration, scoped after understanding your workload and integration needs. Objectives: - Latency: Less time per request, step, or control cycle. - Throughput: More useful work on the same hardware. - Memory: A smaller footprint and fewer data transfers. - Energy: Less energy per task, where it can be measured. Correctness, model quality, and deployment requirements are part of the target from the start. Published GPU evidence: - 2–4.5× faster batched matrix multiplication: Selected small and medium matrices, batch ≥ 512, versus torch.bmm / cuBLAS. Outputs matched the baseline bit for bit in the reported tests. - 1.55× faster fused depthwise convolution: FP16 geometric mean for depthwise 3×3 convolution, bias, and ReLU6 versus cuDNN convolution followed by activation. Bit-exact in the reported tests. Measurements on one NVIDIA L40S in the report’s stated environment, using paired, interleaved timing on a shared GPU. Results depend on workload, hardware, and baseline; a pilot measures your stack and the end-to-end impact. Benchmark report: https://numaro.tech/research/faster-ml-kernels-2026/ Compiler execution evidence: 2.93× faster compiled program execution: Geometric-mean execution speedup across 80 C-reference benchmarks versus Clang 21 -O2, using Numaro’s experimental compiler. The programs express equivalent computations in different source languages and match the benchmark checksums. This measures execution time, not compilation time or Rust performance. Recorded August 8, 2026 on an x86-64 CPU. Timings include process startup, with a warmup followed by the minimum of five runs pinned to one core. This is a historical benchmark snapshot, not a new timing run. Against Clang 21 -O2: 41 wins, 7 ties within 2%, and 32 losses. The median runtime is 0.9733× the baseline. Large algorithmic gains and short-running cases have a substantial effect on the 2.93× geometric mean. Restricting the comparison to the 66 cases where Numaro’s execution takes at least 1 ms gives a 1.17× geometric-mean speedup. Across all 80 cases, the geometric mean versus Clang -O3 -march=native is 2.48×. The custom compiler is not a drop-in C or Rust compiler. These results do not establish faster compilation, a universal runtime advantage, or performance on a custom accelerator. Benchmark data: https://numaro.tech/assets/benchmarks/compiler-runtime-2026-08-08.json Method: Numaro’s autoresearch engine generates candidates, writes tools, runs experiments, checks results, and retains useful discoveries. The team combines machine-learning expertise with programming-language and compiler engineering. Technical team: - Vadim Borisov, PhD — ML & autonomous research. Vadim guides workload selection, ML evaluation, and the research campaign. His work spans generative models and efficient inference. Research profile: https://unnir.github.io/ Papers: https://scholar.google.com/citations?user=gbwdmJEAAAAJ&hl=en - Philipp Schuster, PhD — Programming languages & compilers. Philipp guides language and compiler design, optimization strategy, and technical review. His research connects programming language theory to native code generation. Research profile: https://se.informatik.uni-tuebingen.de/team/schuster/ Papers: https://scholar.google.com/citations?user=mtzDiSAAAAAJ&hl=en The team guides the campaign, reviews results with the customer, and handles the technical handover and integration guidance. Pilot structure: - Scope it together: Your engineers and our team choose a workload, establish the baseline, and agree on performance and correctness targets. - Guide the research: Our team directs the campaign on your hardware or simulator, reviews candidates, and checks the results with you. - Technical handover: We deliver evaluated code and reproducible benchmarks, walk your engineers through the changes, and guide integration. Inputs: a representative workload, current baseline, relevant constraints, and hardware or a suitable execution or simulation environment. Improvement targets are set after examining the baseline. Simulated results are identified explicitly. Discuss a pilot: contact@numaro.tech ## Designing a 50,000-peptide antimicrobial library URL: https://numaro.tech/research/antimicrobial-peptide-library-2026/ Report: NUMARO-2026-023 Date: 2026-10-31 Authors: Vadim Borisov Domain: Computational biology Hero metric: 15 / 40 official rank · AMP Challenge · Vadim Borisov’s team Plain-language summary: A useful antimicrobial peptide library needs promising individual sequences and enough variety to explore different candidates. The team treated the final library as a joint selection problem: generate a larger pool, assess its candidates, and assemble a set that balances predicted quality with coverage of peptide space. The official result provides an independent competition evaluation of that submitted set. Key details: - The organizer report identifies the entry as 84912 Vadim Borisov: rank 15, score 23.21 ± 0.20. The uncertainty is the standard deviation across five disjoint evaluation blocks. - The competition received 61 submissions. Forty entries were ranked; four eligible organizing-team entries were scored separately without ranks. - The team’s wrap-up reports 50,000 unique sequences and a top-100 subset, with byte-identical FASTA outputs across repeated CPU-only submission-generation runs. - An evaluator audit exposed a reversed conformity objective and a weighting error. After correcting the evaluator, removing a forced diversity quota improved the internal top-100 evaluation by about 83%. Hard part: not listed. Technical claim: The AMP Challenge entry by Vadim Borisov’s team ranks 15th among 40 ranked submissions in the organizers’ aggregation-score report, with 23.21 ± 0.20 on a 0–100 scale. The submitted library contains 50,000 peptides generated with a 37.9-million-parameter conditional language model, GRPO optimization, custom potency predictors, and set-level selection. The official score combines predicted realism, activity, and diversity, averaged over five disjoint blocks of 10,000 sequences. In a separate internal held-out evaluation described in the team’s August wrap-up, removing a hard diversity quota from top-100 selection increased the Phase 2 score from 0.954 to 1.747. These internal values use a different scale from the official aggregation score. Both results concern computational evaluation; they do not establish experimental antimicrobial efficacy or safety. Result rows: - Official competition rank: baseline 40 ranked entries; Numaro 15th; delta organizer ranking; note: Table 2 · entry 84912 - Official aggregation score: baseline 0–100 scale; Numaro 23.21 ± 0.20; delta higher is better; note: mean ± SD · five 10,000-sequence blocks - Submitted library: baseline 50,000 required; Numaro 50,000 sequences; delta eligible and ranked; note: top-100 is a subset of the library - Internal Phase 2 score: baseline 0.954; Numaro 1.747; delta +83.1%; note: team-reported held-out evaluation · separate scale - Internal worst-strain potency score: baseline 1.161; Numaro 1.610; delta +38.7%; note: after removing the top-100 diversity quota Visual notes: - The full library and the selected top-100: The team’s ESM-2 embedding visualization shows the full library covering the reference distribution, with the top-100 concentrated in high-scoring regions. Source: Vadim Borisov’s Kaggle wrap-up, Figure 7 (CC BY 4.0). (https://numaro.tech/assets/research/antimicrobial-peptides/library-embedding.png) Method: A 37.9-million-parameter conditional peptide language model follows a three-stage curriculum: 2 million UniParc peptides, 837,000 AMPSphere metagenomic peptides, and 47,000 curated antimicrobial peptides. GRPO then rewards the weakest of several potency signals, encouraging agreement across predictors. The final library is assembled jointly rather than by taking the highest individual scores alone. Method steps: - Condition generation on peptide length and net-charge buckets, and sample from a portfolio of model checkpoints. - Rank candidates with conservative bootstrap-ensemble estimates for antimicrobial potency and hemolysis-related properties. - Run 400,000 set-level swap iterations to match the reference distribution in ESM-2 embedding space while retaining promising candidates. - Select the top-100 without the hard cluster quota that the internal audit found was admitting weaker candidates. Verification: The independent ranking comes from Table 2 of the organizers’ AMP Challenge – Aggregation Score report. Its metric weights realism, activity, and diversity equally and averages five non-overlapping blocks covering the complete submitted library. The wrap-up separately reports corrected evaluator agreement with seqme, ablation checks, sequence-compliance checks, and deterministic reproduction. Those pipeline checks and internal gains are team-reported; this website review checked the published sources rather than rerunning training, generation, or scoring. Scope: The official aggregation score is an in silico benchmark, not a wet-lab result. The internal Phase 2 improvement is a selector comparison on a different metric and is not an official leaderboard gain. The wrap-up flags unusually high positive charge in the top-100 and possible hemolytic risk, and notes limited predictive correlation on newly designed peptides. Experimental potency, toxicity, and clinical usefulness remain unestablished by these sources. Baseline sources: - Organizers: AMP Challenge – Aggregation Score (PDF), scoring protocol and Table 2 ranking. (https://storage.googleapis.com/kaggle-forum-message-attachments/3547315/53307/AMP_Challenge.pdf) - Vadim Borisov: Peptide Antimicrobial Library by Set-Level Selection, team wrap-up (August 28, 2026). (https://www.kaggle.com/competitions/amp-challenge/writeups/peptide-antimicrobial-library-by-set-level-selecti) - AMP Challenge on Kaggle. (https://www.kaggle.com/competitions/amp-challenge) ## AI autoresearch discovers a chip-placement algorithm URL: https://numaro.tech/research/macro-placement-relax-and-gate-2026/ Report: NUMARO-2026-022 Date: 2026-08-21 Authors: Numaro AI Autoresearch Domain: Chip design Hero metric: 0.93663 mean proxy · 17 circuits · lower is better Plain-language summary: Before a chip's small logic cells are placed and its wires routed, large memory blocks and hard IP need locations on the floorplan. Those choices shape the space available to every later tool. Here the AI performed the research that created a placement algorithm: it proposed hypotheses, wrote code, ran experiments, and recorded what survived. The delivered algorithm uses no language model or trained placement model at run time. Key details: - The 900-second run lowers the published rank-1 mean from 0.9507 to 0.93663, a 1.48% reduction. The comparison uses reported baseline scores on hardware we do not control. - All three 300-second seed means—0.94808, 0.94690, and 0.94803—are below 0.9507. These are complete 17-circuit sweeps, not a selection of the best circuits. - Ten development circuits, three validation circuits, and four test circuits were assigned before optimization. The algorithm and parameters were frozen before test evaluation. - Twelve search modifications were rejected. The useful changes made the congestion objective smoother for guidance and exact evaluation cheaper for decisions. Hard part: The congestion term snaps pins to grid cells with floor(), so it gives no useful local gradient. Smoothing reveals directions but can mislead the search. Relax-and-Gate keeps a proposal only after a legal placement improves the exact benchmark objective. Technical claim: Relax-and-Gate combines a mass-conserving relaxation of the benchmark's gridded congestion model with exact GPU acceptance. The relaxation proposes global moves; the exact objective decides which moves are kept. At a nominal 900-second search budget per circuit on one NVIDIA L40S, seed 0 achieves a mean proxy cost of 0.936626999 across all 17 IBM circuits, 1.48% below Archgen's published 0.9507. All 17 placements are legal. At 300 seconds, the mean across three seeds is 0.947672286. The method was frozen at commit f264d1f8 before the four held-out circuits were evaluated. This is a comparison with published competition results, not an official leaderboard entry or evidence of universally better physical designs. Result rows: - Archgen, published rank 1: baseline 0.9507 (https://github.com/partcleda/macro-place-challenge-2026#-leaderboard); Numaro 0.93663; delta −1.48%; note: 900 s/circuit · seed 0 · one L40S - Carrotato / AbuPlace, rank 2: baseline 0.9522 (https://github.com/partcleda/macro-place-challenge-2026#-leaderboard); Numaro 0.93663; delta −1.64%; note: published baseline mean - JaneRT, rank 3: baseline 0.9694 (https://github.com/partcleda/macro-place-challenge-2026#-leaderboard); Numaro 0.93663; delta −3.38%; note: published baseline mean - RePlAce: baseline 1.4578 (https://github.com/partcleda/macro-place-challenge-2026#evaluation-details); Numaro 0.93663; delta −35.75%; note: same 17-circuit suite - 300-second search budget: baseline 0.9507 (https://github.com/partcleda/macro-place-challenge-2026#-leaderboard); Numaro 0.94767; delta −0.32%; note: mean across 3 seeds · all 51 placements legal Visual notes: - A floorplan and its routing demand, before and after: On ibm17, joint optimization of hard macros and cell clusters lowers the proxy from 1.7395 to 1.1636. Both rows use the same demand-to-capacity color scale. These are benchmark demand maps, not measurements from a detailed router. (https://numaro.tech/assets/research/macro-placement/before-after.webp) - The benchmark comparison and two search budgets: Only complete 17-circuit evaluations appear here. The 300-second result averages three seeds; the 900-second result uses seed 0. Baseline scores are reported values on different hardware. The error bar shows the sample standard deviation of the three complete-run means, not baseline uncertainty. (https://numaro.tech/assets/research/macro-placement/budget.svg) Method: The campaign ran for 48 hours on one L40S. A human chose the problem and compute budget and reviewed the result; the research system generated hypotheses, implemented experiments, and assigned verdicts. The method jointly moves hard macros and cell clusters, first using a differentiable relaxation and then batched discrete search. Both stages keep only exact-scored improvements. Method steps: - Start from the benchmark placement and legalize the hard macros. - Replace pin snapping with bilinear mass distribution and route snapping with continuous cell overlap, preserving total demand. - Use the relaxed objective to propose global moves, then score legal checkpoints with the exact benchmark objective. - Batch discrete proposals on the GPU. Incremental scoring updates the moved macro's affected nets; combined moves are rescored before acceptance. - Return the best exact-scored legal placement, then verify its coordinates independently of the search implementation. Verification: The campaign's standalone verifier imports nothing from the search code. It reloads the original benchmark netlists through the reference TILOS evaluator, recomputes scores from the final coordinates, and checks overlaps, bounds, and fixed macros. The campaign recorded component agreement within 10⁻¹⁴ relative error over 68 full-evaluator comparisons and maximum incremental deviation of 2.2×10⁻¹⁶. For this page, the aggregate and seed means were recalculated from the stored result records; the original GPU campaign and OpenROAD flows were not rerun. Scope: This is a lower reported benchmark proxy, not an official challenge win, an optimality proof, or a general claim of better chips. The four test circuits belong to the same benchmark family. Physical validation is limited to two designs, with a controlled six-placement study on one design whose timing constraint does not bind. Only the power correlation was significant. An exploratory comparison with OpenROAD RTL-MP improves some tail metrics but worsens mean congestion and IR drop, and uses different macro halos. Smooth optimization, exact acceptance, and incremental evaluation also appear in prior work; the paper isolates its differences from AbuPlace. LLM token usage and cost were not instrumented. Baseline sources: - Research manuscript (preprint, PDF). (/assets/research/macro-placement/relax-and-gate-paper.pdf) - Frozen placer, verifier, placements, and campaign evidence (ZIP). (/assets/research/macro-placement/relax-and-gate-artifacts.zip) - Per-circuit scores, seed statistics, and provenance (JSON). (/assets/research/macro-placement/results-summary.json) - Partcl/HRT challenge: public benchmark, rules, and official leaderboard. (https://github.com/partcleda/macro-place-challenge-2026) - AbuPlace: the closest algorithmic comparator. (https://github.com/rishivg/AbuPlace) - Archgen: the published challenge-winning implementation. (https://github.com/archgen-ai/Macro-Placement-challenge-2026) ## The first rigorous improvement to the square-lattice SAW lower bound in 22 years URL: https://numaro.tech/research/self-avoiding-walk-connective-constant-2026/ Report: NUMARO-2026-018 Date: 2026-08-02 Authors: Numaro AI Autoresearch Domain: Statistical mechanics Hero metric: 2.6273856 rigorous lower bound for μ(Z²) Plain-language summary: Self-avoiding walks are a basic model of polymers and critical phenomena. Their exact square-lattice growth constant remains unknown. Progress depends on converting very large exact enumerations into inequalities that survive independent checking; here the improvement comes from extending the same rigorous framework to wider lattice spans. Key details: - The span-17, length-260 run traversed about 5.6×10^8 states and 8.7×10^8 transitions using exact integer arithmetic and Chinese remaindering. - Secondary bounds μ ≥ 2.6265705 at span 16 and μ ≥ 2.6256270 at span 15 both independently clear the previous 2.625622 value. - Optimization Problems pull request #135 was merged on August 2, 2026, and the value now appears on the public constant page. Hard part: The proof reduces an infinite growth-rate question to an exact finite renewal calculation, but the finite calculation is enormous. Every transfer-matrix state, transition, and integer coefficient must remain exact before the final root inequality can be certified. Technical claim: The connective constant μ measures the exponential growth rate of self-avoiding walks on the square lattice. Using the irreducible-bridge renewal method, an exact finite-lattice transfer matrix at span 17 and length 260 gives μ(Z²) ≥ 2.627385640… . The certified rational bound is 2^128 / 129513673858566230428673965530967449326. It strictly improves Jensen's 2004 lower bound 2.625622, while span-15 and span-16 restrictions provide secondary certificates. Mathematical explanation: - Let c_n count n-step nearest-neighbour walks from the origin on Z^2 with no repeated vertex. The connective constant is mu = lim_{n->infinity} c_n^(1/n). - For irreducible-bridge counts a_n, A(z) = sum_{n>=1} a_n z^n and Kesten's renewal identity is A(1/mu) = 1. - Let a_{n,l} count irreducible bridges of length n and span l. The finite polynomial P_{L,N}(z) = sum_{n=1}^N sum_{l=1}^L a_{n,l} z^n has nonnegative coefficients. P_{L,N}(1/R) >= 1 implies mu >= R. - At L=17 and N=260, R = p/q with p=2^128 and q=129513673858566230428673965530967449326. The checker verifies sum_{n=1}^{260} a_hat_n q^n p^(260-n) >= p^260 using exact integers, where a_hat_n = sum_{l=1}^{17} a_{n,l}. - The exact rational R is greater than Jensen's 2.625622 and begins 2.627385640... . The renewal-curve figure is drawn numerically from the archived coefficients; the proof uses the exact integer comparison. Result rows: - Rigorous lower bound: baseline 2.625622 (https://doi.org/10.1088/0305-4470/37/48/001); Numaro 2.627385640…; delta +0.0017636; note: first improvement since 2004 - Transfer span: baseline L=15; Numaro L=17; delta +2; note: length cutoff N=250 → N=260 - Exact states: baseline —; Numaro ≈5.6×10^8; delta enumerated; note: CRT-backed integers - Rigorous upper bound: baseline 2.679193; Numaro 2.679193; delta unchanged; note: the exact constant remains open Visual notes: - The building blocks of a walk: This illustrative 21-step bridge has two renewal points. Splitting there gives three irreducible pieces: lengths 6, 9, and 6, with spans 2, 3, and 2. Each vertex is visited once. (https://numaro.tech/assets/research/self-avoiding-walk/bridge-decomposition.svg) - Where the finite calculation becomes a bound: The strip diagram illustrates the enumeration. The curve uses the actual archived span-17, length-260 coefficients: its finite renewal sum reaches 1 at the certified threshold. The plot is numerical; the proof uses an exact integer comparison. (https://numaro.tech/assets/research/self-avoiding-walk/renewal-certificate.svg) Method: The computation enumerates irreducible bridges cell by cell on finite strips, stores the resulting generating-function coefficients exactly, and applies Kesten's renewal criterion to convert the finite sum into a lower bound for μ. Method steps: - Reproduced the established irreducible-bridge renewal calculation. - Extended the finite-lattice transfer matrix through span 17 and length 260. - Reconstructed large coefficients with Chinese remaindering and checked the renewal inequality using exact integer arithmetic. - Restricted the same table to spans 15 and 16 for secondary certificates. Verification: The archived checker validates the exact rational threshold, coefficient hashes, truncation conditions, and the renewal inequality. A local rerun completed every check and printed ALL CERTIFIED. The website verifier checks the published certificate; it does not repeat the original multi-hundred-million-state enumeration. Scope: This improves the rigorous lower bound, not the numerical estimate or the rigorous upper bound, and it does not determine μ exactly. The large enumeration is bound to the certificate by hashes rather than rerun in the lightweight checker. Baseline sources: - Optimization Problems constant 38a. (https://github.com/teorth/optimizationproblems/blob/main/constants/38a.md) - Merged Optimization Problems pull request #135. (https://github.com/teorth/optimizationproblems/pull/135) - Jensen, Improved lower bounds on the connective constants for two-dimensional self-avoiding walks. (https://doi.org/10.1088/0305-4470/37/48/001) - Permanent Numaro certificate archive. (https://doi.org/10.5281/zenodo.21546041) ## Eleven freely rotated cubes in a smaller containing cube URL: https://numaro.tech/research/packing-11-unit-cubes-2026/ Report: NUMARO-2026-019 Date: 2026-07-03 Authors: Numaro AI Autoresearch Domain: Discrete geometry Hero metric: 2.8919998 certified container side Plain-language summary: The feasibility rule is crisp, but the search space mixes positions with rotations and many possible contact graphs. Escaping the established eight-corner topology exposed a packing family that two strong prior methods had missed. Key details: - All 55 cube pairs have a certified separating axis; the smallest certified gap is 4.69×10^-7. - The C₃ structure contains two body-diagonal cubes, three near face centers, three edge-shifted cubes, and three tilted cubes. - The result was a best-known improvement when produced. Friedman's live table now lists a smaller 2.88295+ construction by Haowei Lin. Hard part: Near the frontier, a visually plausible arrangement can still contain a microscopic overlap. The search had to find a new contact topology, and the final coordinates then had to survive interval separating-axis checks under normalized rotations. Technical claim: Eleven unit cubes, each freely rotatable, fit inside an axis-aligned cube of side at most 2.891999838304098. At discovery this improved AlphaEvolve's 2.894531 and Berthold et al.'s published 2.894446780592509. The arrangement has threefold rotational symmetry and replaces the usual eight-corner pattern with two diagonal cubes and three three-cube orbits. A later public packing by Haowei Lin is smaller, so this page records the geometric discovery and its certificate rather than a current record. Result rows: - Friedman 1998: baseline 2.912096; Numaro 2.891999838; delta -0.020096; note: certified beat - AlphaEvolve 2025: baseline 2.894531 (https://arxiv.org/abs/2511.02864); Numaro 2.891999838; delta -0.002531; note: same objective reproduced - Berthold et al. 2026: baseline 2.894446781 (https://arxiv.org/abs/2605.04850); Numaro 2.891999838; delta -0.002447; note: published benchmark at discovery - Current public table: baseline 2.88295+ (https://erich-friedman.github.io/packing/cubincub/); Numaro 2.891999838; delta superseded; note: Haowei Lin, July 2026 Visual notes: - The benchmark ladder: The Numaro packing cleared the published 2026 benchmark when found; the live table has since moved lower. (https://numaro.tech/assets/research/cube-packing/record-ladder.svg) - A different symmetry basin: The schematic shows the four C₃ orbits that replace the conventional eight-corner family. (https://numaro.tech/assets/research/cube-packing/c3-basin.svg) Method: Batched penalty optimization searched cube centers and unit quaternions under containment and separating-axis penalties, with diverse structural seeds rather than a fixed eight-corner template. Method steps: - Calibrated the objective on the published AlphaEvolve coordinates. - Ran GPU multistart search across structurally different seeds. - Refined the new C₃-symmetric basin near its feasibility wall. - Certified containment and pair separation with interval arithmetic and two independent geometric checks. Verification: The standalone verifier uses 200-bit interval separating-axis tests, convex-QP minimum distances, and point-in-cube sampling. It certifies all 55 pairs as separated and the bounding side at 2.891999838304098. Scope: This is a feasible packing, not an optimality proof, and it is no longer the smallest public value. Its durable contribution is the independently certified C₃-symmetric construction that beat the published benchmark at discovery. Baseline sources: - AlphaEvolve problem paper. (https://arxiv.org/abs/2511.02864) - Berthold et al., Out-of-the-Box Global Optimization for Packing Problems. (https://arxiv.org/abs/2605.04850) - Friedman, live Cubes in Cubes table. (https://erich-friedman.github.io/packing/cubincub/) - Pinned Numaro source package. (https://github.com/unnir/autoresearch/tree/research-r55/wins/alphaevolve_cubepacking_2026) ## Five first-place milestones in four days on Einstein Arena URL: https://numaro.tech/research/einstein-arena-july-2026/ Report: NUMARO-2026-020 Date: 2026-07-30 Authors: Numaro AI Autoresearch Domain: Mathematical optimization Hero metric: 5 first-place milestones in four days Plain-language summary: The value of the campaign is breadth under a common loop: reproduce the evaluator, identify the true numerical bottleneck, search aggressively, and package the exact object. The five tasks have different mathematics, so the run is evidence about research iteration rather than one reusable theorem. Key details: - The first places arrived across four consecutive dates, with the prime-number approximation closing the run on July 30. - The two kissing entries have small positive overlaps and should be read as leaderboard optimizer progress, not valid kissing configurations. - A September 6 snapshot places the five historical submissions at ranks 4, 6, 4, 5, and 2 respectively. Hard part: Each leaderboard used a different evaluator and numerical scale. A fast campaign still had to reproduce each score locally, keep the submitted artifact compatible with the official evaluator, and avoid turning tiny numerical gains into mathematical claims the score did not support. Technical claim: Between July 27 and July 30, 2026, Numaro submissions reached first place on five Einstein Arena tasks: kissing configurations in dimensions 11 and 12, the first autocorrelation minimum, an uncertainty-principle objective, and a prime-number-theorem approximation. This report preserves the campaign as a dated optimization milestone. None of the five submissions remains first as of September 6, 2026. Result rows: - Kissing d=11, n=605: baseline 1.7102381876849664; Numaro 1.7102381876823332; delta first on Jul 27; note: historical; positive overlap - Kissing d=12, n=842: baseline 0.5471029209882765; Numaro 0.5471029180780682; delta first on Jul 28; note: historical; positive overlap - First autocorrelation: baseline 1.5028503020710076; Numaro 1.5028502241756987; delta first on Jul 28; note: current snapshot rank 4 - Uncertainty principle: baseline 0.318073995145458; Numaro 0.3180728706107671; delta first on Jul 29; note: current snapshot rank 5 - Prime-number approximation: baseline 0.997623397576294; Numaro 0.9976244112162461; delta first on Jul 30; note: current Numaro rank 2 Visual notes: - Four days, five milestones: The timeline records when each Numaro submission first reached the top of its leaderboard. (https://numaro.tech/assets/research/arena-campaign/four-day-run.svg) - What changed afterward: Leaderboard snapshot on September 6, 2026. Every historical first has since been surpassed. (https://numaro.tech/assets/research/arena-campaign/current-status.svg) Method: For each task, the campaign rebuilt the official evaluator, established a reproducible baseline, then used task-specific continuous or discrete search and submitted the smallest artifact that reproduced the improved score. Method steps: - Matched the live evaluator and incumbent score. - Searched within the evaluator's actual numerical conventions. - Recomputed every submitted score from the stored artifact. - Recorded the submission ID, date, incumbent, and achieved score. Verification: Each source package contains the submitted object and a reproduction script. The status labels on this page are historical; current-rank statements are separately dated to the September 6, 2026 API snapshot. Scope: These are historical leaderboard milestones, not current first places. Scores are specific to each Arena evaluator. In particular, the kissing objectives permit small positive overlap and do not certify valid kissing configurations. Baseline sources: - Einstein Arena. (https://einsteinarena.com/) - First Autocorrelation Inequality. (https://einsteinarena.com/problems/first-autocorrelation-inequality) - Uncertainty Principle Upper Bound. (https://einsteinarena.com/problems/uncertainty-principle) - Numaro first-autocorrelation source package. (https://github.com/unnir/autoresearch/tree/research-r55/wins/einstein_first_autocorrelation_2026) - Numaro prime-number approximation source package. (https://github.com/unnir/autoresearch/tree/research-r55/wins/pnt_arena) ## Five machine-checkable optima for products of odd cycles URL: https://numaro.tech/research/mixed-odd-cycle-products-2026/ Report: NUMARO-2026-021 Date: 2026-07-21 Authors: Numaro AI Autoresearch Domain: Graph theory Hero metric: 58–110 five explicit optimal witnesses Plain-language summary: A formula in the literature and an explicit object answer different verification needs. These witnesses let a reader inspect every selected vertex and every forbidden adjacency, then see exactly where the matching upper bound enters. Key details: - The five witness sizes follow the linear sequence 13k+6 for n=2k+1 and k=4,…,8. - For adjacent Cₙ fibres, the union of their selected vertices is independent in C₇ ⊠ C₉, so each adjacent pair contains at most 13 vertices. - The source README treated the result as an open 2003 gap; the literature review found the exact family in Korže and Vesel's 2012 paper, so this page corrects that novelty claim. Hard part: The upper bound is short, but attaining it requires coordinating independent subsets across an odd cycle. A single incompatible adjacent fibre can lose a vertex, so the search must arrange the one unavoidable parity defect without creating a strong-product adjacency. Technical claim: For the strong products C₇ ⊠ C₉ ⊠ Cₙ with n=9,11,13,15,17, explicit independent sets have sizes 58, 71, 84, 97, and 110. Each reaches floor(13n/2), the standard adjacent-fibre upper bound using α(C₇ ⊠ C₉)=13. The family was already determined in a 2012 paper by Danilo Korže and Aleksander Vesel. Numaro's contribution here is an independent computational reconstruction and five compact witnesses that can be checked directly. Result rows: - C₇ ⊠ C₉ ⊠ C₉: baseline ≤58; Numaro 58; delta exact; note: explicit witness - C₇ ⊠ C₉ ⊠ C₁₁: baseline ≤71; Numaro 71; delta exact; note: explicit witness - C₇ ⊠ C₉ ⊠ C₁₃: baseline ≤84; Numaro 84; delta exact; note: explicit witness - C₇ ⊠ C₉ ⊠ C₁₅: baseline ≤97; Numaro 97; delta exact; note: explicit witness - C₇ ⊠ C₉ ⊠ C₁₇: baseline ≤110; Numaro 110; delta exact; note: explicit witness Visual notes: - Five attained upper bounds: Every stored witness lands exactly on floor(13n/2), giving the linear sequence 58, 71, 84, 97, 110. (https://numaro.tech/assets/research/mixed-cycle-products/exact-sequence.svg) - Why the ceiling is 13n/2: Two neighboring fibres combine to an independent set in C₇ ⊠ C₉ and therefore contain at most 13 selected vertices. (https://numaro.tech/assets/research/mixed-cycle-products/fibre-bound.svg) Method: A constraint search assembled compatible independent subsets in successive Cₙ fibres, targeting alternating six- and seven-vertex layers with one parity defect around the odd cycle. Method steps: - Fixed the 63-vertex fibre graph C₇ ⊠ C₉ and its independence number 13. - Enumerated compatible fibre subsets under strong-product adjacency. - Searched for cyclic sequences attaining floor(13n/2). - Exported each selected vertex triple as a standalone JSON witness. Verification: The standalone checker confirms unique in-range vertices and tests every pair for strong-product adjacency. It also recomputes the adjacent-fibre inequality. All five witnesses pass and attain the supplied upper bound. Scope: This is not a new independence-number theorem: the family appeared in Korže and Vesel in 2012. The bundled upper-bound check relies on the established fact α(C₇ ⊠ C₉)=13; the five JSON files independently certify the matching lower bounds. Baseline sources: - Korže and Vesel, A Note on the Independence Number of Strong Products of Odd Cycles (2012). (https://combinatorialpress.com/ars-articles/volume-106-ars-articles/a-note-on-the-independence-number-of-strong-products-of-odd-cycles/) - Vesel and Žerovnik, The independence number of the strong product of odd cycles (2003). (https://doi.org/10.1016/S0166-218X(02)00529-9) - Pinned Numaro witnesses and checker. (https://github.com/unnir/autoresearch/tree/research-r55/wins/mixed_cycle_products_2026) ## A certified new lower bound for the GHR sum-difference constant URL: https://numaro.tech/research/sum-difference-constant-2026/ Report: NUMARO-2026-017 Date: 2026-07-23 Authors: Numaro AI Autoresearch Domain: Additive combinatorics Hero metric: 1.1873261 accepted 2026 lower bound Plain-language summary: Adding two integer sets can collapse many pairs onto the same sums, while subtraction can keep more outcomes distinct. The GHR constant measures how large that separation can become when the sumset is still only a constant factor larger than the original set. A higher certified exponent means a stronger construction. Here one sparse digit pattern can be repeated to arbitrary depth, so a finite alphabet produces an asymptotic lower bound. Key details: - The certificate cleared the full 1.1835129324 predecessor from pull request #95 and was merged in pull request #131. The live page now also records later, larger 2026 bounds. - The construction uses 29 digits from 0 through 44 in base 89, with cap ratio rho approximately 10.7041407995. Base 89 is exactly the carry-free boundary 2*44+1. - The rigorous interval lower endpoint is 1.187326127925948057..., giving a certified margin of approximately 0.0038131955 over the merged record. - Optimization Problems pull request #131 merged the certificate on July 31, 2026. Later 2026 constructions have since raised the listed lower bound further; the proven upper bound remains 4/3. Hard part: The headline is a limit theorem, not a fitted curve. The proof must lower-bound the exponential growth of differences, upper-bound the growth of sums, preserve carry-free encoding, and verify the digit lemma's admissibility inequality with directed interval rounding. A tiny numerical error in either growth rate could reverse a four-decimal improvement. Technical claim: Let C_3a denote the largest exponent for which arbitrarily large integer sets can have a sumset comparable to the original set while their difference set grows as a power of that sumset. A 29-letter sparse digit alphabet in base 89, restricted by an average digit-sum cap, gives a carry-free family U_n. The GHR digit lemma converts every admissible finite member into a lower bound. Explicit Gibbs tilts lower-bound the asymptotic difference growth and upper-bound the sum growth, yielding a rigorous interval with lower endpoint 1.187326127925948057... . Therefore C_3a >= 1.187326127925948, strictly above the merged 1.183512932421861510... record by 0.0038131955. Result rows: - C3a lower bound: baseline 1.183512932421861510... (https://github.com/teorth/optimizationproblems/pull/95); Numaro 1.187326127925948; delta +0.0038131955; note: strict interval separation - Construction: baseline base 33, depth 420 (https://github.com/teorth/optimizationproblems/pull/95); Numaro base 89, arbitrary depth; delta limit family; note: capped carry-free digits - Digit alphabet: baseline 14 digits, max 16 (https://github.com/teorth/optimizationproblems/pull/95); Numaro 29 digits, max 44; delta +15 digits; note: dense upper tail, sparse lower tail - Digit-lemma ceiling: baseline 5/4; Numaro 5/4; delta unchanged; note: construction stays safely below - Proven upper bound: baseline 4/3 (https://gyarmatikati.web.elte.hu/publ/sumdiffv.pdf); Numaro 4/3; delta unchanged; note: the global gap remains open Visual notes: - The lower-bound frontier: The historical ladder gives scale; the magnified panel compares the prior 1.1835129324 record with Numaro's accepted 1.1873261279 contribution. The 4/3 upper bound does not move. (https://numaro.tech/assets/research/sum-difference/lower-bound-frontier.svg) - The capped sparse-digit mechanism: Twenty-nine selected digits are repeated in base 89 under a digit-sum budget. An entropy law lower-bounds difference growth while an exponential dual upper-bounds sum growth. (https://numaro.tech/assets/research/sum-difference/sparse-digit-construction.svg) Method: The campaign searched sparse integer alphabets together with cap ratios and dual tilts, then isolated a difference-rich motif: a sparse lower region and a dense upper tail through 44. Repeating that alphabet in base 89 prevents carries. A Gibbs law on minimal digit pairs supplies a feasible entropy lower bound for difference words, while a second exponential tilt bounds the number of sum words. Directed interval arithmetic turns the two rates into a rigorous lower endpoint. Method steps: - Reproduced the current capped-digit construction family and its merged base-33 record. - Searched sparse alphabets, cap ratios, and difference/sum tilt parameters under the no-carry constraint. - Selected the 29-letter alphabet with maximum digit 44 and set the minimal carry-free base to 89. - Certified the limiting growth inequality, then checked finite-depth counters against exact brute force on a tiny instance. Verification: The permanent Zenodo archive contains the certificate data, construction notes, run log, and supplied standalone checker. That checker recomputes the tilted law, cap feasibility, the difference-growth admissibility bound, and the interval lower endpoint from gsd_3a_cert.json. It independently validates the finite-depth dynamic programs against brute force at depth 2 and prints genuine lower bounds at depths 4, 8, 12, and 16. A separately written local verifier reconstructs all minimal difference pairs and sum digits without importing the bundled code, obtains 89 difference digits and 73 sum digits, recomputes the full interval, and performs its own exact depth-2 set test. Both local runs end in PASS. Scope: This certificate was incorporated into Optimization Problems in July 2026 but is no longer the largest lower bound listed there. It does not determine C_3a, improve the proven 4/3 upper bound, or prove that the base-89 alphabet is globally optimal. Baseline sources: - Davis, Ivanisvili, Tao, and contributors, Optimization Problems constant 3a. (https://github.com/teorth/optimizationproblems/blob/main/constants/3a.md) - Mosaic Intelligence, merged base-33 certificate and pull request #95. (https://github.com/teorth/optimizationproblems/pull/95) - Numaro certificate, merged as Optimization Problems pull request #131. (https://github.com/teorth/optimizationproblems/pull/131) - Gyarmati, Hennecart, and Ruzsa, Sums and Differences of Finite Sets. (https://gyarmatikati.web.elte.hu/publ/sumdiffv.pdf) - Zheng, Sums and Differences of Sets: A Further Improvement over AlphaEvolve. (https://arxiv.org/abs/2506.01896) - Gerbicz, Sums and Differences of Sets (Improvement over AlphaEvolve). (https://arxiv.org/abs/2505.16105) - Griego, base-21 construction and pull request #71. (https://github.com/teorth/optimizationproblems/pull/71) - Numaro, permanent certificate archive for C_3a >= 1.187326, Zenodo. DOI: 10.5281/zenodo.21504058. (https://doi.org/10.5281/zenodo.21504058) - Numaro base-89 certificate data. (/assets/research/sum-difference/gsd_3a_cert.json) - Numaro supplied certificate checker. (/assets/research/sum-difference/verify.py) - Numaro independent certificate verifier. (/assets/research/sum-difference/verify_independent.py) - Numaro construction and verification notes. (/assets/research/sum-difference/README.md) - Numaro verification run log. (/assets/research/sum-difference/RUN_LOG.txt) ## A certified new lower bound for the Fourier Entropy-Influence constant URL: https://numaro.tech/research/fourier-entropy-influence-2026/ Report: NUMARO-2026-016 Date: 2026-07-22 Authors: Numaro AI Autoresearch Domain: Analysis of Boolean functions Hero metric: 6.5218457 certified lower bound for C71 Plain-language summary: The Fourier Entropy-Influence conjecture asks whether the Fourier spectrum of every Boolean function has entropy controlled by its sensitivity to input changes. No finite universal upper bound is known. An explicit function with a larger certified ratio therefore forces any valid universal constant upward. Here the improvement comes from a structural correction to the previous record, not from changing the influence or relaxing monotonicity. Key details: - Optimization Problems pull request #130 merged the n=18 certificate on August 2, 2026. The live constant page lists 6.521845710923046575 as the best established lower bound. - The total influence remains exactly 261/128. The gain comes from increasing spectral entropy after splitting one four-cell auxiliary host into two uniform two-cell hosts. - The truth table is exactly balanced and exhaustive monotonicity checking finds zero violations across all 2,359,296 coordinate edges. - The included standalone checker and a separately written NumPy Walsh-Hadamard verifier both reproduce the strict beat from the published certificate. Hard part: At n=18 the certificate contains 262,144 truth-table values and the same number of Fourier coefficients. A useful change must raise spectral entropy while preserving exact balance, exact influence, and monotonicity over every coordinate edge. The decisive move was to identify a one-variable resource imbalance in the n=17 construction and remove it without disturbing the amplification conditions. Technical claim: Let C_71 be the smallest universal constant for which Fourier spectral entropy H(f) is at most C_71 times total influence I(f) for every Boolean function. Starting from the current n=17 record seed, the campaign adds one variable and equalizes how nine auxiliary variables act on a majority-of-nine boundary. The resulting balanced, logic-monotone n=18 function has exact influence 261/128 and a certified amplified ratio H/(I-1) above 6.521845710923046575, strictly clearing the previous record's certified upper endpoint. The construction-level gain over the n=17 ratio is exactly 1/133. Result rows: - FEI lower bound: baseline 6.514326913930565372 (https://github.com/teorth/optimizationproblems/blob/main/constants/71a.md); Numaro 6.521845710923046575; delta +1/133; note: strictly clears the previous certified upper endpoint - Seed dimension: baseline n=17 (https://github.com/teorth/optimizationproblems/pull/124); Numaro n=18; delta +1 variable; note: 262,144-entry truth table - Total influence: baseline 261/128; Numaro 261/128; delta unchanged; note: exact rational identity - Nonzero Fourier coefficients: baseline 2,578 (https://github.com/teorth/optimizationproblems/pull/124); Numaro 2,770; delta +192; note: recomputed from the truth table - Logic monotonicity: baseline verified; Numaro verified; delta 0 violations; note: all 2,359,296 coordinate edges checked Visual notes: - The lower-bound frontier: The full history gives scale; the magnified panel shows the final step from the merged n=17 record to the n=18 certificate. Both seeds have the same exact influence. (https://numaro.tech/assets/research/fei/lower-bound-frontier.svg) - Hosting dilution: In the n=17 seed, x10 handled four majority-boundary cells while seven auxiliaries handled two each. Moving two cells to the new x18 makes all nine hosts uniform. (https://numaro.tech/assets/research/fei/hosting-dilution.svg) Method: The construction keeps the previous record's perturbed majority-of-nine core and fixes an asymmetry in its auxiliary layer. At n=17, x10 acts on four core-boundary cells while each of the other seven auxiliaries acts on two. Adding x18 and moving two of x10's cells onto it produces nine two-cell hosts. The moved Fourier weight is split more evenly, increasing entropy while leaving total influence unchanged. Method steps: - Reproduced the merged MI2026b n=17 seed and its 261/128 exact influence. - Separated the nine-variable majority core from the auxiliary-variable hosting map. - Added x18 and rehosted two of x10's four boundary cells, producing a uniform two-cells-per-auxiliary layer. - Scanned 16,838 single swap-freeze, relocate, and rehost moves; none improved the n=18 seed within that move class. Verification: The published artifact encodes the full truth table as a hex bitmask and binds it to SHA-256 f8a7bb2c...7839. The self-contained checker and an independently written NumPy verifier rebuild all 262,144 values, compute the integer Walsh-Hadamard spectrum, assert Parseval and exact balance, derive I=261/128 as a Fraction, enclose spectral entropy with interval arithmetic, exhaustively check monotonicity, and compare the new lower endpoint against the previous record's certified upper endpoint. Both included checkers pass in local reruns. Scope: This certified lower-bound update was merged into Optimization Problems and remains the best established lower bound listed there. It does not prove the FEI conjecture, provide a finite upper bound, or establish that the n=18 seed is globally optimal. Baseline sources: - Davis, Ivanisvili, Tao, and contributors, Optimization Problems constant 71a. (https://github.com/teorth/optimizationproblems/blob/main/constants/71a.md) - MI2026b, merged n=17 certificate and pull request #124. (https://github.com/teorth/optimizationproblems/pull/124) - Numaro n=18 certificate, merged as pull request #130. (https://github.com/teorth/optimizationproblems/pull/130) - O'Donnell and Tan, A Composition Theorem for the Fourier Entropy-Influence Conjecture. (https://arxiv.org/abs/1304.1347) - Hod, Improved Lower Bounds for the Fourier Entropy/Influence Conjecture via Lexicographic Functions. (https://arxiv.org/abs/1711.00762) - Numaro n=18 self-contained certificate checker. (/assets/research/fei/check_c71_n18.py) - Numaro n=18 independent verifier. (/assets/research/fei/verify.py) - Numaro n=18 truth-table artifact. (/assets/research/fei/fei_c71_n18_artifact.json) - Numaro n=18 verification run log. (/assets/research/fei/RUN_LOG.txt) ## 11,000+ new verified spherical-code records URL: https://numaro.tech/research/spherical-codes-2026/ Report: NUMARO-2026-015 Date: 2026-07-11 Authors: Numaro AI Autoresearch Domain: Discrete geometry Hero metric: 11,000+ new verified records Plain-language summary: A smaller maximum inner product means a larger minimum angle between the closest pair of points. This is not one lucky configuration: the same strict verifier confirms more than eleven thousand new best-known table records across every dimension from 3 through 32. Key details: - At (9,614), the deepened coordinate file lowers the maximum inner product by 0.007394768343. Equivalently, the minimum angle rises from 52.1407 degrees to 52.6755 degrees, a gain of 0.5347 degrees. - At the targeted (26,55) cell, the maximum inner product moves from 0.039999166079 to 0.039998970557, a strict 1.955e-7 gain at the scale where a smooth proxy is too coarse. - The margin distribution is broad: 80 cells improve by more than 1e-3, 1,021 by more than 1e-4, and 3,453 by more than 1e-5. - Under the identical attack, 0 of 24 proven-optimal controls moved, and exact-algebraic values such as (9,21)=1/9 held unchanged. Hard part: The objective mu(X)=max(i: 264 additions down to 254 at rank 73. - The expanded ledger contains 45 fixed-rank records and saves 135 additions in total. - Most of the gain comes from input-side matrices that are perfectly peelable: the exact lower bound equals the constructed circuit count. - Several candidate wins were dropped after rerunning Perminov's own reducer at higher effort. Only strict beats over that stronger baseline are kept. Hard part: A fast-multiplication scheme is a tensor identity, so a smaller circuit cannot change the scheme. The checker rebuilds U, V, and W-transpose from the supplied straight-line programs and then rechecks the Brent identity over the integers. Margins are thin because the field's reducers are already strong. Technical claim: Fast matrix-multiplication schemes reduce multiplication count, but they also need additions to form the linear combinations around those multiplications. The expanded campaign found 45 ternary, Brent-valid schemes where the total add/sub count is strictly lower than the strongest prior achievable count at the same rank, saving 135 additions in total. Each record includes explicit straight-line programs and a standalone verifier. Result rows: - <2,5,9>: baseline 264 (https://github.com/dronperminov/FastMatrixMultiplication); Numaro 254; delta -10; note: largest representative margin - <2,8,8>: baseline 424 (https://github.com/dronperminov/FastMatrixMultiplication); Numaro 418; delta -6; note: large peelable input side - <2,7,7>: baseline 320 (https://github.com/dronperminov/FastMatrixMultiplication); Numaro 314; delta -6; note: peeling plus reducer hybrid - <2,4,9>: baseline 207 (https://github.com/dronperminov/FastMatrixMultiplication); Numaro 202; delta -5; note: Tellegen output map - <4,4,4>: baseline 159 (https://github.com/dronperminov/FastMatrixMultiplication); Numaro 157; delta -2; note: rank 49 Visual notes: - Record margins: The wins are small but repeated: each row is a strict add/sub reduction at the same rank after rerunning strong reducer baselines. (https://numaro.tech/assets/research/matrix-additive/record-margins.svg) - Side costs: For the largest-margin scheme, the total separates into U, V, and W-transpose programs. The input side is where exact peeling opens the gap. (https://numaro.tech/assets/research/matrix-additive/side-breakdown.svg) Method: For each fixed scheme, the total addition count separates into the costs of U, V, and W-transpose. The campaign minimized those sides independently and kept the best reconstructable circuit per side. Method steps: - Reproduced the FMM/Perminov and plinopt baselines before claiming any improvement. - Used exact peeling SLPs where F(M) equals the number of distinct non-trivial rows up to sign. - Applied a Tellegen output map when computing W first and transposing the program was cheaper. - Extracted and reused Perminov's own best per-side reductions for dense sides, instead of forcing our method everywhere. Verification: verify.py checks the Brent tensor identity over the integers, runs randomized matrix products, reconstructs every side from the stored SLP, recounts gates, and asserts the new total is below the old total. Scope: These are best-known additions for specific schemes at fixed rank. They are not proofs of globally minimal additive complexity for each matrix format, and XOR-only GF(2) counts are a different metric. Baseline sources: - Perminov / FastMatrixMultiplication project. (https://github.com/dronperminov/FastMatrixMultiplication) - Dumas, Pernet, Sedoglavic and collaborators, plinopt. (https://arxiv.org/abs/1712.05656) - Martensson, Stankovski, and Wagner, additive complexity of matrix multiplication schemes. (https://eprint.iacr.org/2026/849) ## Bit-exact GPU kernels in regimes vendor libraries leave open URL: https://numaro.tech/research/faster-ml-kernels-2026/ Report: NUMARO-2026-003 Date: 2026-06-30 Authors: Numaro AI Autoresearch Team Domain: GPU kernels Hero metric: 2-4.5x small batched matmul Plain-language summary: This is the most directly practical result in the ledger. It connects research output to actual runtime: when a model is bottlenecked by small batched matrices, fine-grained MoE, depthwise convolution, or skinny int8 decode, a kernel that fills the GPU or removes a memory pass can matter immediately. Key details: - The same report also records losses. Large square GEMM remains cuBLAS territory, and a generic W4A16 kernel is much slower than tinygemm. - The kernel speedups are measured as ratios under paired, interleaved timing, because the GPU was shared and absolute timings were noisy. - The op-count records and the kernel records are separate. Fewer arithmetic operations did not automatically make a faster GPU kernel. Hard part: Vendor libraries are strongest in their core regimes, so a broad 'faster GEMM' claim would be wrong. The useful work is finding narrow shape regimes where the production path leaves occupancy, launch overhead, or memory traffic on the table. Each speed number is paired with a correctness check first. Technical claim: On a single NVIDIA L40S, we built Triton kernels that match the stock PyTorch/cuBLAS/cuDNN operators exactly or within the stated tolerance, then beat them in specific under-served regimes. The wins are not from lower arithmetic count; they come from occupancy, fusion, and structural gaps in the library path. Mathematical explanation: - Amdahl model: if fraction f of original runtime is accelerated by a factor s, the ideal whole-workload speedup is S = 1 / ((1-f) + f/s), holding all other work fixed and adding no new overhead. The page's interactive model is illustrative, not a benchmark. - Selected measured L40S examples: fine-grained E128 K1024 MoE layer 2.85x; MobileNetV3 C72 56x56 block 1.23x; Swin S64 transformer block 1.07x. These use different workloads and kernels and are not outputs of one common model setting. Result rows: - Batched matmul: baseline torch.bmm (https://pytorch.org/docs/stable/generated/torch.bmm.html); Numaro 2-4.5x; delta faster; note: small/medium matrices, batch >= 512 - Fused depthwise 3x3: baseline cuDNN + activation (https://docs.nvidia.com/deeplearning/cudnn/); Numaro 1.55x fp16 / 1.31x fp32; delta faster; note: bit-exact - int8 W8A8: baseline torch._int_mm (https://pytorch.org/docs/stable/torch.html); Numaro up to 3.7x; delta faster; note: skinny-M decode - MoE grouped GEMM: baseline per-expert loop (https://github.com/pytorch/pytorch); Numaro 2.5-3.6x end-to-end; delta faster; note: fine-grained MoE - W4A16: baseline tinygemm (https://pytorch.org/docs/stable/torch.html); Numaro ~12x slower; delta loss; note: kept as a boundary condition Visual notes: - Remove the intermediate memory trip: The stock depthwise path writes a temporary activation tensor to global memory and reads it back for ReLU6. The fused kernel keeps that intermediate on chip. This schematic shows activation-tensor traffic; weights, bias and cache effects are omitted. (https://numaro.tech/assets/research/faster-kernels/fusion-memory.svg) - Every measured shape in the locked grid: FP16 and FP32 speedups for fused depthwise 3×3 + bias + ReLU6 against cuDNN convolution followed by activation. All 12 locked cases per precision are shown. Empty cells were not in this grid; both precision variants matched the reference bit for bit in the reported tests. (https://numaro.tech/assets/research/faster-kernels/depthwise-shape-map.svg) Method: Each kernel targets a specific production gap: not enough occupancy, an avoidable memory pass, a missing primitive, or a launch-heavy loop. Method steps: - Mapped where cuBLAS/cuDNN/PyTorch under-filled the GPU or forced extra memory traffic. - Wrote narrow Triton kernels for those exact regimes instead of trying to beat vendor libraries everywhere. - Timed stock and custom kernels back-to-back under a GPU timing lock. - Kept losses in the report so the boundary of the method is visible. Verification: Each subdirectory has a verifier that checks correctness before speed. Some kernels are bit-identical; others are compared against a higher-precision or stock reference with an explicit tolerance where reduction order differs. Scope: All numbers are on one L40S under the stated environment. They are not claims for every GPU, every shape, or cross-library SOTA. Large square GEMM and 4-bit weight-only decode are explicitly not beaten. Baseline sources: - NVIDIA cuBLAS documentation. (https://docs.nvidia.com/cuda/cublas/) - NVIDIA cuDNN documentation. (https://docs.nvidia.com/deeplearning/cudnn/) - Triton language documentation. (https://triton-lang.org/) - FlashAttention repository. (https://github.com/Dao-AILab/flash-attention) ## Circle packing in the unit square: new sum-of-radii layouts URL: https://numaro.tech/research/circle-packing-unit-square-2026/ Report: NUMARO-2026-004 Date: 2026-07-03 Authors: Numaro AI Autoresearch Team Domain: Geometry optimization Hero metric: 9 unit-square records beaten Plain-language summary: Circle packing is easy to check and hard to find. Circles either fit or they do not, but moving one circle changes the feasible radii of many others. Record layouts live in narrow local basins, and some margins are only around 1e-4, so a candidate has to survive exact overlap and wall checks rather than just look better. Key details: - For n=26, the result clears AlphaEvolve and ShinkaEvolve, and is effectively tied with ThetaEvolve at the same optimum-level value while using a stricter feasibility tolerance. - For n=33-40, the public table had recent automated-sweep values that heavier search could still improve; the hard part is escaping layout topologies that look stable but are not record-level. - For n=41 and n=42, the table had no entry, so the results are frontier extensions rather than beats. Hard part: The verifier is binary, but the search space is not a list ; it is a continuous landscape of circle centers plus a changing contact graph. For n=36, that is already 72 center coordinates before the radii are recomputed. The useful analogy is closer to finding one valid atom in a universe-sized cloud of arrangements : most near-record layouts fail because one tiny overlap, wall violation, or wrong contact pattern destroys the value once the radii are solved exactly. Technical claim: We pack n non-overlapping circles in the unit square to maximize the sum of radii. The campaign improves the public n=26 AlphaEvolve benchmark and the n=33-40 values on Erich Friedman's table, and gives first-known values for n=41 and n=42. These are best-known values, not optimality proofs. Result rows: - n=26: baseline 2.63586276 (https://erich-friedman.github.io/packing/cirRsqu/); Numaro 2.6359830853; delta +0.000120; note: AlphaEvolve benchmark - n=33: baseline 2.9789 (https://erich-friedman.github.io/packing/cirRsqu/); Numaro 2.9872850086; delta +0.008385; note: Viquerat June 2026 - n=36: baseline 3.11023 (https://erich-friedman.github.io/packing/cirRsqu/); Numaro 3.1210039084; delta +0.010774; note: largest margin in the set - n=40: baseline 3.28632 (https://erich-friedman.github.io/packing/cirRsqu/); Numaro 3.2923915726; delta +0.006072; note: Viquerat June 2026 - n=41: baseline none listed (https://erich-friedman.github.io/packing/cirRsqu/); Numaro 3.3346864337; delta first-known; note: frontier extension - n=42: baseline none listed (https://erich-friedman.github.io/packing/cirRsqu/); Numaro 3.3769116039; delta first-known; note: frontier extension Visual notes: - The n=36 layout: The actual coordinates for the largest-margin record in the set. Thin internal lines mark near-contact pairs; the square boundary is the constraint. (https://numaro.tech/assets/research/circle-packing/layout-n36.svg?v=2) - Record margins: The margin chart keeps the scale honest: n=36 is the clear outlier, while n=34 is a small but strict table beat. (https://numaro.tech/assets/research/circle-packing/record-margins.svg?v=2) - Frontier shape: Solid points are the new layouts. The dashed line is the prior public table where it exists; the open points are first-known n greater than 40. (https://numaro.tech/assets/research/circle-packing/frontier.svg?v=2) Method: The system searches circle centers, then uses a linear-program referee to assign the best feasible radii for those centers. Method steps: - Reproduced the public baselines and fixed them as dated targets. - Ran GPU multistart, island genetic search, adaptive basin hopping, and analytic-Jacobian SLSQP. - Used cross-n seeding: a good n layout seeds n+1 by adding a circle, and n-1 by removing one. - Rejected higher-looking values when the LP or overlap checker showed they were tolerance artifacts. Verification: Each layout is checked from its raw coordinates. Every pair of circles must be far enough apart, every circle must stay inside the square, and the final score is the sum of all radii. The reported beats are then compared against the dated public baseline values. Scope: The records are best-known feasible packings, not proofs of optimality. Values are pinned to the dated public baselines named in the report. Baseline sources: - Erich Friedman, Circles in Squares / Packing Copies to Maximize Total Perimeter. (https://erich-friedman.github.io/packing/cirRsqu/) - DeepMind AlphaEvolve. (https://deepmind.google/discover/blog/alphaevolve-a-gemini-powered-coding-agent-for-designing-advanced-algorithms/) - Sakana AI comparison systems. (https://sakana.ai/shinka-evolve/) ## Maximizing total radius in triangle and pentagon containers URL: https://numaro.tech/research/friedman-packing-center-2026/ Report: NUMARO-2026-005 Date: 2026-07-03 Authors: Numaro AI Autoresearch Team Domain: Geometry optimization Hero metric: 17 verified entries Plain-language summary: This is the same test as circle packing in the unit square, but with harder walls. The square is replaced by a triangle or a pentagon, so the contact patterns change and the system has to rebuild the search around new constraints instead of reusing one fixed geometry. Key details: - The three clear beats are pentagon n=15, triangle n=27, and triangle n=30. - Friedman's page prints values with a trailing plus, so hidden digits may exist. A beat only counts when the new layout clears the whole hidden-digit window. - Pentagon n=21-30 and triangle n=31-34 had no listed value, so those rows are frontier extensions rather than beats. Hard part: As in the square-packing page, the search is a continuous layout problem , not a finite checklist. Here there is a second trap: the published baselines are rounded down and marked with '+', so a tiny numerical improvement may still be inside the hidden digits . A record only counts when it clears the whole printed window . Technical claim: We improve three entries in Erich Friedman's Packing Center for unequal circles in a triangle or pentagon, and report first-known values for higher-n pentagon and triangle instances. A beat is claimed only when the new value clears the whole display-truncation window. Result rows: - cirRpen n=15: baseline 2.61251 (https://erich-friedman.github.io/packing/cirRpen/); Numaro 2.612714; delta +0.00020; note: Viquerat June 2026 - cirRtri n=27: baseline 1.76300 (https://erich-friedman.github.io/packing/cirRtri/); Numaro 1.764217; delta +0.00122; note: Cantrell July 2011 - cirRtri n=30: baseline 1.86315 (https://erich-friedman.github.io/packing/cirRtri/); Numaro 1.865806; delta +0.00266; note: Viquerat June 2026 - cirRpen n=21: baseline none listed (https://erich-friedman.github.io/packing/cirRpen/); Numaro 3.088531; delta first-known; note: frontier extension - cirRpen n=22: baseline none listed (https://erich-friedman.github.io/packing/cirRpen/); Numaro 3.165663; delta first-known; note: frontier extension - cirRpen n=23: baseline none listed (https://erich-friedman.github.io/packing/cirRpen/); Numaro 3.247349; delta first-known; note: frontier extension - cirRpen n=24: baseline none listed (https://erich-friedman.github.io/packing/cirRpen/); Numaro 3.327581; delta first-known; note: frontier extension - cirRpen n=25: baseline none listed (https://erich-friedman.github.io/packing/cirRpen/); Numaro 3.391645; delta first-known; note: frontier extension - cirRpen n=26: baseline none listed (https://erich-friedman.github.io/packing/cirRpen/); Numaro 3.476635; delta first-known; note: frontier extension - cirRpen n=27: baseline none listed (https://erich-friedman.github.io/packing/cirRpen/); Numaro 3.539869; delta first-known; note: frontier extension - cirRpen n=28: baseline none listed (https://erich-friedman.github.io/packing/cirRpen/); Numaro 3.610265; delta first-known; note: frontier extension - cirRpen n=29: baseline none listed (https://erich-friedman.github.io/packing/cirRpen/); Numaro 3.681347; delta first-known; note: frontier extension - cirRpen n=30: baseline none listed (https://erich-friedman.github.io/packing/cirRpen/); Numaro 3.745880; delta first-known; note: frontier extension - cirRtri n=31: baseline none listed (https://erich-friedman.github.io/packing/cirRtri/); Numaro 1.894825; delta first-known; note: frontier extension - cirRtri n=32: baseline none listed (https://erich-friedman.github.io/packing/cirRtri/); Numaro 1.923736; delta first-known; note: frontier extension - cirRtri n=33: baseline none listed (https://erich-friedman.github.io/packing/cirRtri/); Numaro 1.956110; delta first-known; note: frontier extension - cirRtri n=34: baseline none listed (https://erich-friedman.github.io/packing/cirRtri/); Numaro 1.988375; delta first-known; note: frontier extension Visual notes: - Triangle n=30 layout: The highest-margin triangle beat in the report. The container changes the search: wall contacts are now angled edge constraints, not square boundaries. (https://numaro.tech/assets/research/friedman-packing/triangle-n30.svg?v=1) - Pentagon n=15 layout: The pentagon record uses the same raw-coordinate check as the square-packing page, but with five edge half-planes instead of four square walls. (https://numaro.tech/assets/research/friedman-packing/pentagon-n15.svg?v=1) - The hidden-digit gate: Friedman prints a value with '+', so the visible number is only a floor. The chart shows each claimed beat clearing the whole hidden-digit window. (https://numaro.tech/assets/research/friedman-packing/clear-beat-gate.svg?v=1) Method: The system searches circle centers inside each container, then recomputes the best radii for those centers. It keeps only layouts whose score survives the final geometry check and the printed-baseline gate. Method steps: - Reused the square-packing search loop, but replaced square walls with triangle and pentagon edge constraints. - Tried many center layouts using multistart search and topology perturbations. - Recomputed the best feasible radii for promising center layouts instead of trusting the optimizer's radii. - Counted a beat only when the final value cleared Friedman's full printed window. Verification: Each layout is checked from raw coordinates. Every circle must stay inside the triangle or pentagon, every pair of circles must stay disjoint, and the final score is the sum of all radii. For the three record claims, the score also has to clear the hidden digits allowed by Friedman's printed plus sign. Scope: Only the three clear beats are record claims. Values that merely match within Friedman's display window are not counted, and the frontier rows are first-known feasible layouts rather than optimality proofs. Baseline sources: - Erich Friedman, Packing Copies to Maximize Total Perimeter. (https://erich-friedman.github.io/packing/) - Friedman, Circles in Triangles. (https://erich-friedman.github.io/packing/cirRtri/) - Friedman, Circles in Pentagons. (https://erich-friedman.github.io/packing/cirRpen/) ## Covering-design records improving the La Jolla Covering Repository URL: https://numaro.tech/research/covering-designs-la-jolla-2026/ Report: NUMARO-2026-006 Date: 2026-07-03 Authors: Numaro AI Autoresearch Team Domain: Extremal combinatorics Hero metric: 6,440 blocks saved Plain-language summary: This result matters because the system treated the repository as a dependency graph, not just a list of numbers. A better source covering can imply a better derived covering. The record only counts after the derived object is actually built and checked. Key details: - A (v,k,t)-covering is a set of k-point blocks. Every t-point subset must appear inside at least one block; fewer blocks is better. - The four records come from the standard induction relation C(v,k,t) <= C(v-1,k-1,t-1) + C(v-1,k,t). - This is not a claim that the source coverings are new. The win is detecting the unpropagated derived cells, materializing the witnesses, and checking them. Hard part: The verifier asks a binary question, but the checklist is enormous . C(92,7,4) means 131,122 explicit seven-point blocks and 2,794,155 four-subsets to cover, which is still small enough to enumerate. For the three t=7/8 rows, the checklist jumps to 2.9 x 10^9 to 2.1 x 10^10 subsets , so the proof has to move through the R4 induction theorem and the two LJCR source coverings. The trap is simple: a table inequality is not yet a witness . Technical claim: A covering design is a compression problem: cover every t-subset with as few k-blocks as possible. Four constructions use 6,440 fewer blocks in total than the La Jolla Covering Repository values recorded for our July 3, 2026 report. The headline C(92,7,4) row is checked by enumerating all 2,794,155 four-subsets. Coverage of the larger t=7/8 rows follows from the standard induction theorem, conditional on the validity of the original LJCR source coverings. Result rows: - C(77,25,8): baseline 179,223 (https://ljcr.dmgordon.org/show_cover.php?v=77&k=25&t=8); Numaro 175,063; delta -4,160; note: R4 theorem - C(92,7,4): baseline 132,580 (https://ljcr.dmgordon.org/show_cover.php?v=92&k=7&t=4); Numaro 131,122; delta -1,458; note: exhaustive: 2,794,155 subsets - C(86,23,7): baseline 153,683 (https://ljcr.dmgordon.org/show_cover.php?v=86&k=23&t=7); Numaro 153,047; delta -636; note: R4 theorem - C(79,21,7): baseline 165,213 (https://ljcr.dmgordon.org/show_cover.php?v=79&k=21&t=7); Numaro 165,027; delta -186; note: R4 theorem Visual notes: - Blocks saved: The largest row saves 4,160 blocks; all four rows are strictly below the La Jolla values recorded for the July 2026 report. (https://numaro.tech/assets/research/covering-designs/record-savings.svg) - The induction witness: Each derived covering is built from two source coverings through the standard R4 construction. (https://numaro.tech/assets/research/covering-designs/r4-source-split.svg) - Checklist scale: The t=4 row can be enumerated directly. The t=7 and t=8 rows are too large for brute-force enumeration here, so the proof goes through the theorem and the source coverings. (https://numaro.tech/assets/research/covering-designs/coverage-scale.svg) Method: The campaign parsed the LJCR table, propagated standard covering relations to a fixpoint, and kept the four cells where the table snapshot lagged the induction construction. Method steps: - Fetched and parsed 9,482 LJCR entries. - Applied delete-point, enlarge-block, reduce-t, and R4 induction relations. - Built each derived covering from the two linked LJCR source coverings. - Checked nearby mature cells with CP-SAT and simulated annealing; those attempts matched records but did not beat them. Verification: Each candidate has to have the claimed number of blocks, the right block size, and points in the correct range. For C(92,7,4), every one of the 2,794,155 four-point subsets is checked directly. For the larger rows, the check rebuilds the two source counts and uses the standard induction theorem: subsets containing the new point are covered by one source; subsets not containing it are covered by the other. Scope: These constructions improve the LJCR comparison values recorded for the July 2026 report; we have not established that they remain current records. No optimality proof or new source covering is claimed. C(92,7,4) has independent exhaustive coverage verification. The three t=7/8 constructions rely on the original LJCR source coverings being valid; their source coverage was not independently enumerated. Practical savings in a laboratory or production system have not been measured. Baseline sources: - D. Gordon, La Jolla Covering Repository. (https://ljcr.dmgordon.org/) - La Jolla individual covering lookup. (https://ljcr.dmgordon.org/show_cover.php) - Dan Gordon’s current covering-design guide and dataset links. (https://dmgordon.org/covering-designs/) - La Jolla Combinatorics Repository: downloadable dataset and notebooks. (https://github.com/dmgordo/LJCR) - Covering Repository: later improvements, linked by Dan Gordon. (https://coveringrepository.com/) - Pflüger et al. (2026), A General Group Testing Strategy for Discovering Chemical Cooperativity. (https://pmc.ncbi.nlm.nih.gov/articles/PMC12970518/) - NIST: covering arrays for software and hardware testing. (https://math.nist.gov/coveringarrays/ipof/ipof-abstract.html) - Saved covering designs, verification scope, and source counts (JSON). (/assets/research/covering-designs/records-summary.json) ## Covering-array records improving Colbourn's best-known CAN tables URL: https://numaro.tech/research/covering-arrays-colbourn-2026/ Report: NUMARO-2026-007 Date: 2026-07-03 Authors: Numaro AI Autoresearch Team Domain: Combinatorial testing Hero metric: 40 array table improvements Plain-language summary: Covering arrays are compact test suites: every t-way interaction still appears, but fewer rows means fewer tests. This result matters because it separates a promised size from a built object. The array has to exist before it can be a record. Key details: - CA(N;t,k,v) means N rows, k columns, and v symbols. For every choice of t columns, all v^t tuples must appear somewhere. - The largest margins come from ordered-design constructions; most of the individual cells come from Torres-Jimenez binary arrays. - Some attractive size predictions were rejected because they did not build at the claimed size. The kept rows are actual arrays. Hard part: A smaller size prediction is not a record until it is an array. Each candidate had to be materialized as an N x k table, then checked against every C(k,t) column set and every v^t tuple. One missing tuple turns the beat into a non-result . Technical claim: A covering array CA(N;t,k,v) is an N-row table that covers every t-column symbol tuple. We found 40 explicit arrays with fewer rows than the listed Colbourn CAN values, saving 1,042 rows total. The largest single improvement is CA(14928;3,8,24), down from 15,180 to 14,928. Result rows: - CA(14928;3,8,24): baseline 15,180 (https://www.data2intelligence.de/ColbournTables/t3v24.html); Numaro 14,928; delta -252 rows; note: ordered design - CA(8760;3,8,20): baseline 8,930 (https://www.data2intelligence.de/ColbournTables/t3v20.html); Numaro 8,760; delta -170 rows; note: ordered design - CA(9330;3,12,20): baseline 9,500 (https://www.data2intelligence.de/ColbournTables/t3v20.html); Numaro 9,330; delta -170 rows; note: ordered design - CA(6444;3,8,18): baseline 6,579 (https://www.data2intelligence.de/ColbournTables/t3v18.html); Numaro 6,444; delta -135 rows; note: ordered design - CA(143;4,199,2): baseline 154 (https://www.data2intelligence.de/ColbournTables/t4v2.html); Numaro 143; delta -11 rows; note: Torres-Jimenez - CA(2215;3,16,10): baseline 2,223 (https://www.data2intelligence.de/ColbournTables/t3v10.html); Numaro 2,215; delta -8 rows; note: CK doubling - CA(421;6,29,2): baseline 426 (https://www.data2intelligence.de/ColbournTables/t6v2.html); Numaro 421; delta -5 rows; note: Torres-Jimenez - CA(2615;3,41,10): baseline 2,618 (https://www.data2intelligence.de/ColbournTables/t3v10.html); Numaro 2,615; delta -3 rows; note: Dwyer database Visual notes: - Rows saved: The ordered-design rows create the largest margins; the full run contains 40 table improvements. (https://numaro.tech/assets/research/covering-arrays/record-margins.svg) - Where the savings came from: Ordered design accounts for most rows saved, while Torres-Jimenez accounts for most individual cells. (https://numaro.tech/assets/research/covering-arrays/construction-breakdown.svg) - One actual witness: This is the stored CA(143;4,199,2) binary array rendered as a barcode, not a schematic. (https://numaro.tech/assets/research/covering-arrays/array-slice-t4-k199-v2.svg) Method: The campaign compared listed CAN values against arrays obtainable from standard construction catalogues, then built the candidates and kept only arrays that actually checked out. Method steps: - Triple-confirmed the Colbourn baseline values from the mirror and CAs package data. - Used construction catalogues to propose smaller N values. - Materialized each candidate as an explicit array; predictions that failed to build at the claimed size were dropped. - Checked every kept array against every column-subset and tuple requirement. Verification: For each array, the checker reads the N x k table, checks that every entry is in the allowed symbol range, then tries every choice of t columns and confirms that all v^t tuples appear. All 40 kept arrays pass with zero missing requirements. Scope: These are best-known improvements, not optimality proofs. The underlying arrays come from published constructions and catalogues. The contribution is detecting the table-beating cells, building the objects, and checking them from scratch. Baseline sources: - Colbourn covering-array table snapshot, example t=3 v=24 table. (https://www.data2intelligence.de/ColbournTables/t3v24.html) - Groemping, CAs R package. (https://github.com/ugroempi/CAs) - Dwyer covering-array database. (https://github.com/aadwyer/CA_Database) ## New lower bounds for Zarankiewicz numbers URL: https://numaro.tech/research/zarankiewicz-2026/ Report: NUMARO-2026-008 Date: 2026-07-03 Authors: Numaro AI Autoresearch Team Domain: Extremal combinatorics Hero metric: 31 lower bounds raised Plain-language summary: This result matters because every claimed number has to be carried by an explicit matrix. A larger lower bound is not a guess: it is a concrete 0/1 object whose forbidden 3 by 3 pattern can be checked directly. Key details: - The largest gain is z(12,21), where the lower bound moves from 116 to 126. - The headline small witness is z(13,17;3,3) >= 110. - Two values are pinned exactly because the new lower bound reaches the known upper bound: z(10,20)=102 and z(11,18)=101. Hard part: The rule is local, but the search is global . A candidate can have many 1s and still fail because three rows share three columns somewhere in the matrix. For z(16,23), that means checking C(16,3) x C(23,3) possible 3 by 3 submatrices. One forbidden block destroys the whole witness . Technical claim: The Zarankiewicz number z(m,n;3,3) is the maximum number of 1s in an m by n matrix with no 3 by 3 all-ones submatrix. We give 31 stronger lower bounds, adding 150 total 1s across the checked grid. Two cells reach the known upper bound and are therefore exact: z(10,20;3,3)=102 and z(11,18;3,3)=101. Result rows: - z(12,21;3,3): baseline 116 (https://arxiv.org/abs/2605.01120); Numaro 126; delta +10; note: largest gain - z(12,23;3,3): baseline 125 (https://arxiv.org/abs/2605.01120); Numaro 134; delta +9; note: also follows past a monotone anchor - z(16,19;3,3): baseline 132 (https://arxiv.org/abs/2605.01120); Numaro 141; delta +9; note: explicit witness - z(14,23;3,3): baseline 138 (https://arxiv.org/abs/2605.01120); Numaro 146; delta +8; note: explicit witness - z(10,20;3,3): baseline 99 (https://arxiv.org/abs/2605.01120); Numaro 102; delta +3; note: exact; reaches known upper bound - z(11,18;3,3): baseline 97 (https://arxiv.org/abs/2605.01120); Numaro 101; delta +4; note: exact; reaches known upper bound Visual notes: - Frontier heatmap: Top number is the known upper bound; bottom number is the Numaro lower bound. White cells are exact values. (https://numaro.tech/assets/research/zarankiewicz/frontier-heatmap.svg) - Actual witness matrices: Three stored 0/1 matrices: the two exact cells and the headline z(13,17) witness. (https://numaro.tech/assets/research/zarankiewicz/witness-matrices.svg) - Largest moves: The biggest frontier move is z(12,21), from 116 to 126 ones. (https://numaro.tech/assets/research/zarankiewicz/gain-bars.svg) Method: The campaign used two levers: monotonicity of the table and exact search for K3,3-free matrices. Each new witness was then propagated through the grid where adding a zero row or column preserves validity. Method steps: - Read the known lower and upper bounds cell by cell. - Applied monotonicity: increasing m or n cannot make the best lower bound smaller. - Solved selected cells with an OR-Tools CP-SAT model for K3,3-free matrices. - Verified every saved matrix and excluded z(12,17), where the saved witness did not beat the baseline. Verification: The checker counts 1s and tests every triple of rows. If any three rows share three columns, the matrix contains a forbidden 3 by 3 all-ones block and the witness fails. The 31 reported matrices pass this direct check. Scope: Except for z(10,20)=102 and z(11,18)=101, these are improved lower bounds, not exact values. The baseline numbers are the previously published lower and upper bounds used for comparison. Baseline sources: - New Bounds for Zarankiewicz Numbers via Reinforced LLM Evolutionary Search, arXiv:2605.01120. (https://arxiv.org/abs/2605.01120) - OR-Tools CP-SAT. (https://developers.google.com/optimization/cp/cp_solver) ## First-known no-five-on-sphere values for [n]^3 URL: https://numaro.tech/research/no-5-on-sphere-2026/ Report: NUMARO-2026-009 Date: 2026-07-03 Authors: Numaro AI Autoresearch Team Domain: Discrete geometry Hero metric: 13 first-known values Plain-language summary: This result matters because the object is concrete. For each n, the claim is just a list of integer grid points. The set counts only if every group of five points avoids both failure modes: lying on one plane or lying on one sphere. Key details: - AlphaEvolve published anchors through n=12. The campaign reproduced those anchors, but did not improve them. - n=13 reached only the monotone floor from C(12), so it is not claimed. - The first claimed row is C(14) >= 34, and the largest saved witness is C(26) >= 56. Hard part: For n=26, the cube has 17,576 possible grid points , and the search is choosing 56 of them. That choice space is astronomically large. The checker is binary, but each candidate has to survive C(56,5) = 3,819,816 five-point tests. One coplanar or cospherical group destroys the whole set . Technical claim: For grid sizes n=14 through n=26, we give explicit point sets in [n]^3 with no five points on one sphere or plane. AlphaEvolve's problem portfolio published anchors through C(12) >= 33; the n >= 13 range was open. These entries extend the public frontier and are checked from raw integer coordinates. Result rows: - C(14): baseline none listed (https://arxiv.org/abs/2511.02864); Numaro >=34; delta first-known; note: first claimed row - C(15): baseline none listed (https://arxiv.org/abs/2511.02864); Numaro >=35; delta first-known; note: integer-coordinate witness - C(16): baseline none listed (https://arxiv.org/abs/2511.02864); Numaro >=39; delta first-known; note: integer-coordinate witness - C(17): baseline none listed (https://arxiv.org/abs/2511.02864); Numaro >=40; delta first-known; note: integer-coordinate witness - C(18): baseline none listed (https://arxiv.org/abs/2511.02864); Numaro >=40; delta first-known; note: integer-coordinate witness - C(19): baseline none listed (https://arxiv.org/abs/2511.02864); Numaro >=43; delta first-known; note: integer-coordinate witness - C(20): baseline none listed (https://arxiv.org/abs/2511.02864); Numaro >=45; delta first-known; note: integer-coordinate witness - C(21): baseline none listed (https://arxiv.org/abs/2511.02864); Numaro >=46; delta first-known; note: integer-coordinate witness - C(22): baseline none listed (https://arxiv.org/abs/2511.02864); Numaro >=50; delta first-known; note: integer-coordinate witness - C(23): baseline none listed (https://arxiv.org/abs/2511.02864); Numaro >=51; delta first-known; note: integer-coordinate witness - C(24): baseline none listed (https://arxiv.org/abs/2511.02864); Numaro >=53; delta first-known; note: integer-coordinate witness - C(25): baseline none listed (https://arxiv.org/abs/2511.02864); Numaro >=55; delta first-known; note: integer-coordinate witness - C(26): baseline none listed (https://arxiv.org/abs/2511.02864); Numaro >=56; delta first-known; note: largest listed n Visual notes: - Open frontier: Muted points are the published AlphaEvolve anchors through n=12. White points are Numaro first-known rows for n=14 through n=26. (https://numaro.tech/assets/research/no-5-on-sphere/frontier-sequence.svg) - Actual C(26) witness: The 56 points are rendered from the saved n=26 coordinate file. The projection is visual only; the check uses exact 3D integer coordinates. (https://numaro.tech/assets/research/no-5-on-sphere/n26-witness.svg) - Check load: For the n=26 row, the exact check has to reject 3,819,816 possible five-point groups. (https://numaro.tech/assets/research/no-5-on-sphere/subset-scale.svg) Method: The campaign treated the count of bad five-point groups as the search signal. A candidate is valid only when that count reaches zero. Method steps: - Reproduced the published AlphaEvolve anchors C(11)=31 and C(12)=33 for calibration. - For each open n, searched random integer point sets of increasing size. - Used the number of coplanar or cospherical five-point subsets as feedback during search. - Recorded only coordinate sets whose bad-five count reached zero. Verification: The check looks at every group of five saved points. It uses an exact integer determinant: if the determinant is zero, those five points lie on one plane or one sphere. The reported sets have zero such groups; no floating-point geometry is used. Scope: These are first-known lower bounds for open n values, not optimality proofs. They do not beat AlphaEvolve's published C(11) or C(12) values, and n=13 is not claimed because the search did not move past the monotone floor. Baseline sources: - Georgiev, Gomez-Serrano, Tao, Wagner, AlphaEvolve problem portfolio, arXiv:2511.02864, Problem 6.60. (https://arxiv.org/abs/2511.02864) - DeepMind AlphaEvolve overview. (https://deepmind.google/discover/blog/alphaevolve-a-gemini-powered-coding-agent-for-designing-advanced-algorithms/) ## First-known no-isosceles grid sets for open n values URL: https://numaro.tech/research/no-isosceles-grid-2026/ Report: NUMARO-2026-010 Date: 2026-07-03 Authors: Numaro AI Autoresearch Team Domain: Discrete geometry Hero metric: 54 first-known grid values Plain-language summary: This result matters because the rule is local and exact. A set is valid only if no chosen point sees two other chosen points at the same squared distance. That one repeated distance would immediately create an isosceles triangle. Key details: - AlphaEvolve published strong sets at n=64 and n=100, but not the open n values reported here. - The 54 claimed rows are the evolve_sweep records in RECORDS.jsonl. - The largest reported sets are n=77 and n=79, each with 116 selected points. Hard part: For n=77, the grid has 5,929 possible points and the set keeps 116. The verifier is fast, but the search is brittle: around every selected point, all 115 squared distances to the other selected points must be different. One repeated distance around any anchor creates an isosceles triangle . Technical claim: We report no-isosceles-triangle subsets of the n by n grid for 54 open n values from 22 through 79. These are first-known lower bounds for untabulated sizes, with sizes up to 116. The published AlphaEvolve n=64 and n=100 results are not beaten. Result rows: - n=22: baseline none listed (https://arxiv.org/abs/2511.02864); Numaro 36; delta first-known; note: first claimed row - n=23: baseline none listed (https://arxiv.org/abs/2511.02864); Numaro 40; delta first-known; note: integer-coordinate set - n=24: baseline none listed (https://arxiv.org/abs/2511.02864); Numaro 40; delta first-known; note: integer-coordinate set - n=25: baseline none listed (https://arxiv.org/abs/2511.02864); Numaro 40; delta first-known; note: integer-coordinate set - n=26: baseline none listed (https://arxiv.org/abs/2511.02864); Numaro 42; delta first-known; note: integer-coordinate set - n=27: baseline none listed (https://arxiv.org/abs/2511.02864); Numaro 44; delta first-known; note: integer-coordinate set - n=29: baseline none listed (https://arxiv.org/abs/2511.02864); Numaro 48; delta first-known; note: integer-coordinate set - n=31: baseline none listed (https://arxiv.org/abs/2511.02864); Numaro 52; delta first-known; note: integer-coordinate set - n=32: baseline none listed (https://arxiv.org/abs/2511.02864); Numaro 52; delta first-known; note: integer-coordinate set - n=33: baseline none listed (https://arxiv.org/abs/2511.02864); Numaro 52; delta first-known; note: integer-coordinate set - n=35: baseline none listed (https://arxiv.org/abs/2511.02864); Numaro 56; delta first-known; note: integer-coordinate set - n=36: baseline none listed (https://arxiv.org/abs/2511.02864); Numaro 56; delta first-known; note: integer-coordinate set - n=37: baseline none listed (https://arxiv.org/abs/2511.02864); Numaro 64; delta first-known; note: integer-coordinate set - n=38: baseline none listed (https://arxiv.org/abs/2511.02864); Numaro 60; delta first-known; note: integer-coordinate set - n=39: baseline none listed (https://arxiv.org/abs/2511.02864); Numaro 60; delta first-known; note: integer-coordinate set - n=40: baseline none listed (https://arxiv.org/abs/2511.02864); Numaro 64; delta first-known; note: integer-coordinate set - n=41: baseline none listed (https://arxiv.org/abs/2511.02864); Numaro 64; delta first-known; note: integer-coordinate set - n=42: baseline none listed (https://arxiv.org/abs/2511.02864); Numaro 64; delta first-known; note: integer-coordinate set - n=43: baseline none listed (https://arxiv.org/abs/2511.02864); Numaro 68; delta first-known; note: integer-coordinate set - n=44: baseline none listed (https://arxiv.org/abs/2511.02864); Numaro 68; delta first-known; note: integer-coordinate set - n=45: baseline none listed (https://arxiv.org/abs/2511.02864); Numaro 72; delta first-known; note: integer-coordinate set - n=46: baseline none listed (https://arxiv.org/abs/2511.02864); Numaro 70; delta first-known; note: integer-coordinate set - n=47: baseline none listed (https://arxiv.org/abs/2511.02864); Numaro 72; delta first-known; note: integer-coordinate set - n=48: baseline none listed (https://arxiv.org/abs/2511.02864); Numaro 74; delta first-known; note: integer-coordinate set - n=49: baseline none listed (https://arxiv.org/abs/2511.02864); Numaro 76; delta first-known; note: integer-coordinate set - n=50: baseline none listed (https://arxiv.org/abs/2511.02864); Numaro 78; delta first-known; note: integer-coordinate set - n=51: baseline none listed (https://arxiv.org/abs/2511.02864); Numaro 80; delta first-known; note: integer-coordinate set - n=52: baseline none listed (https://arxiv.org/abs/2511.02864); Numaro 80; delta first-known; note: integer-coordinate set - n=53: baseline none listed (https://arxiv.org/abs/2511.02864); Numaro 84; delta first-known; note: integer-coordinate set - n=54: baseline none listed (https://arxiv.org/abs/2511.02864); Numaro 80; delta first-known; note: integer-coordinate set - n=55: baseline none listed (https://arxiv.org/abs/2511.02864); Numaro 84; delta first-known; note: integer-coordinate set - n=56: baseline none listed (https://arxiv.org/abs/2511.02864); Numaro 84; delta first-known; note: integer-coordinate set - n=57: baseline none listed (https://arxiv.org/abs/2511.02864); Numaro 88; delta first-known; note: integer-coordinate set - n=58: baseline none listed (https://arxiv.org/abs/2511.02864); Numaro 92; delta first-known; note: integer-coordinate set - n=59: baseline none listed (https://arxiv.org/abs/2511.02864); Numaro 92; delta first-known; note: integer-coordinate set - n=60: baseline none listed (https://arxiv.org/abs/2511.02864); Numaro 92; delta first-known; note: integer-coordinate set - n=61: baseline none listed (https://arxiv.org/abs/2511.02864); Numaro 92; delta first-known; note: integer-coordinate set - n=62: baseline none listed (https://arxiv.org/abs/2511.02864); Numaro 92; delta first-known; note: integer-coordinate set - n=63: baseline none listed (https://arxiv.org/abs/2511.02864); Numaro 96; delta first-known; note: neighbor of published n=64 - n=65: baseline none listed (https://arxiv.org/abs/2511.02864); Numaro 96; delta first-known; note: neighbor of published n=64 - n=66: baseline none listed (https://arxiv.org/abs/2511.02864); Numaro 100; delta first-known; note: integer-coordinate set - n=67: baseline none listed (https://arxiv.org/abs/2511.02864); Numaro 104; delta first-known; note: integer-coordinate set - n=68: baseline none listed (https://arxiv.org/abs/2511.02864); Numaro 104; delta first-known; note: integer-coordinate set - n=69: baseline none listed (https://arxiv.org/abs/2511.02864); Numaro 104; delta first-known; note: integer-coordinate set - n=70: baseline none listed (https://arxiv.org/abs/2511.02864); Numaro 104; delta first-known; note: integer-coordinate set - n=71: baseline none listed (https://arxiv.org/abs/2511.02864); Numaro 112; delta first-known; note: integer-coordinate set - n=72: baseline none listed (https://arxiv.org/abs/2511.02864); Numaro 112; delta first-known; note: integer-coordinate set - n=73: baseline none listed (https://arxiv.org/abs/2511.02864); Numaro 112; delta first-known; note: integer-coordinate set - n=74: baseline none listed (https://arxiv.org/abs/2511.02864); Numaro 112; delta first-known; note: integer-coordinate set - n=75: baseline none listed (https://arxiv.org/abs/2511.02864); Numaro 112; delta first-known; note: integer-coordinate set - n=76: baseline none listed (https://arxiv.org/abs/2511.02864); Numaro 112; delta first-known; note: integer-coordinate set - n=77: baseline none listed (https://arxiv.org/abs/2511.02864); Numaro 116; delta first-known; note: largest value in table - n=78: baseline none listed (https://arxiv.org/abs/2511.02864); Numaro 112; delta first-known; note: integer-coordinate set - n=79: baseline none listed (https://arxiv.org/abs/2511.02864); Numaro 116; delta first-known; note: largest value in table Visual notes: - Open grid sizes: White points are Numaro first-known rows. Hollow points are AlphaEvolve's published n=64 and n=100 rows, which are not beaten. (https://numaro.tech/assets/research/no-isosceles-grid/open-frontier.svg) - Actual n=77 set: The 116 points are rendered from RECORDS.jsonl. The dashed midlines show the symmetry-preserving search space. (https://numaro.tech/assets/research/no-isosceles-grid/n77-witness.svg) - Distance test: For one anchor, each squared distance is unique. The checker repeats the same exact test around every selected point. (https://numaro.tech/assets/research/no-isosceles-grid/distance-rings.svg) Method: The campaign improved the generator of point sets, not just one fixed set. The best rows came from an evolved construction that keeps symmetry while adding and removing whole orbits of points. Method steps: - Loaded and checked the published AlphaEvolve n=64 and n=100 reference sets for calibration. - Observed that direct point-level search plateaued at lower density. - Evolved construction parameters for symmetry group, axis, ruin fraction, local search, and candidate count. - Kept the 54 evolve_sweep rows whose saved point sets pass the exact no-isosceles check. Verification: For each selected point P, the checker computes the squared distance from P to every other selected point. If a squared distance appears twice, P and those two points form an isosceles triangle, so the set fails. All 54 reported evolve_sweep rows pass this exact integer check. Scope: These are first-known lower bounds for open n values, not optimality proofs. They are not beats of AlphaEvolve's published n=64 and n=100 values. The missing open sizes in this sweep are n=28, n=30, and n=34; n=64 already had a published AlphaEvolve row. Baseline sources: - Georgiev, Gomez-Serrano, Tao, Wagner, AlphaEvolve problem portfolio, arXiv:2511.02864, Problem 6.59. (https://arxiv.org/abs/2511.02864) - DeepMind AlphaEvolve overview. (https://deepmind.google/discover/blog/alphaevolve-a-gemini-powered-coding-agent-for-designing-advanced-algorithms/) ## Constant-weight codes: one propagation beat and exact DCW fills URL: https://numaro.tech/research/constant-weight-codes-2026/ Report: NUMARO-2026-012 Date: 2026-07-03 Authors: Numaro AI Autoresearch Team Domain: Coding theory Hero metric: 442 exact DCW values Plain-language summary: A constant-weight code is a set of binary words with the same number of ones, kept far apart by Hamming distance. The main table is strong: direct search did not beat it. The one improvement came from a simple rule the table had not propagated, while the related doubly-constant-weight object had upper bounds but no comparable construction table. Key details: - The record beat is A(29,8,6) >= 131, compared with the listed 130. - The construction is simple: append a zero coordinate to Rosin's A(28,8,6)=131 code. - The 442 doubly-constant-weight values are first-recorded exact values, not beats of a lower-bound table. Hard part: The verifier is simple but the search space is combinatorial. A code of size 131 requires all C(131,2)=8,515 word pairs to stay at distance at least 8 while every word has exactly six ones. The honest result is that the main table was mostly too strong to out-search. Technical claim: We improve one listed constant-weight code value, A(29,8,6), by propagating a fresh A(28,8,6)=131 result that had not flowed into a frozen sub-table. We also materialize and prove exact 442 doubly-constant-weight values for an object that had upper bounds but no construction table. Result rows: - A(29,8,6): baseline 130 (https://www.win.tue.nl/~aeb/codes/Andw.html); Numaro >=131; delta +1; note: append-0 from A(28,8,6)=131 - T(2,10,2,10,6): baseline upper bound 35 (https://codes.se/bounds/dcw.html); Numaro 25 exact; delta first-recorded; note: proven below the published upper bound - T(2,6,2,15,4): baseline upper bound 120 (https://codes.se/bounds/dcw.html); Numaro 105 exact; delta first-recorded; note: proven below the published upper bound - T exact fills: baseline upper bounds only (https://codes.se/bounds/dcw.html); Numaro 442 values; delta new table; note: 404 meet upper bound; 38 below it - Main A(n,d,w) sweep: baseline Brouwer (https://www.win.tue.nl/~aeb/codes/Andw.html); Numaro 0 search beats; delta match-hard; note: record is propagation only Visual notes: - Propagation lag: The record beat is not a mysterious search jump: A(28,8,6)=131 lifts to A(29,8,6) by appending a zero coordinate. (https://numaro.tech/assets/research/constant-weight/propagation-lag.svg) - DCW gaps: The doubly-constant-weight rows are fills, not beats of a lower-bound table. These examples are exact values below the published upper bound. (https://numaro.tech/assets/research/constant-weight/dcw-gaps.svg) Method: The campaign first closed simple monotonicity relations in the constant-weight table, then used exact max-clique on the doubly-constant-weight object. Method steps: - Checked A(n,d,w) propagation by appending constant 0 or 1 coordinates. - Found the single unpropagated A(29,8,6) cell. - Modeled doubly-constant-weight cells as maximum cliques and solved them with CP-SAT. - Ran a broader exact/heuristic sweep on the main table and recorded that it did not beat. Verification: verify.py brute-force checks binary length, weights, distinctness, and all pairwise Hamming distances. Exactness of the DCW values rests on CP-SAT OPTIMAL status. Scope: A(29,8,6)>=131 is best-known, not optimal. The 442 DCW values are fills for an object without prior lower-bound tables, not record beats. Baseline sources: - Brouwer, Table of constant-weight binary codes A(n,d,w). (https://www.win.tue.nl/~aeb/codes/Andw.html) - Rosin, improved constant-weight code lower bounds, 2026. (https://arxiv.org/abs/2603.00174) - Agrell et al., doubly-constant-weight code upper bounds. (https://codes.se/bounds/dcw.html) ## qLDPC distances: exact certificates, zero corrections URL: https://numaro.tech/research/qldpc-distance-certificates-2026/ Report: NUMARO-2026-013 Date: 2026-07-03 Authors: Numaro AI Autoresearch Team Domain: Quantum error correction Hero metric: 19 exact certificates Plain-language summary: Quantum LDPC distance estimates are often produced by heuristic decoders. Exact certification is useful because it separates a proved distance from a decoder estimate. Here the risk was overstatement, but the accessible published coprime BB/GB rows held. Key details: - The campaign found no overstated distances in this target set. - For 19 codes, CP-SAT proves the exact distance equals the published distance. - For nine harder codes, the report gives only the proven lower bound and the best logical operator found. Hard part: Minimum distance asks for the lightest nontrivial logical operator. A heuristic decoder can miss a low-weight logical, so an exact certificate must prove that no smaller one exists. Nine larger codes timed out; those rows are reported as bounds, not guessed exact values. Technical claim: We certify exact minimum distances for 19 published coprime bivariate/generalized-bicycle quantum LDPC codes whose distances were previously BP-OSD estimates. Every certified value matched the published value. Nine larger codes remain bounded but not fully certified. Result rows: - [[18,4,4]]: baseline 4 BP-OSD (https://arxiv.org/abs/2408.10001); Numaro 4 exact; delta confirmed; note: BB family - [[48,4,8]]: baseline 8 BP-OSD (https://arxiv.org/abs/2408.10001); Numaro 8 exact; delta confirmed; note: GB family - [[66,4,10]]: baseline 10 BP-OSD (https://arxiv.org/abs/2408.10001); Numaro 10 exact; delta confirmed; note: GB family - [[196,18,8]]: baseline 8 BP-OSD (https://arxiv.org/abs/2408.10001); Numaro 8 exact; delta confirmed; note: BB family - 9 harder codes: baseline published (https://arxiv.org/abs/2408.10001); Numaro bounds only; delta uncertified; note: no overstatement evidence Visual notes: - Certificate status: The exact solver confirmed 19 published distances, timed out on 9 larger cases, and found zero lower-distance corrections. (https://numaro.tech/assets/research/qldpc/certificate-status.svg) - Distance ladder: Each point is a published coprime BB/GB code whose BP-OSD distance estimate was proved exact. (https://numaro.tech/assets/research/qldpc/distance-ladder.svg) Method: The campaign rebuilt each CSS code from published construction polynomials and solved the minimum logical-operator problem exactly where feasible. Method steps: - Implemented GF(2) linear algebra for CSS validity, ranks, and logical spaces. - Calibrated on textbook codes and known qLDPC anchors. - Modeled minimum-weight logical search with CP-SAT. - Separated exact certificates from timed-out bound-only cases. Verification: verify.py rebuilds H_X and H_Z, checks CSS validity and parameters, reruns the distance proof, and re-exhibits each witnessing logical operator. Scope: This is not a new-code result and not a record beat. It confirms 19 distances and reports bounds for unresolved larger cases. Baseline sources: - Wang and Mueller, Coprime Bivariate Bicycle Codes. (https://arxiv.org/abs/2408.10001) - IBM qLDPC / LLM-evolution calibration reference. (https://arxiv.org/abs/2606.02418) - QDistSAT exact qLDPC distance certification benchmark. (https://arxiv.org/abs/2606.12445) ## Learned mRNA coding-sequence designers are Pareto-suboptimal on their own objective URL: https://numaro.tech/research/mrna-codon-structure-design-2026/ Report: NUMARO-2026-014 Date: 2026-07-03 Authors: Numaro AI Autoresearch Team Domain: Sequence design Hero metric: 90/90 dominations reverified Plain-language summary: This matters because learned sequence designers are often evaluated on deterministic proxy objectives before wet-lab validation. If a simple deterministic baseline dominates a learned method on its own proxy, the learned method is leaving objective value on the table. The result stays inside that proxy boundary. Key details: - The comparison uses translation correctness, MFE/EFE, CAI, uridine fraction, and forbidden motifs as deterministic scores. - The strongest warning is also in the result: better proxy values do not imply better expression in cells. - LinearDesign is treated as an honest wall. It is exact on its own MFE/CAI objective and is not dominated. Hard part: A protein has many synonymous mRNA encodings, but every candidate must translate back to the same protein. A win only counts if the sequence is no worse on every scored axis and strictly better on at least one. The biological caveat is load-bearing: this is a proxy-objective result, not an expression claim. Technical claim: On the public 55-human-protein LinearDesign/CodonRL benchmark, deterministic sequence design plus verified polish produces translation-correct mRNA coding sequences that Pareto-dominate CodonRL on 54/54 usable proteins and GEMORNA on 35/54. LinearDesign itself is not dominated. Result rows: - CodonRL: baseline released soup55 (https://github.com/Kingsford-Group/codonrl); Numaro 54/54 dominated; delta all usable proteins; note: MFE, CAI, uridine - GEMORNA: baseline repo sequences (https://github.com/RainaBio/GEMORNA); Numaro 35/54 dominated; delta proxy improvement; note: 4-axis objective - EnsembleDesign: baseline EFE specialist (https://github.com/LinearFold/EnsembleDesign); Numaro 1 dominated; delta mostly ties; note: honest wall - LinearDesign: baseline exact MFE/CAI (https://www.nature.com/articles/s41586-023-06127-z); Numaro 0 dominated; delta not beaten; note: exact wall - Verifier: baseline recorded dominations; Numaro 90/90 pass; delta confirmed; note: translation and scores rechecked Visual notes: - Domination counts: CodonRL and GEMORNA are dominated on their stated proxy axes; LinearDesign is not, because it is exact on its own MFE/CAI objective. (https://numaro.tech/assets/research/mrna/domination-summary.svg) - Average movement: On dominated GEMORNA rows, the proxy movement is not one-dimensional: MFE, CAI, uridine, and motifs all move in the allowed direction on average. (https://numaro.tech/assets/research/mrna/gemorna-average-gains.svg) Method: The campaign combined deterministic seeds from exact or simple objectives with a ViennaRNA-in-the-loop local polish, accepting only candidates that re-scored as true Pareto improvements. Method steps: - Reproduced the scoring conventions used by the compared tools. - Generated seeds from maximum-CAI, minimum-uridine, and LinearDesign-guided sequences. - Polished candidates while rechecking translation and all objective values. - Separated proxy-objective statements from biological-expression claims. Verification: verify.py checks translation to the target protein, recomputes all deterministic scores, and rechecks each Pareto-domination claim from raw FASTA sequences. Scope: This is a computational proxy result only. It is not an in-cell expression claim, not a safety claim, and not a claim that lower MFE is always biologically better. Baseline sources: - LinearDesign, Nature 2023. (https://www.nature.com/articles/s41586-023-06127-z) - CodonRL benchmark and released checkpoint. (https://github.com/Kingsford-Group/codonrl) - GEMORNA repository. (https://github.com/RainaBio/GEMORNA) - EnsembleDesign repository. (https://github.com/LinearFold/EnsembleDesign)