https://arxiv.org/api/D1w14c0DUxqhjVRQn80Ylu5Cayc 2026-10-03T15:53:34Z 60 5885 0 http://arxiv.org/abs/2610.01922v1 2026-10-01T15:57:10Z

This paper introduces tellegen, an open source framework for interactive power flow (PF) and optimal power flow (OPF) studies that run in the browser. This provides intuitive and democratized access to power system analysis tools compiled to WebAssembly. A user can drag and drop a case file, click and drag to change a nodal demand or line rating, preview the impacts via sensitivity analysis, and obtain an exact re-solve on release. User case files and results stay entirely on the device: tellegen transmits zero Critical Energy/Electric Infrastructure Information (CEII). The framework comprises a core numerical engine for PF and OPF, reusable browser components, saved studies, and structured WebMCP tools for agentic interaction. We evaluate the transmission OPF solver by comparing objectives with PGLib baselines; the distribution PF solver by comparing voltages and currents with OpenDSS; and the WebAssembly execution times by comparing with PowerModels.jl. On realistic synthetic grids, WebAssembly OPF solves take only 25-43% longer than native binary solves. The implementation shows how an engineer can distribute an executable numerical study as a URL, reducing installation and hosting requirements while keeping case data local.

2026-10-01T15:57:10Z 9 pages, 3 figures, 6 tables. To appear in the Inaugural ACM Conference on Digital Transformation (ACM DXConf 2026), Ann Arbor, MI, USA Samuel Talkington Frederik Geth Qian Zhang Le Xie Skyler Liu http://arxiv.org/abs/2610.01338v1 2026-10-01T09:11:02Z

Every scalar ordinary differential equation of order at least three with rational right-hand side that is locally linearizable by a point transformation admits a linear form with rational coefficients over the same coefficient field. We prove this by restricting the derived symmetry algebra to a coordinate line and recovering a scalar differential operator from rational symmetry-jet data. The construction uses differential elimination and linear algebra; it does not require the symmetry generators or a linearizing transformation to be solved for. A single integer parameter suffices to choose the line.

2026-10-01T09:11:02Z 6 pages Dmitry Lyakhov http://arxiv.org/abs/2609.38492v1 2026-09-29T20:21:25Z

We present gap-lean4-port (Release v0.2.0), a machine-checked formalization of foundational algorithms in computational discrete algebra and permutation group theory within the Lean 4 interactive theorem prover and Mathlib4. While modern proof assistants feature extensive abstract algebraic hierarchies, constructive and operational permutation group algorithms, such as Charles Sims' 1970 Schreier-Sims algorithm, transversal tree lookups, and backtrack ordered partition refinement, have remained largely unformalized in dependent type theory. Here, we formalize the operational algorithmic core of the Groups, Algorithms, Programming (GAP) system library across four foundational modules, proving 35 machine-checked theorems with zero unproven conjectures (sorry) and zero custom axioms under standard Lean 4 foundations (propext, Classical.choice, Quot.sound). We machine-check: (1) Schreier-Sims stabilizer chain hierarchies (StabLevel, StabChain) and the invariance of incremental transversal tree extensions (extendSchreierPoint_invariant); (2) single-level and multi-level Schreier sifting reductions (siftOneLevel, siftFull), proving that full sifting strictly fixes all base points (siftFull_fixes_all_basePoints); (3) constructive soundness and completeness of Base and Strong Generating Set (BSGS) membership testing (membershipTestKnownBase_iff_mem); (4) backtrack ordered partition cell refinement (splitCellByPred), proving mutual cell disjointness, union conservation, and exact cardinality preservation; (5) cyclotomic extension rings Z/nZ(eps_m) and machine-check GAP's exact size theorem |Z/nZ(eps_m)| = n^m; and (6) executable Bezout inverses via Extended Euclidean GCD (Nat.gcdA) over residue rings Z/nZ. The entire codebase compiles deterministically under 'lake build RequestProject' and is openly available at https://github.com/pCwOrM/gap-lean4-port.

2026-09-29T20:21:25Z 3 pages, 1 table, Release v0.2.0, 35 machine-checked theorems with 0 sorry in Lean 4 / Mathlib4. Repository: https://github.com/pCwOrM/gap-lean4-port Volkan Dağlı Zerrin Dağlı Dağhan Dağlı 10.5281/zenodo.23045504 http://arxiv.org/abs/2609.37844v1 2026-09-29T15:41:20Z

Rounding errors in finite element computations can lead to a complete loss of accuracy, stalled convergence, and incorrect results. Moreover, the effects of rounding errors accumulated within automatically generated and compiled kernels are difficult to analyze a priori. We present the first software framework for automated rounding error estimation within finite element kernels. The proposed methodology is based on an a posteriori technique called Running Error Analysis (REA), where a forward error estimate is automatically computed concurrently with the value. An open-source implementation is provided for the FEniCS Form Compiler (FFCx), based on a C++ backend for generating type-generic templated kernels over a custom arithmetic type that tracks both the value and its error estimate. We demonstrate REA on two examples. First, we use it to detect catastrophic cancellation in the assembly of a Neo-Hooke hyperelastic model in the small deformation regime. A series expansion circumvents the cancellation problem and the computed error estimates show this. Second, we study the assembly of the Laplace operator on a near-degenerate mesh. We demonstrate that our REA implementation typically incurs only 2-4x performance overhead. Applications of this work include robust reduced-precision computations in embedded systems, numerical debugging of new, possibly ill-conditioned or unstable PDE formulations, and guiding the design of mixed-precision kernels.

2026-09-29T15:41:20Z 18 pages Michal Habera Paul T. Kühner Matteo Croci Andreas Zilian http://arxiv.org/abs/2609.37610v1 2026-09-29T13:55:36Z

Schreyer's algorithm is usually the fastest way to determine a (typically non-minimal) free resolution of a finitely presented module over a polynomial ring. We adapt a refined version of Schreyer's algorithm to compute free resolutions over the exterior algebra, relying on relative Groebner bases. We illustrate the use of our algorithm for the computation of cohomology of coherent sheaves over projective space, which by the BGG correspondence can be computed via free resolutions over the exterior algebra. Schreyer's method relies on a tree traversal and thus has the potential for parallel computations. We report on ongoing work on a massively parallel implementation, observing that Gnawali's parallel approach over polynomial rings can be carried over to our setting.

2026-09-29T13:55:36Z 26 pages, 5 figures Janko Boehm Lakshmi Ramesh http://arxiv.org/abs/2609.37137v1 2026-09-29T09:39:27Z

Reduced and mixed precision have moved from a niche optimization to a central design axis in scientific computing and engineering, driven by energy constraints, heterogeneous accelerators, and the convergence of simulation and machine learning. This paper organizes the landscape around seven coupled themes---number formats, floating-point emulation, emerging architectures, hardware/software co-design, relation to other approximations, software design, and precision as a multilevel resource ---and, for each theme, synthesizes the state of the art, future directions, and open questions. We emphasize \emph{energy per trusted solution} as the core objective, and we frame \say{recklessly responsible} computing as a pragmatic doctrine: exploit low precision aggressively, but with systematic detection, escalation, and certification pathways.

2026-09-29T09:39:27Z 41 pages Emmanuel Agullo Hartwig Anzt Daniel Bauer David Bindel Alfredo Buttari Alexandru Calotoiu Erin Claire Carson Pasqua D'Ambra Ieva Daužickaitė James W. Demmel Jack Dongarra Iain Duff Massimiliano Fasi Dominik Göddeke Stef Graillat Laslo Hunhold Roman Iakymchuk Fabienne Jézéquel Nils Kohl Harald Köstler Jakub Kružík Julien Langou Xiaoye Sherry Li Hatem Ltaief Piotr Luszczek Yuxin Ma Theo Mary Mantas Mikaitis Hiroyuki Ootomo Daniel Osei-Kuffuor Enrique S. Quintana-Ortí Ulrich Rüde Jennifer Scott John Shalf Linda Stals Rasmus Tamstorf Stefan Turek Petr Vacek Bastien Vieublé Rio Yokota http://arxiv.org/abs/2609.35515v1 2026-09-28T16:08:19Z

Scientific discovery requires not only recovering mathematical laws that describe observable behavior, but also identifying the mechanisms that generate them. Existing benchmarks for symbolic regression and scientific agents primarily evaluate phenomenal-law recovery, leaving mechanism discovery largely untested. We introduce MechBench, a benchmark that explicitly separates these two capabilities. Each task is defined by a mechanistic model, a structured set of scientifically meaningful relations whose joint consequences entail an observable phenomenal law, while agents receive only observational data and scientific context. We evaluate mechanism recovery through mechanism probes, which query internal scientific consequences that cannot be inferred from the phenomenal law alone. To reduce reliance on memorized textbook mechanisms, we construct unfamiliar variants through controlled, scientifically interpretable mutations of canonical mechanisms, and screen for mechanistic indistinguishability to exclude ambiguous instances admitting comparable competing mechanisms. Experiments across representative scientific agents reveal a substantial phenomenal--mechanism recovery gap: for Codex with GPT-5.6-sol, phenomenal-law accuracy reaches 35.00% on the Core-set while mechanism accuracy is only 13.75%, with mechanism recovery failing in 64.29% of cases where the phenomenal law is correctly recovered. The gap widens as mechanisms become increasingly mutated, and even providing the correct phenomenal law leaves mechanism recovery below 50%. These results reveal a substantial generalization gap in mechanistic reasoning and establish mechanism discovery as a distinct challenge beyond recovering observable scientific laws.

2026-09-28T16:08:19Z Zihan Yu Jiadong Zhang Jialin Cheng Jingtao Ding Yong Li http://arxiv.org/abs/2609.35501v1 2026-09-28T16:03:24Z

Recent agentic symbolic regression approaches increasingly rely on large language models to analyze data, select scientific operations, and refine hypotheses over long search trajectories. In such systems, performance depends not only on the underlying model and search strategy, but also on the runtime infrastructure that supports scientific search. We introduce SRHarness, a domain-specific harness for agentic symbolic regression built around three mechanisms: composable scientific actions that provide a common interface over raw, transformed, and candidate-derived quantities; persistent scientific state that retains evaluated hypotheses and exposes compact model-facing views; and trajectory lifecycle management that coordinates continuation, branching, restart, and termination. On LLM-SRBench, SRHarness consistently improves both numerical generalization and symbolic recovery under matched LLM backbones. With DeepSeek-v4-flash-0731, it achieves 93.69% symbolic accuracy on LSR-Transform, compared with 62.16% for SR-Scientist, and retains 72.97% accuracy on an anonymized variant that removes scientific descriptions and variable semantics, versus 39.64% for SR-Scientist. Under the same DeepSeek-v4-flash-0731 backbone, SRHarness also substantially outperforms Codex (72.97% vs. 20.72%) and reaches performance comparable to Codex with GPT-5.5, while simply providing Codex with the same scientific tools does not reproduce this advantage. These results show that effective agentic symbolic regression depends not only on models or tools, but also on structured runtime support for organizing scientific actions, accumulated hypotheses, and long-horizon search.

2026-09-28T16:03:24Z Zihan Yu Shixuan Zhou Hao Huang Jingtao Ding Yong Li http://arxiv.org/abs/2609.35099v1 2026-09-28T13:10:17Z

We present e3j, a fast Euclid-equivariance backend for geometric deep learning applications with JAX bindings for GPU and TPU. Leveraging both optimized CUDA and Pallas kernels and algorithmic improvements, the library achieves state-of-the-art throughput and runtime on both forward and backward paths. On a machine learning interatomic potential (MLIP) use case, it outperforms established backends, measuring up to 34% speed-up over cuEquivariance on water box NPT simulation using MACE, while remaining fully open source. E3j achieves over 80% efficiency over the H100 maximum memory bandwidth on tensor product operations, and in many cases more than doubles throughput of message passing convolutions forward compared to previously available backends. In addition, with the release of dedicated Pallas TPU kernel, e3j opens the possibility of large scale equivariant deep learning workloads on TPU architectures, which has so far been difficult to achieve. Our benchmarks show that e3j also achieves over 80% of a TPUv6e memory bandwidth, up to one order of magnitude more than e3nn-jax. The library is available on GitHub, PyPI and is released under an open source Apache 2.0 license.

2026-09-28T13:10:17Z 9 pages (36 total), 12 figures, 4 tables Olivier Peltre Armand Picard Adrien Pichard Miguel Bragança Luca Giacomoni Valentin Heyraud Zachary Weller-Davies Christoph Brunken Jules Tilly http://arxiv.org/abs/2609.35015v2 2026-10-01T06:47:16Z

Range reduction plays a crucial role in the accuracy and performance of evaluating trigonometric functions, and is often the primary bottleneck for large floating-point inputs. While fast algorithms such as Cody--Waite work efficiently over narrow intervals, the Payne--Hanek algorithm remains the standard technique for accurate reduction across large floating-point inputs. However, many existing implementations of Payne--Hanek suffer from high latency due to heavy branching, conversion overheads, and the use of multi-word integer arithmetic, which hinders SIMD vectorization. In this paper, we analyze and present a branch-free variation of the Payne--Hanek algorithm using only floating-point arithmetic. Our method operates directly over large double-precision inputs ($|x| \ge 2^{16}$) and is well suited to hardware with FMA instructions. We formulate the precision constraints in terms of a truncation error budget, construct a compact lookup table indexed by the input exponent, and prove that the scaled reduced argument has absolute error below $2^{-110}$ and relative error below $2^{-60}$ for every input, including worst cases. The same routine can serve both as the complete range reduction of a single-stage implementation and as the fast path of a correctly rounded one, achieving higher throughput than existing implementations and lower latency than those returning a double-double reduced argument. The algorithm is currently implemented in the LLVM libc project.

2026-09-28T12:16:35Z Updated to include CORE-MATH newer Payne-Hanek range reduction implementation, and add CRLIBM to performance analysis. Updated the performance table after fixing the setup Tue Ly http://arxiv.org/abs/2609.34928v1 2026-09-28T11:26:39Z

Structural analysis is a core method in Petri Net (PN) research, offering a perspective complementary to state-space techniques while avoiding many of their limitations. It is well studied for classical PNs but far less for High-Level Petri Nets (HLPN). Symmetric Nets (SN), a common HLPN formalism, use compact annotations to encode behavioral symmetries, enabling the construction of a symbolic reachability graph (and a lumped Markov chain in stochastic SN) and the execution of symbolic discrete-event simulations. During the past two decades, structural techniques tailored to SN have been developed, notably supported by the SNexpression tool. This tool implements a formal calculus designed for the computation of symbolic structural relations, including, but not limited to, conflict relations and causal dependencies. Here, we focus on using this calculus to verify semi-automatically symbolic structural invariants, a task currently feasible only for certain restricted SN subclasses. We focus specifically on (semi)flows and briefly discuss an approach through which a flow generative family can be generated, at least theoretically. We further briefly outline a framework for the formal verification of a broader class of invariant properties. An extended formulation of the SN formalism is employed, which demonstrably satisfies the closure property with respect to fundamental functional operators. The core concepts are elucidated by means of representative examples throughout the exposition.

2026-09-28T11:26:39Z In Proceedings ICE 2026, arXiv:2609.30353 EPTCS 453, 2026, pp. 79-99 Lorenzo Capra Università degli Studi di Milano, Italy 10.4204/EPTCS.453.6 http://arxiv.org/abs/2609.34891v1 2026-09-28T10:59:34Z

Structural analysis is central to Petri Net (PN) research, complementing state-space methods while avoiding their combinatorial issues. It is well studied for classical PNs but much less for High-Level Petri Nets (HLPN). Symmetric Nets (SN), a common HLPN formalism, use compact annotations to encode behavioral symmetries, allowing symbolic reachability graphs and associated lumped Markov chains for stochastic SN. In the past two decades, specific structural techniques for SN have emerged, notably the SNexpression tool, which implements a calculus for symbolic structural relations such as conflict and causality. We propose using this calculus to semi-automatically verify symbolic structural invariants, currently possible only for restricted SN subclasses, for an extended SN formalism (ESN) closed under key functional operators. We focus on flows and outline, at least in theory, how to construct a flow-generating family. We also sketch a framework for formally verifying a wider range of invariant properties. Representative examples illustrate the main concepts.

2026-09-28T10:59:34Z In Proceedings FROM 2026, arXiv:2609.30324 EPTCS 452, 2026, pp. 172-190 Lorenzo Capra Università degli Studi di Milano 10.4204/EPTCS.452.12 http://arxiv.org/abs/2609.34882v1 2026-09-28T10:58:06Z

We present a formalization in Dafny of the Omega Test, an algorithm used to decide the satisfiability of a system of inequalities. The implementation defines executable representations for rational numbers, linear expressions, inequalities, equalities, divisibility constraints, and systems of constraints, together with their semantic interpretation through valuations. We fully specify and verify the implementation in Dafny. We describe the lessons learned and how the formalization process led to new insights into the algorithm.

2026-09-28T10:58:06Z In Proceedings FROM 2026, arXiv:2609.30324 EPTCS 452, 2026, pp. 67-81 Ariadna Brănici-Faraon Alexandru Ioan Cuza University of Iasi Ştefan Ciobâcă Alexandru Ioan Cuza University of Iasi Diana-Elena Gratie Alexandru Ioan Cuza University of Iasi 10.4204/EPTCS.452.5 http://arxiv.org/abs/2609.37490v1 2026-09-28T08:47:36Z

LLMs excel at recalling statistical patterns but degrade sharply when answers must be derived, especially on multi-hop chains. Delegating derivation to deterministic symbolic executors shifts reliability to whether model-generated premises are source-supported. We introduce CPUNeSy, a serving architecture that controls model writes to symbolic state via a task-defined predicate interface and certificate gate, abstaining when grounding passes disagree. Component analysis isolates deterministic execution, restricted grounding, agreement, and source rechecking. Experiments show deterministic execution drives most accuracy recovery on derivation-heavy tasks; controlled writes mainly improve selective reliability by withholding unsupported or inconsistent answers, at a coverage cost. On multi-hop tests in law and formal math, deterministic execution recovers most of the gap over chain-of-thought and retrieval baselines, with full-pool gains up to 35.0 points. Certification is selective-serving control, not accuracy mechanism: with grounding traces fixed on ContractNLI, source rechecking removes a quarter of DeepSeek's wrong answers surviving two-vote agreement, at measurable coverage cost. When abstention is costly, routing withheld cases to an uncertified same-model fallback raises full-pool accuracy on MedCalc-Bench Verified by 13.9 and 4.9 points for Seed and DeepSeek; these gains are not from the certified channel. On LeanDojo Benchmark 4, kernel-restricted pools match BM25 recall@15 (89.3%). Gains depend on the grounder's error regime: bias-dominated grounders benefit less, consistent with our voting bound. Certificates guarantee derivational validity relative to admitted premises; semantic faithfulness to natural-language sources remains conditional on the source checker, and prospective validation is future work.

2026-09-28T08:47:36Z Zeyan Li Siyuan Qiu Shuai Zhao Jianfeng Xu http://arxiv.org/abs/2609.33663v1 2026-09-27T15:22:40Z

Discovering underlying symmetries from data has emerged as a crucial challenge in scientific discovery. Existing data-driven methods for symmetry discovery fail to determine the exact number and mathematical form of unknown infinitesimal generators. Recent explicit methods represent generators using a predefined function library and identify them through algebraic optimization, but they often struggle to capture complex symmetries involving high-order polynomials or transcendental functions. To address this limitation, we formulate symmetry discovery as a joint optimization problem over the function library and coefficients. We propose a novel framework that leverages an encoder-decoder architecture to dynamically generate symbolic expressions and expand the library. This generation process is optimized via reinforcement learning, which accelerates the exploration of the symbolic search space through step-wise rewards. Experiments demonstrate that LieDiscover can successfully uncover open-form infinitesimal generators involving high-order polynomials or transcendental functions, which remain intractable for existing methods. The discovered symmetries also improve performance in downstream PDE solving and discovery tasks.

2026-09-27T15:22:40Z Xinxin Li Jianming Ma Xingyu Cui Da Li Juan Zhang Junping Yin http://arxiv.org/abs/2609.33313v1 2026-09-27T07:26:24Z

One of the most important problems in computational algebra is the computation of real solutions of a polynomial system. Lasserre, Laurent, and Rostalski introduced a numerical method to compute the real radical of an ideal defining a finite set of real points. Their method is based on moment matrices and reduces the problem to solving a semidefinite program. In this work, we build on this method and on the work of Laurent and Mourrain to exploit the sparsity of the input polynomials. For this purpose, we extend the theory of moment matrices to the setting of affine toric varieties. We prove that, for sparse polynomial systems, this approach allows us to recover real points on affine toric varieties. Moreover, we show that a projection of the spectrahedron associated with the semidefinite program is, in fact, a polytope, and we propose a variation of the method to compute only one real solution of the system.

2026-09-27T07:26:24Z Tom Baumbach Matías Bender http://arxiv.org/abs/2609.32978v1 2026-09-26T22:15:13Z

As networks expand and become an ever more critical infrastructure to modern society the need to analyze these networks with the highest regard for privacy is essential to ensure their proper function. Depending on the level of the network layer to be analyzed, sources and destinations can be any combination of physical, logical, or persona/agentic endpoints, which requires the ability to handle diverse data. Invaluable to these analyses are mathematical tools that enable sophisticated mathematical algorithms to be expressed succinctly while achieving scalable vertical (within a compute node), horizontal (across compute nodes), and temporal (over different generations of hardware) performance. Associative (token) array mathematics and corresponding libraries is one approach that can meet these requirements. Accelerating these libraries with GPUs enables the analysis of the largest networks. The MIT/IEEE/Amazon Anonymized Network Sensing Graph Challenge provides a venue for highlighting the applicability of accelerated associative arrays for these types of problems. The D4M associative library has been implemented in a number of languages. This work benchmarks a prototype Matlab D4M GPU accelerated implementation of the Anonymized Network Sensing challenge across a wide range of CPU and GPU hardware. Scalable performance is demonstrated within and across CPU cores, CPU nodes, and GPU nodes. Horizontal scaling across multiple nodes was linear. Running on hundreds of GPU nodes simultaneously achieved a sustained processing rate sufficient to potentially analyze a 10 Petabit/s network.

2026-09-26T22:15:13Z 8 pages, 3 figures, 6 tables, to appear in IEEE HPEC 2026 Jeremy Kepner Hayden Jananthan LaToya Anderson William Arcand David Bestor William Bergeron Chansup Byun Alex Bonn Daniel Burrill Vijay Gadepally Michael Houle Matthew Hubbell Michael Jones Piotr Luszczek Peter Michaleas Lauren Milechin Julie Mullen Andrew Prout Albert Reuther Antonio Rosa Charles Yee Alex Pentland http://arxiv.org/abs/2609.32388v1 2026-09-26T09:03:22Z

We give a rank-23 algorithm for $3\times3$ matrix multiplication using 51 additions and subtractions in alternative bases. The input and output conversions require five further additions, giving 56 additions in ordinary coordinates. The construction combines linear-program reduction with a search over sparse basis changes, and the resulting programs are distributed as a machine-checkable certificate. We verify correctness by exact coefficient expansion and distinguish the kernel cost from the cost of a complete multiplication.

2026-09-26T09:03:22Z 7 pages. Certificate and verification code: https://github.com/Joshua-Stapleton/51-addition-alt-basis-3x3-rank23 Joshua Stapleton Andrew Perminov http://arxiv.org/abs/2609.31446v1 2026-09-25T16:05:42Z

Multidisciplinary Design Optimization (MDO) enables the application of optimization algorithms to complex engineered systems, ranging from aerospace and automotive to robotics and microelectronics. Such multi-component systems typically consist of coupled subsystems, each characterized by its own design variables, constraints and objectives. Without adequate coordination of these couplings, subsystems may be optimal in isolation while the overall system remains suboptimal or even infeasible. Distributed design optimization coordinates coupled subsystem optimization problems while allowing them to retain control over their local design variables. Although promising coordination methods exist, their application is hindered by the lack of a comprehensive software framework which supports intuitive problem definition, provides suitable distributed coordination algorithms, is modular and extensible, enables interactive (post-)processing, and supports the distributed computation of subsystem executions. This work derives requirements for such software, assesses existing frameworks against them, and introduces DistributedDesignOptimizer, an open-source Python framework to fill this gap.

2026-09-25T16:05:42Z to be published in the conference proceedings of ECCOMAS 2026 Sebastian Ellmaier Albert J. de Wit Akilesh Raveendran Marc-Eric Vogt Thomas Bäck Anna V. Kononova http://arxiv.org/abs/2609.31152v1 2026-09-25T11:46:11Z

Scientific data span heterogeneous structures, including coordinates, networks, surfaces, volumes and fields, yet their topology can be quantified within a common framework through graph connectivity, cycle structure, genus and spatial embedding. Graph- and homology-based summaries do not determine spatial embedding, while standard knot and link polynomials require extensions to accommodate branching graphs. Here, we introduce KnottedGraph, a computational framework that converts such scientific representations to knotted graphs that retain graph connectivity and spatial embedding together. It constructs projected diagrams and PD codes, enabling various topological analyses, including Yamada-polynomial evaluation for topological classification. For scalable exact evaluation, it combines partial resolutions that leave the same unresolved connections and optimizes their processing order; the resulting algorithm is verified against published topological invariants of knotted graphs with up to 500 crossings. This scalability enables us to introduce an LLM-assisted mathematical-discovery methodology, in which computational topological data generated across knotted-graph families are used to identify candidate closed-form formulas. With this approach, we identify analytical Yamada-polynomials for generic graph motif families exhibiting Abelian and non-Abelian word sequences. Together, these scalable capabilities make knotted-graph topology computationally accessible across scientific domains, enabling large-scale classification and introducing a route from topological data to LLM-assisted AI4Math discovery.

2026-09-25T11:46:11Z 40 pages, 15 figures, 4 tables; includes Supplementary Information. Source code, documentation, workflows and data are available at https://github.com/HakanAkgn/KnottedGraph Hakan Akgün Xianquan Yan Kehan Liu Zhaoyun Chen Ching Hua Lee http://arxiv.org/abs/2609.35847v1 2026-09-25T04:51:06Z

We present a constructive atlas of finite simple groups with proofs of their orders, simplicity, and structural properties. The eight completed families are cyclic groups of prime order, alternating groups, the classical series $A_r(q)$, $B_r(q)$, $C_r(q)$, $D_r(q)$, and the exceptional series $G_2(q)$ and the small Ree groups $ {}^2G_2(3^{2m+1})$, $m\geq1$. The fifteen sporadic entries are $M_{11}$, $M_{12}$, $M_{22}$, $M_{23}$, $M_{24}$, $\mathrm{Co}_1$, $\mathrm{Co}_2$, $\mathrm{Co}_3$, $\mathrm{McL}$, $\mathrm{HS}$, $\mathrm{Suz}$, $J_2$, and $\mathrm{Fi}_{22}$, $\mathrm{Fi}_{23}$, $\mathrm{Fi}_{24}'$. The simple parameter ranges and exceptional cases are stated explicitly. The models arise from codes, lattices, forms, algebras, and finite geometries, including the split octonions and the Conway--Parker algebra. They retain natural actions, stabilizers, central quotients, and comparison maps for subsequent group theory. Several classical comparison isomorphisms relate the models, while involution-class counts distinguish the equal-order orthogonal and symplectic families in odd characteristic and rank at least three. Drawing on classical sources and companion mathematical work, the project develops the construction side of finite simple group theory, not the exhaustiveness proof of the classification. The completed models and stated proofs are formalized in Lean for verification and reuse.

2026-09-25T04:51:06Z 29 pages. Lean formalization, catalogue, and verification material available from the source repository linked in the paper Gerald Höhn http://arxiv.org/abs/2609.30451v1 2026-09-24T18:44:19Z

Parameter estimation for ordinary differential equation (ODE) models is a fundamental task that is often complicated by the limitations of conventional optimization-based methods. In theory, differential-algebraic approaches offer an appealing alternative: they reduce the problem to polynomial system solving and do not require user-supplied initial guesses for parameter values. In practice, however, algebraic methods have been limited by their sensitivity to measurement noise, because they require accurate derivatives of observed outputs. In this work, we integrate Gaussian Process Regression (GPR) into the differential-algebraic method and derive a first-order error analysis in terms of noise level and algebraic sensitivity. We evaluate the method across several noise levels on a benchmark of 25 dynamical systems arising in applications including mechanical engineering and systems biology. The proposed method achieves the highest aggregate performance among the methods considered, recovering all sought parameter values and initial conditions to within 10% relative error in 88.5% of runs. These results demonstrate that robust derivative estimation can make differential-algebraic parameter estimation practical for dense, noisy synthetic data while retaining key advantages of the algebraic formulation.

2026-09-24T18:44:19Z Oren Bassik Alexander Demin Alexey Ovchinnikov http://arxiv.org/abs/2609.30324v1 2026-09-23T19:46:16Z

The 10th Working Formal Methods Symposium (FROM 2026) was held in Timişoara, Romania on September 15-17, 2026. It was organized jointly by the Faculty of Informatics of West University of Timişoara, the e-Austria institute, and the Institute for Logic and Data Science (ILDS). This event was co-located with the 28th International Symposium on Symbolic and Numeric Algorithms for Scientific Computing (SYNASC 2026). This volume contains the texts of the 14 papers accepted by the Program Committee for presentation.

2026-09-23T19:46:16Z EPTCS 452, 2026 Mircea Marin West University of Timişoara Adrian Crăciun West University of Timişoara 10.4204/EPTCS.452 http://arxiv.org/abs/2609.28442v2 2026-09-30T16:14:05Z

Reordering a set of mathematical rules without changing its meaning should preserve the correct answer, but must a model's internal representations stay invariant too? We investigate this question using synthetic multi-step function-composition problems, each presented under multiple rule orderings with the same correct answer. We measure accuracy and permutation signal-to-noise ratio (SNR), which quantifies how distinctly ordering patterns are represented relative to variation across problem instances. Across 16 language models ranging from 1B to 8B parameters, we find a pattern: models that solve reordered problems more accurately represent different rule orderings more distinctly. Layer-averaged permutation SNR is positively rank-correlated with accuracy in every synthetic setting we evaluate, with Spearman correlations reaching 0.86. These findings highlight a distinction between answer invariance and representation invariance: successful mathematical rule composition can accompany distinct internal representations between equivalent rule orderings. This motivates distinguishing answer invariance from representation invariance, and offers a representational perspective on mathematical reasoning beyond answer accuracy alone.

2026-09-23T17:40:57Z NeurIPS 2026 Workshop: The 6th Workshop on Mathematical Reasoning and AI Zhixu Silvia Tao http://arxiv.org/abs/2609.28248v1 2026-09-23T15:09:09Z

We present hyperbolix, an open-source library for hyperbolic deep learning in JAX, built on Flax NNX. To our knowledge, it is the first comprehensive, general-purpose hyperbolic deep learning library in JAX. It includes six manifolds with a common interface: Euclidean space, the Poincaré ball, the hyperboloid, the $κ$-stereographic model, mixed-curvature product spaces, and the proper velocity space. We implement layer families that cover linear layers, convolutions, attention, normalization, positional encoding, regression, and vector quantization. These building blocks span methods ranging from Ganea's original hyperbolic neural networks to recent fully hyperbolic architectures such as Hypformer and Lorentzian ResNet. Additionally, hyperbolix contains Riemannian optimizers implemented as optax transformations, wrapped distributions, and hyperbolic dimensionality-reduction techniques. Its API uses idiomatic JAX: Manifolds are stateless, with curvature being passed at call time, while manifold operations act on single points, with jax.vmap enabling batch operations. The precision of every checked operation is tested against a closed-form NumPy/SciPy transcription from the source paper or a finite difference, for both float32 and float64. On the hyperboloid, standard formulas for two-point operations, such as the distance, lose precision far from the origin, because they subtract two large, nearly equal terms. hyperbolix replaces these subtractions with cancellation-free formulas that stay accurate in float32 at distances where prior implementations return NaN. hyperbolix is available under the MIT license at https://github.com/timoklein/hyperbolix .

2026-09-23T15:09:09Z Timo Klein Thomas Lang Yllka Velaj Sebastian Tschiatschek http://arxiv.org/abs/2609.28179v1 2026-09-23T14:23:39Z

GPU robotics lacks the reusable numerical infrastructure of mature CPU stacks, instead relying on compiler frameworks that introduce overhead or repeatedly reimplementing numerical libraries. To address this, we introduce GLASS (GPU Linear Algebra Simple Subroutines), a header-only CUDA C++ library that provides thread-, warp-, block-, and NVIDIA-backed implementations of robotics-scale linear algebra and geometric computations under one composable device API. GLASS treats implementation choice, execution scope, and launch packing as architecture-specific placement decisions determined by offline measurement and resolved statically at compile time. This is critical as the best and worst placements differ by a median of 4.9x (max 81x), with 145 of 396 recommended placements changing between a Jetson AGX Orin and an RTX 5090, and 162 of 396 versus an AGX Xavier. These stakes are highest at the edge as GLASS's advantage over the best of PyTorch and JAX is as much as 73x on the Orin versus 12x on the RTX 5090. GLASS is released open source with independent numerical oracles and source-bound local-GPU test attestation. Finally, integrating GLASS with published robotics systems both exposed a pre-existing numerical bug and improved embedded runtimes by up to 1.5x.

2026-09-23T14:23:39Z 8 pages, 7 figures, 2 tables Brian Plancher http://arxiv.org/abs/2609.27268v2 2026-09-27T15:13:43Z

We study how determinant recurrences of banded Toeplitz matrices behave when their Laurent symbols are multiplied. Two classical structures underlie the problem. Clean banded Toeplitz determinants have a root-product description of their recurrences, while a product of two finite Toeplitz sections differs from the finite section of the product by finite-rank corner corrections. We connect these structures by identifying multiplication-induced boundary defects with exterior-degree sectors of the determinant recurrence. To each polynomial core we associate recurrence polynomials for all exterior degrees. Multiplication of cores becomes a graded convolution via composed products, while complementary degrees are related by a scaled reciprocal duality. On the matrix side, one-sided factors produce a defect filtration whose successive pieces are exactly these sectors. For general two-sided factors, independently weighting the two corner corrections gives an interval filtration: increasing either defect order adds one adjacent sector, and the cumulative recurrences are generically minimal. The multiplication-induced same-corner minors used in these filtrations lie in the standard row-column state module, whereas cross-corner imbalance corresponds instead to Laurent recentering. Opposite Laurent recenterings realize the individual sectors directly, and for several factors the admissible recenterings form an explicit lattice polytope. The pentadiagonal case gives the basic $1+4+1$ decomposition. The resulting framework gives a factor-level description of how finite-section boundary effects generate the recurrence spectrum of structured banded Toeplitz products.

2026-09-23T02:52:38Z Max A. Alekseyev Dmitry I. Khomovsky http://arxiv.org/abs/2609.27087v1 2026-09-22T21:39:06Z

Organizations increasingly use LLMs for policy, compliance, risk, and operational decision support, requiring evidence validation, review routing, version control, and auditability. We introduce Policy-as-Skill (PaS), a modular runtime that packages these functions as executable, versioned policy capabilities. Thirteen methods are evaluated with a fixed Gemma4 backend on 600 development tasks. PaS+Audit achieves 53.8% exact accuracy, macro-F1 0.346, review F1 0.854, citation precision 1.000, policy-reference recall 0.984, and audit completeness 1.000, outperforming LLM+RAG on most governance and review metrics. Deterministic control raises aggregate accuracy to 61.2% but is strongly task dependent, supporting selective rather than universal rule-based intervention.

2026-09-22T21:39:06Z Kabeh Mohsenzadegan Vahid Tavakkoli Kyandoghere Kyamakya http://arxiv.org/abs/2609.25616v1 2026-09-22T03:23:19Z

We evaluate a SymPy implementation of the parallel Risch-Norman method using Charlwood's 2008 suite of 50 challenging indefinite integrals. The system automatically builds integrand towers, verifies answers by differentiation, and returns correct, verified integrals for 49 problems with zero errors. The single failure, $\int\arcsin(x\sqrt{1-x^2})\,dx$, is proven non-elementary using a holomorphic-remainder certificate, though limited by an unverified completeness hypothesis on a genus-three curve. Part II's degree bounds successfully reduce classical ansatz sizes by two-thirds without impacting running time. The paper details algorithmic mechanisms like $S'$-units, Pell units, and residue computing in tower coordinates. Compared to mature implementations, this untuned SymPy prototype is slower than FriCAS (by a factor of six on the median integral) but more accurate than AXIOM (which returned three wrong answers). Profiling pinpoints performance bottlenecks in nonlinear norm searches and nested number fields, outlining clear targets for optimisation.

2026-09-22T03:23:19Z Sam Blake http://arxiv.org/abs/2609.24932v1 2026-09-21T17:26:30Z

Despite the success of neural models in natural language processing, their black-box nature limits interpretability and conceals the linguistic phenomena underlying their predictions. We present SLITE, an explainable hybrid model for Recognizing Textual Entailment that integrates two complementary layers of semantic analysis: a structural-relational layer, based on semantic compatibility and incompatibility between compositional entities, and a distributional-informational layer, based on structured patterns of information change between embedding-based representations of the premise and the hypothesis. We propose 17 features that combine entity-level semantic relations, polarity-sensitive lexical matching, and alignment measures over semantic sub-representations of the similarity matrix, including measures based on entropy and transfer entropy. A logistic regression trained on these features achieves an accuracy of 83% on three-class SICK and 96% on SICK-CE, outperforming IsoLex by 4 percentage points and falling within 2 percentage points of RoBERTa with a fraction of its computational complexity. Ablation studies and SHAP analysis confirm that structural-relational features are the primary drivers of classification, while distributional-informational features provide essential complementary contributions, particularly for detecting neutrality and contradiction. Our results demonstrate that further exploration of hybrid approaches is a viable and scientifically productive alternative to massive neural architectures, and we hope they will strengthen the dialogue between linguistic theory and computational modeling of inference

2026-09-21T17:26:30Z 38 pages, 5 figures, 8 tables David Torres-Moreno Jorge Hermosillo-Valadez Asela Reig-Alamillo http://arxiv.org/abs/2609.24845v1 2026-09-21T16:22:46Z

$RΠΣ^*$-extensions form a rich class of difference rings that provide a unified algebraic framework for modeling indefinite nested sums, transcendental products, and nested products over roots of unity structures that frequently appear in combinatorics, number theory, and particle physics. For a large subclass of these extensions whose ring of constants is a field, we introduce a complete reduction approach to resolve the telescoping problem without solving any difference equations. More precisely, we explicitly construct a complement to the subspace of differences over the constant field and develop an algorithm that decomposes any element of the extension into the sum of a difference and a component lying in this complement. Consequently, summability holds if and only if this complementary component is zero. This structural approach yields significant speed-ups for parameterized telescoping and, notably, creative telescoping for deriving linear recurrences of definite sums. Finally, we compute an explicit idempotent representation that extends existing telescoping algorithms and our complete reduction framework to the general class of $RΠΣ^*$-extensions, opening up previously untreatable classes of sums and products.

2026-09-21T16:22:46Z Yiman Gao Jakob Obrovsky Carsten Schneider http://arxiv.org/abs/2609.24519v1 2026-09-21T12:55:45Z

Emulation of high-accuracy floating-point matrix multiplication, as in the Ozaki scheme, splits the inputs into low-precision components and multiplies them pairwise. These products must be error-free, and each is an integer matrix product times a scale factor. FP4 Tensor Cores are the fastest on the NVIDIA B200 and B300 but cannot hold INT8 operands. The FP4 values scaled by 2 form the set $S = \{0, \pm1, \pm2, \pm3, \pm4, \pm6, \pm8, \pm12\}$, which contains every residue modulo 13, so with carries any integer splits into base-13 digits that FP4 can store. Prior work splits each INT8 operand into 3 such digits (limbs) with weights $(1, 13, 169)$ and multiplies them pairwise, 9 FP4 matrix multiplications (GEMMs) for INT8$\times$INT8. The classical ways to reduce products, such as the Karatsuba and Toom--Cook methods, do not apply as they stand: sums of limbs reach $\pm 24$ and leave $S$. This paper asks how many FP4 GEMMs are needed for one integer matrix product. We propose Adaptive Weight Encoding (AWE): the limbs take freely chosen integer weights, the stored planes are linear combinations of limbs, and the exact product is the sum of the FP4 GEMMs scaled by reconstruction coefficients. For each input range, we searched these choices for encodings with fewer products and found INT8$\times$INT8 in 6 products and INT4$\times$INT8 in 4. The formulation also holds modulo $m$, which covers the residue number systems of Ozaki scheme II: for the FP64 significand, the 75 products of prior work are reduced to 59. The boundary in product count between encodings with and without residues lies near input width 15. We release the encodings found.

2026-09-21T12:55:45Z Shun-ichiro Hayashi Daichi Mukunoki Tetsuya Hoshino Takahiro Katagiri http://arxiv.org/abs/2609.24279v1 2026-09-21T08:43:24Z

Massive three-loop form factors for vector, axial-vector, scalar, and pseudoscalar currents are vital for precision collider phenomenology. Extending the quarkonic framework to the more complex gluonic case, in Ref. (arXiv:2609.22034 [hep-ph]) we computed these contributions widely using advanced computer algebra, automated guessing, and large-scale PSLQ searches. Here, we outline the core strategy of the large-moment method and illustrate its main challenges, including solving record-sized recurrences and differential equations. Our high-precision evaluation provides an exact analytic representation around $s=0$ in terms of MZVs. We achieved a complete analytic series expansion around $s=\pm\infty$ for the first time, which depends on MZVs and three constants out of higher number spaces, along with reliable analytic continuations across $s \in (-\infty, \infty)$, serving as a landmark benchmark for modern symbolic computation.

2026-09-21T08:43:24Z PoS(LL2026)071 J. Blümlein A. De Freitas P. Marquard J. Obrovsky C. Schneider http://arxiv.org/abs/2610.00203v1 2026-09-20T13:22:29Z

A smooth 3D function can be efficiently and accurately approximated by a 3D lookup table of significantly lower resolution combined with tetrahedral interpolation. The function is sampled once on a coarse grid in a preprocessing step. For each input, the enclosing grid cube is located, one of the 6 tetrahedra in this cube is selected, and the values at its 4 corners are combined by a weighted sum. For RGB to CMYK color conversion, a particularly frequent application of this, a table with $n = 16$ cells per axis ($17^3$ nodes, 16-bit values) requires 38\,KiB. A full 8-bit table requires 64\,MiB. As shown in an experimental evaluation, the mean error of the $n = 16$ table is 0.08\,\% ink per channel. For 8-bit input, the lookup uses integer arithmetic only (Section~\ref{sec:integer}). It requires no floating point and no division, and all intermediate values fit in 32 bits. Floating point is needed only to build the table, once and offline. The integer result differs from tetrahedral interpolation with exact fractions by at most 1 unit of the 16-bit output, and white and black are reproduced exactly. This makes the approach suitable for low-power devices and real-time applications where computational resources are limited.

2026-09-20T13:22:29Z Dennis Luxen http://arxiv.org/abs/2609.22938v1 2026-09-19T10:29:35Z

We present reference implementations of four published primal heuristics for mixed-integer programming inside the open-source solver HiGHS (Huangfu and Hall, 2018): Feasibility Jump (Luteberget and Sartor, 2023), fix-propagate-repair (FPR; Salvagnin, Roberti and Fischetti, 2025) with its LP-guided dive-time variant, LocalMIP (Lin, Zou and Cai, 2024), and the first-order-LP feasibility pump Scylla (Mexi et al., 2025). They share one integration interface with per-heuristic budgets and patiences, and each runs in parallel on independently seeded workers. The evaluation is on the mipfeas benchmark (Bussieck and Dirkse, 2026), 233 instances at 600 s, against a separately built unpatched HiGHS on the same machine. The primal integral improves by 23.7% over the full set and by 12.9% on the instances not used for tuning: the patched solver reaches a good solution sooner. At the time limit it is slightly ahead. It finds a solution on 4 instances where the unpatched solver finds none, against 1 the other way, and its final gap is smaller, significantly so only over the full set. Scylla and the LP-guided dive produced no accepted incumbent in any full-limit run that carried them and ship disabled; their implementations remain. The implementation is released as open source.

2026-09-19T10:29:35Z Simon Spoorendonk http://arxiv.org/abs/2609.21492v1 2026-09-18T08:46:37Z

Chain-of-Thought (CoT) reasoning has been shown to improve the performance of large language models (LLMs), yet existing optimization methods largely rely on outcome-based feedback, leaving the logical validity of intermediate reasoning steps largely unverified. To address the gap whereby LLMs arrive at correct final answers through logically flawed intermediate reasoning chains, we propose LogicTrack, a neuro-symbolic framework that audits reasoning trajectories by auto-formalizing each reasoning step into symbolic representations and verifying it with automated theorem provers. LogicTrack introduces Solver-Based Backtracking Reward (SBR), a step-wise scoring mechanism that quantifies logical soundness and guides backtracking tree search at inference time. We further extend LogicTrack to construct supervised fine-tuning (SFT) data with backtracking traces from its trajectories, enabling fine-tuned models to internalize step-wise auditing as an intrinsic capability. Extensive experiments across 8 reasoning benchmarks and 7 LLMs demonstrate that LogicTrack effectively improves both the verifiability of reasoning chains and final answer pass rate, thereby enhancing overall CoT quality and trustworthiness in high-stakes domains.

2026-09-18T08:46:37Z Jingyu Hu Shu Yang Weiru Liu Di Wang http://arxiv.org/abs/2609.21051v1 2026-09-17T20:12:37Z

When computing with univariate polynomials, two fundamental and related problems are the XGCD and rational reconstruction, classically solved in quasi-linear complexity using the half-gcd algorithm. These problems have various applications in algebraic computations and bear strong connections to linearly recurrent sequences, structured matrices, and continued fractions. This article first gives a collection of algorithmic reductions, showing that rational reconstruction and XGCD can be solved via the computation of bases of relations modulo a freely-chosen polynomial $M(x)$. In particular, one recovers the folklore idea that bases of Padé approximants (i.e., $M(x) = x^d$) can be used to perform quasi-linear rational reconstruction or XGCD, extending to fast algorithms the well-known link between the Berlekamp-Massey algorithm and the extended Euclidean algorithm. One highlight of these reductions is that, instead of approximants, one may rely on Cauchy interpolants (i.e., $M(x)$ vanishes at chosen points). In a second part, this article describes divide-and-conquer algorithms for approximants and interpolants along with complexity analyses showing an explicit leading constant in front of the dominant term. For interpolants, the best leading constant is obtained through a variant that stores polynomials represented by evaluations, and exploits fast extrapolation in order to avoid repeated conversions to the monomial basis; this requires special points, in geometric or arithmetic progression, or FFT points when the base field allows them. Combining the analyses with the reductions leads to the best complexity bounds we are aware of for rational reconstruction and XGCD. Perhaps surprisingly, even Padé approximants or Berlekamp-Massey-like computations, which intrinsically involve $M(x) = x^d$, are accelerated by reducing them to Cauchy interpolation at well-chosen points.

2026-09-17T20:12:37Z Vincent Neiger Mohab Safey El Din Kevin Tran http://arxiv.org/abs/2609.19828v1 2026-09-17T07:33:54Z

We propose GPU algorithms for high-fidelity simulation of incompressible turbulent flows. Discretization in space is performed with H(div)-conforming high-order Raviart-Thomas finite elements for the velocity and an $L^2$-conforming discontinuous Galerkin approximation for the pressure. In time, a consistent splitting scheme based on higher-order BDF time stepping is used, with convection treated explicitly. In this scheme, a pressure Poisson equation and a symmetric reaction-diffusion-type equation for the velocity need to be solved in each time step. We develop a solution framework with fast matrix-free operator evaluation for all ingredients, combined with multigrid solvers for the Poisson problem, and propose a robust mixed-precision algorithmic framework. A key to mixed-precision efficiency is a least-squares projection to generate accurate initial guesses for the iterative linear solvers, enabling us to work with relative residual tolerances of $10^{-3}$. In this regime, running the solvers entirely in single precision leads to almost no change in overall iteration counts and maintains the crucial turbulence statistics, while showing up to $1.7\times$ speedup over pure double-precision simulations.

2026-09-17T07:33:54Z 19 pages, 9 figures, 5 tables Ivan Prusak Enes Mustafa Soydan Ivan Pribec Martin Kronbichler http://arxiv.org/abs/2609.19343v1 2026-09-16T19:11:11Z

We compute the convex envelope of (nonconvex) bivariate piecewise linear-quadratic (PLQ) functions (bivariate quadratic functions defined on a polyhedral subdivision). Our algorithm is composed of the following steps: (1) compute the convex envelope of each quadratic piece obtaining piecewise rational functions (quadratic divided by linear function) defined over a polyhedral subdivision; (2) compute the (Legendre-Fenchel) conjugate of each resulting piece to obtain piecewise quadratic functions defined over a parabolic subdivision; (3) compute the maximum of all those functions to obtain the conjugate of the original PLQ function as a piecewise quadratic function defined on a parabolic subdivision; (4) compute the conjugate of each resulting piece; and finally (5) compute the maximum over all those functions to obtain the convex envelope (biconjugate) as rational functions (quadratic divided by linear function) defined over a polyhedral subdivision. Our contribution includes a practical algorithm running in linear time, and proving that the convex envelope is a piecewise rational function.

2026-09-16T19:11:11Z Tanmaya Karmarkar Yves Lucet http://arxiv.org/abs/2609.31687v1 2026-09-16T19:01:43Z

Parallel numerical libraries such as PETSc are widely used in science and engineering applications where wrong results can have costly consequences. Despite this, numerical libraries are rarely formally verified. One of the challenges is the need for an expert to hand-write a specification and manually apply a verification tool, often requiring the development of a harness or driver, all of which can contain additional bugs that lead to false positives or false negatives during verification. With recent advancements in large language models (LLMs), it is tempting to generate such drivers and reference models automatically, but one-shot generation based on a simple prompt is brittle and leads to additional unverified code that needs to be audited. In this paper, we present an approach to use LLMs in a limited setting to generate a small, human-certifiable ACSL contract from the function's documentation, combined with a deterministic toolchain that supports a restricted ACSL profile and generates a driver that uses the CIVL verifier to check the implementation against the contract and, when available, an existing reference model. We demonstrate the pipeline end-to-end on three PETSc functions: MatAXPY (reference model already exists), MatAYPX (no reference model, so the certified contract is the sole oracle), and the non-compressing mode of MatFilter (no reference model, with more complex, conditional behavior). With this pipeline, we were able to discover a bug in PETSc's MatAYPX function that was previously undiscovered and had been present in the code since 1997.

2026-09-16T19:01:43Z Hansol Suh Jan Hückelheim Stephen Siegel http://arxiv.org/abs/2609.18871v1 2026-09-16T16:08:16Z

Region-of-attraction (ROA) certificates for polynomial systems become expensive as state dimension and degree grow: direct sum-of-squares (SOS) formulations require combinatorially growing monomial bases. Quadratization represents a polynomial vector field exactly on an invariant manifold of a quadratic system, allowing a quadratic Lyapunov function to certify the ROA. For a fixed lift, stabilizer gains shape the off-manifold extension and transverse dynamics, while representation gauges change the matrix representation but not the vector field. Both affect the spectral-norm certificate, yet prior work fixes the gain by a feasibility heuristic before optimizing the gauge. We formulate optimal dissipative quadratization (ODQ), jointly designing gains and gauges for a fixed monomial lift, reference extension, stabilizer factorization, and Lyapunov weight $Q=I$. Gains lie in a prescribed compact Hurwitz box. At each gain, an exact semidefinite program globally minimizes the spectral-norm bound over the gauge. Residual-aware bounds yield a certified closed Lyapunov sublevel set, accounting for the floating-point Lyapunov residual. Under our stated assumptions, every accumulation point of the idealized outer search is box-Clarke stationary. A finite run returns the best independently verified candidate; global optimality of the gain search is not claimed. On a planar quintic, optimizing the gain increases the certified area by a factor of $2.238$ over a matched zero-gain gauge. Across 16 heterogeneous polynomial systems with stabilizer freedom, ODQ improves on both fixed-gain lifted baselines. All 36 ODQ runs on the relay benchmark complete, and all 27 repeat-level comparisons across nine fully paired cases favor ODQ over an SOS baseline with a fixed quadratic Lyapunov function in both the fixed-direction proxy and construction time. Broader comparisons with direct SOS methods remain mixed.

2026-09-16T16:08:16Z 43 pages, 4 figures, 7 tables; includes appendices Yubo Cai Gioele Zardini http://arxiv.org/abs/2609.18866v2 2026-09-29T17:12:05Z

We investigate an algebraic approach to the Syndrome Decoding Problem, based on a reformulation of the Hamming weight constraint and its integration with the Information Set Decoding paradigm. We begin with a systematic analysis of the Hamming variety, deriving its defining equations in terms of elementary symmetric functions. Since these equations may have high degree, we exploit convolution identities for elementary symmetric functions, together with factorizations based on Lucas' identity, to derive an equivalent formulation with auxiliary variables and equations of bounded degree. Building on this modeling, we generalize the ISD paradigm through an ISD-like decoding strategy, implemented by the GBDecode algorithm, in which only a subset of an information set is fixed. This approach reduces the size of the combinatorial search space at the cost of solving the associated multivariate nonlinear systems. To handle this algebraic component, we employ the MultiSolve algorithm, which replaces a single Grobner basis computation with a collection of computations on simpler systems, obtained by exhaustively assigning a varying number of indeterminates over the finite field. This provides a tunable balance between combinatorial search and algebraic solving. We evaluate the resulting approach experimentally on instances of the Syndrome Decoding Problem for random binary linear codes, using parameters corresponding to the NIST Security Category 1 parameter set of the Classic McEliece cryptosystem. The experiments assess the feasibility of this combinatorial-algebraic approach and provide insights into the practical behavior of Grobner basis techniques within an ISD-like decoding framework.

2026-09-16T16:05:12Z 30 pages Roberto La Scala Marco Marchesin Sharwan K. Tiwari http://arxiv.org/abs/2609.18722v1 2026-09-16T14:22:19Z

We prove that the tensor rank of $3\times3$ matrix multiplication over $\mathbb F_2$ is at least $21$. The structural proof, independently developed by Qiushi Engine, converts occupation constraints on a single tensor factor into algebraic relations coupling all three factors. Certified quotient-rank bounds and finite geometry force any hypothetical $20$-term decomposition to have first-factor matrix-rank profile $(16,1,3)$. The ranks of the corresponding split-flattened summands therefore sum to $27$, exactly the rank of the full split flattening. Equality in rank subadditivity forces their images to form a direct sum; normalization by the inverse flattening then makes the summands pairwise annihilating idempotents. An explicit product identity for matrix multiplication implies that at most one first factor can be invertible, contradicting the three forced by the profile. The same obstruction constrains $22$-term decompositions attaining the split-rank bound. The complete proof, including the finite quotient bounds, is formalized in Lean. The accompanying research trajectory records Qiushi Engine's long-horizon autonomous research, from numerical experiments and quotient constructions to the structural proof.

2026-09-16T14:22:19Z 27 pages. Complete Lean formalization, finite certificates, source code, and reproducibility materials are available in the accompanying public repository Shuxing Yang Rui Zhao Junyao Wu Yize Wang Wenhao Li Fujia Chen Taowen Deng Shenzhan Hong Yaqi Li Zichen Li Jincheng Mi Yuang Pan Kaihao Zhu Junjie Yang Hongsheng Chen Yihao Yang http://arxiv.org/abs/2609.19190v1 2026-09-15T19:54:28Z

Background and Objectives: Spatial mapping retains the spatial distribution of radiomic features, but computational cost and fragmented software limit its use. We developed Flash-Radiomics with scalar extraction and spatial mapping, a central processing unit (CPU) backend, a hybrid Compute Unified Device Architecture (CUDA) backend, consistent feature names, and Hierarchical Data Format version 5 (HDF5) storage. Methods: We evaluated Image Biomarker Standardisation Initiative (IBSI) compliance, CPU-CUDA concordance, and end-to-end processing time. Compliance testing included 825 chapter 1 (IBSI-1) tests covering 165 high-consensus features and 323 chapter 2 (IBSI-2) tests with numerical references. Concordance testing included 1,148 scalar pairs and 93 spatial-map pairs. End-to-end processing time was measured five times per input volume of interest (VOI) size. Comparisons included the Medical Image Radiomics Processor (MIRP) and PyRadiomics for 102 shared scalar features and PyRadiomics for 93 shared spatial maps. Results: Both backends passed all 1,148 IBSI tests, and all paired results were concordant. At the largest scalar input, CPU required 76.343 s and hybrid CUDA 81.915 s; CPU was 4.7 times faster than MIRP and 190.7 times faster than PyRadiomics. At the largest spatial input completed by both backends, hybrid CUDA reduced processing time by 68.6% relative to CPU (79.280 versus 252.791 s). At PyRadiomics' largest completed spatial input, hybrid CUDA was 84.9 times faster. Conclusions: Flash-Radiomics unified standardized scalar extraction, spatial mapping, concordant CPU-CUDA results, and HDF5 storage. CPU processing time was similar or shorter for scalar extraction, whereas hybrid CUDA was faster for spatial mapping under the tested conditions.

2026-09-15T19:54:28Z 20 pages, 5 figures Shanli Ding Yiyi Hu Ziyu Fu Chia-Hsin Lin Ruihan Luo Jaehee Chun Xinyue Zhang Osama Mawlawi http://arxiv.org/abs/2609.16361v1 2026-09-14T21:26:19Z

Reaching compressible flow has usually forced lattice Boltzmann methods to abandon the compact stencil or the strict locality that make them efficient. We give up neither, solving the compressible Navier--Stokes--Fourier equations with a scheme that transports only the conserved mass, momentum and energy. The viscous stress and heat flux depend on gradients of the velocity and temperature. To capture them, existing compressible schemes go beyond a single lattice of the conserved fields. They enlarge the velocity set, carry the stress and heat flux as extra transported fields, place the energy on a separate grid, or give up exact streaming for an off-lattice advection. We instead recover the gradients from the non-equilibrium part of the distributions already present, inside the collision. No field beyond the conserved state is transported, no neighbour is read, streaming stays exact, and every computation runs in single precision. The method carries five fields where a transported-flux scheme carries fourteen, at a fraction of the memory and $4.9$ times the throughput. Verified against the exact Sod and Becker shock solutions and a supersonic Taylor--Green vortex, it tracks the direct-numerical-simulation reference on the kinetic energy and stays within the reference-solver spread on both dissipation rates.

2026-09-14T21:26:19Z Adrian Kummerländer Fedor Bukreev Mathias J. Krause http://arxiv.org/abs/2609.15697v1 2026-09-14T15:01:40Z

We introduce OpenQARP, the Open Quantum Application Research Package: an open-source Python framework for quantum application research, built on a compiled C++ core. In OpenQARP, an application is assembled from an algorithm library that orchestrates three interchangeable layers: blocks describe circuits, primitives describe what to extract from them, and engines describe how they run. The release spans near-term through fault-tolerant methods, targeting problems from electronic structure to combinatorial optimization, with device-aware compilation, circuit cutting, and resource estimation over a single set of numerical conventions that the code must follow. Every numerical feature is checked against an independent oracle, and every published timing carries a correctness check. Against OpenFermion, Qiskit/Aer, PennyLane/Lightning, Qulacs, qsim, and pytket, OpenQARP is one to two orders of magnitude faster on operator algebra and among the fastest on simulation. It matches mature compilers on two-qubit gate count, and expresses a complete algorithm in the lines a framework needs rather than the plumbing a primitive stack demands.

2026-09-14T15:01:40Z 18 pages, 2 figures, 7 tables Stefano Scali Vicente P. Soloviev Antonio Márquez Romero Brian Coyle Giuseppe Buonaiuto Annie Paine Jonathan H. Fetherolf Marcos Diez García Michal Krompiec Josh Kirsopp http://arxiv.org/abs/2609.14845v2 2026-09-15T10:33:08Z

Matrix multipliers available on recent GPUs do not conform with the IEEE 754 floating point standard. Features of matrix multipliers differ across vendors and architectures of the same vendor, such as accumulator width, rounding behaviour, normalisation points, intermediate underflow and overflow logic, the handling of subnormals, and the treatment of special inputs. As a result, reproducibility of small matrix multiplier results across devices is not possible and cannot be achieved by software control. Implementation details of matrix multipliers are not documented, making it difficult to interpret discrepancies in the computed results. We characterise the numerical behaviour of matrix multipliers across three AMD GPU architectures: CDNA 1, CDNA 2, and CDNA 3, using the MI100, MI210/250, and MI300A/300X GPUs, respectively. We design test vectors to target numerical features for all supported input formats and provide the derivation and the reasoning for why each vector allows to determine a particular numerical feature based on the outputs of the devices. MATLAB-based software models of the matrix multipliers are then developed for each architecture and validated for bit-level reproducibility against hardware using a randomized test suite consisting of 10 million sets of random input vectors. To achieve this, we applied a previously developed technique to iteratively refine the accuracy of the models in a loop, by randomized testing followed by test-refinement until the model matches the hardware for every test case. Finally, as a proof of concept for what experimental research can be done with the models, we have utilised them in two demonstrative numerical applications, quantifying application-level accuracy differences between AMD matrix cores and the NVIDIA tensor cores.

2026-09-13T23:34:01Z Faizan A Khattak Mantas Mikaitis Carlo J. Graziani http://arxiv.org/abs/2609.16064v2 2026-09-16T20:41:25Z

The array programming paradigm applies operations to entire arrays rather than individual elements, eliminating explicit loops and abstracting many low-level details of computation. Two influential approaches have shaped array programming: NumPy's broadcasting and Kenneth Iverson's array-oriented notation, with the latter first introduced in APL and later developed in the J language. Although NumPy's array programming model was influenced by Iverson's work, the two systems formalize array operations differently: NumPy primarily through array shapes and broadcasting, and J through verb rank. This paper establishes a formal correspondence between NumPy broadcasting and J rank and presents an implementation of NumPy broadcasting in J. The results provide a formal connection between two influential approaches to array-oriented computation and show how they address the common problem of applying operations to arrays with differing shapes without explicit loops.

2026-09-13T11:17:24Z Marcin Żołek http://arxiv.org/abs/2609.14433v1 2026-09-13T11:14:33Z

The computation of row echelon form is one of the main bottlenecks in the F4 algorithm. Several state of the art implementations use a probabilistic algorithm attributed to Monagan, Pearce, and Steel to accelerate this computation. Despite this, no bound on the probability that the algorithm returns an incorrect result appears to be available. In this paper, we provide such a bound. Furthermore, building on this result, we propose a Las-Vegas variant of the F4 algorithm and show experimentally that it can outperform deterministic F4 on some classical examples.

2026-09-13T11:14:33Z Alexander Demin http://arxiv.org/abs/2609.13875v1 2026-09-12T11:00:05Z

We introduce cvxgenrust, an open-source tool for generating custom Rust code that solves families of parameterized convex optimization problems modeled in CVXPY. cvxgenrust canonicalizes a problem family, extracts affine maps to Clarabel cone-program data, and generates a specialized Rust crate that updates parameters and calls Clarabel natively at runtime. The generated solver can also be exposed to Python and registered as a custom CVXPY solver. Our code generator supports a wide range of convex optimization problems up to semidefinite programs and exponential-cone problems. Numerical experiments show reduced runtime relative to direct CVXPY solves and performance comparable to CVXPYgen on shared problem classes.

2026-09-12T11:00:05Z Hao Zhu Joschka Boedecker http://arxiv.org/abs/2609.13755v1 2026-09-12T07:01:01Z

LP-Newton solves a linear program through a sequence of nearest-point problems. Given an interior feasible point for an inequality-form LP, we construct the compact hull formed by the origin and its normalized constraint rows. Polar LP-Newton (P-LPN) follows the objective ray to the boundary of this row-polar hull, where it recovers a primal-dual optimum or a recession direction proving unboundedness. For rational row-polar data, we prove an outer-iteration bound quadratic in dimension and linear in binary input length, excluding inner Wolfe work. Restarting Wolfe at every outer iteration discards its terminal corral even though the hull is unchanged and the next target lies on the same ray. Corral-repair P-LPN (CR-P-LPN) instead repairs that corral and uses it to start the next projection. Verification over the full hull preserves P-LPN's projections, outer targets, and LP conclusion in exact arithmetic. Experiments in Julia and MATLAB show where repair helps. After common initialization, median P-LPN times across 180 single-LP tests are 1.62 times the corresponding CR-P-LPN times in Julia and 1.55 times in MATLAB. On three problems with 5,000 to 100,000 rows, the corresponding geometric-mean factors are 2.03 and 1.46. A separate end-to-end study includes initialization on 19 application-derived LPs. CR-P-LPN has lower median total time than the faster cold HiGHS mode, either dual simplex or the interior-point method with crossover, on 18 of the 19 workloads in each language. The geometric means of the ratios of HiGHS time to CR-P-LPN time are 4.93 and 3.06. Component comparisons identify terminal-corral reuse as the useful component, whereas candidate-first ordering alone shows no consistent gain. Repair is not always beneficial: it is slower on Klee-Minty tests, and an author-implemented simplex is faster on the retained Netlib models.

2026-09-12T07:01:01Z 26 pages, 3 figures, 5 tables, 3 algorithms Yanfei Li Yuki Matsuno Jianming Shi http://arxiv.org/abs/2609.13643v3 2026-09-22T03:14:58Z

In Part I we extended the structure theorems underlying the Risch--Norman (parallel Risch) method to a simple radical extension $L=K(y)$, $y^m=q$, of a differential field $K=F(t_1,\dots,t_n)$ closed under the derivation. Here we remove the closure hypothesis: the radical may occupy any position in the tower, so that the derivatives of the generators above it involve $y$ --- the setting of Bronstein's algorithm for mixed elementary functions. The working ring is $\cA=\cO[t_{j+1},\dots,t_n]$, the integral closure of $F[t_1,\dots,t_n]$ in $L$: a Krull domain, free over the polynomial ring on Trager's basis, so that all factorisation remains in a unique factorisation domain. The denominator of the derivation is no longer an element but a divisor $\fd_D$ on $\cA$, and the valuation lemma takes the unified form $v_P(Dg)=v_P(g)-(1+v_P(\fd_D))$ at normal height-one primes, subsuming the shifts $\{1,e_P\}$ of Part I; the proof localises and requires no cancellation analysis. Stability of the class group and the unit group, $\Cl(\cA)\cong\Cl(\cO)$ and $\cA^*=\cO^*$, splits the admissible logands into $S$-units of $\cO$ --- computed by the machinery of Part I --- and irreducible polynomials moving in the upper variables, whose residues must be constants. We prove degree bounds in the top variable and describe the resulting algorithm, which --- unlike the classical parallel method, whose failure proves nothing --- returns certificates of non-elementarity in two situations: a residue outside the constant field, and, when every bound in force is proved, a residue-free remainder that the linear system shows to be non-exact.

2026-09-12T01:41:16Z Sam Blake http://arxiv.org/abs/2609.13596v1 2026-09-11T23:06:05Z

We study replacements in fixed bilinear tensor decompositions, counting changes to complete rank-one summands, including output factors. The shortening frontier records the maximum rank defect of a fixed-size subset and determines the minimum length attainable within a change budget. For the rational 48-term Li--Wang--Hu decomposition \(D(2)\) of \(4\times4\) matrix multiplication over \(\mathbb{C}\), we prove rank radius at least 12, strong radius exactly 11, and border radius at least 8. Every shorter complex decomposition therefore changes at least thirteen original summands. An exact rational twelve-term replacement attains the equal-length barrier. The proofs combine exhaustive support reductions with saturated projected kernels and zero-corner completion arguments controlling arbitrary minimal competitors. A reduced-incidence argument transfers kernel certificates to tensor-space neighborhoods. A Laurent normal form gives strong radius exactly 11 for the sixteen-term core at every nonzero complex parameter. On a nonempty Zariski-open subset of the actual parameter curve, the rank radius is at least 12, the strong radius exactly 11, and the border radius at least 8. We also prove incomparability of the full Kothari--Moitra--Wein sufficient criterion and the Sylvester-equipped kernel criterion. These results describe local decomposition structure rather than a new rank bound for full matrix multiplication.

2026-09-11T23:06:05Z Abhinav Agarwal http://arxiv.org/abs/2609.13529v2 2026-10-01T04:08:19Z

As the use of Large Language Models moves from chatbots into agentic systems, where outputs become actions with irreversible consequences on reality, the existing paradigm on AI Interpretability research, post-hoc interpretability, is structurally inadequate for safe and trustworthy model deployment: it explains behavior after the fact but cannot audit or intervene in an inference computation before it commits to an output. We therefore argue for a shift toward \emph{generative interpretability}, an architectural property under which a model's inference pass natively exposes semantically meaningful checkpoints that are human-understandable and amenable to causal intervention. We show the merits of generative interpretability as comparison to other interpretability research paradigms, and propose Neuro-Symbolic Models as a concrete instantiation.

2026-09-11T20:54:08Z ACM AI Summit 2026 Xiaocong Yang 10.1145/3806096.3844850 http://arxiv.org/abs/2609.13480v1 2026-09-11T19:49:23Z

Recent developments in the US knowledge economy have created a significant growth in datacenter loads, with two major consequences for power generation. First, to compensate for growth in load, datacenters are encouraged to bring their own generating units. Second, in search of the remaining pools of dispatchable generation, utilities are increasingly turning to subtransmission and distribution level generating assets. Coupled with increasing loads and the resulting tighter grid conditions, both trends are likely to create a need to commit a large number of localized generating units under grid constraints. We propose an extension of Relax-and- Round Unit Commitment (RRUC) that is capable of committing generating units for larger problems faster than conventional methods, while staying within intertemporal and spatial MVA constraints. We demonstrate the performance of RRUC using synthetic congestible test systems ranging from 100 to 20,000 buses. RRUC consistently finds low cost solutions, independent of the problem size, and its run time increases sub-quadratically in the number of buses. RRUC can solve the 100 bus system in less than a second and the 20,000 bus system 7 minutes. In contrast, a leading state of the art solver cannot find a feasible solution to the 100 bus system in 15 minutes.

2026-09-11T19:49:23Z 10 pages, 12 figures Evan J. R. Brody Charles Foltz Eve Tsybina Slaven Peles Shaked Regev http://arxiv.org/abs/2609.13325v1 2026-09-10T23:04:22Z

We study the rational quadratic differential equation \[ \frac{\mathrm{d}y}{\mathrm{d}x} = \frac{ay^2+by+cx}{y^2}, \qquad a,b,c\in\C, \] under the non-degeneracy assumptions \[ c\neq 0,\qquad 2ay+b\not\equiv 0. \] Equivalently, after clearing the denominator, we consider the polynomial vector field \[ \dot{x}=y^2,\qquad \dot{y}=ay^2+by+cx. \] We give a complete, directly checkable classification of its Darboux curves. If $a=0$, no non-constant Darboux polynomial exists. If $a\neq 0$, a non-constant Darboux polynomial exists if and only if \[ c=-ab\qquad\text{or}\qquad c=-2ab. \] In these two cases the unique irreducible Darboux polynomials, up to non-zero constant multiples, are respectively \[ y-ax,\qquad y^2-2bx. \] Consequently every non-constant Darboux polynomial is a non-zero constant multiple of a positive integral power of the corresponding irreducible factor. We then place this classification in the framework of Riccati (R-)integrability and rational potentials, and formulate the analytic integrability theorem asserting that a global Riccati-type analytic first integral occurs precisely on the branch $c=-ab$. Finally, we relate this branch to the Quartic Inverse Riccati (QIR) class and discuss an invariant-based classification problem for quartic Abel equations.

2026-09-10T23:04:22Z Shaoxuan Huang http://arxiv.org/abs/2609.11923v1 2026-09-10T17:58:14Z

Counterfactual regret minimization (CFR) is one of the few large numerical workloads that still runs faster on CPUs than on GPUs. Each iteration sweeps a game tree with up to billions of states in millions of small, interdependent gather and scatter steps issued through a generic tree interface. On a GPU every kernel finishes in microseconds, so kernel launches and framework dispatch dominate the run time, and prior GPU implementations have lost to optimized CPU code. We observe that for a fixed game, everything about a CFR iteration except the numerical values is known before the first iteration runs. We propose GPU-CFR, a compiler and runtime built on this observation. It compiles any game once into static dataflow: flat edge and information-set arrays, precomputed indices, and depth-level batched passes fix the entire operation sequence, and only solver state changes between iterations. Static chance folding, depth-level execution blocks, and a dual-lane reach buffer cut the number of framework operations by up to 18.1x. Because shapes, indices, and buffer addresses never change, CUDA Graph Replay records the iteration once and replays it with a single graph launch. On one A100, across an eight-game suite that spans card games, dice games, and board games, GPU-CFR runs 29.8--80.4x faster than the fastest prior GPU CFR on the same accelerator, and 14--258x faster than LiteEFG, one of the fastest open-source CPU implementations, on the four largest games. The compiled representation carries most of that margin: on eight CPU threads with no accelerator it is already 2.2--51.1x faster than the GPU baseline. On the CPU the optimized path reproduces the reference iterates bitwise, and tree construction and graph capture pay for themselves within the first solve. GPU-CFR beats every CPU and GPU baseline on the mid-to-large games of the suite without changing the update rule.

2026-09-10T17:58:14Z Boning Li Longbo Huang http://arxiv.org/abs/2609.12027v1 2026-09-10T14:54:41Z

We present a fast algorithm for multiplying two 4x4 matrices using 48 multiplications and 216 other operations (addition, subtraction or scaling by a constant) over any ring containing an inverse of 2. Applied recursively, this algorithm reaches a cost bound with leading term $7.75 n^{\log_4(48)}$. This is, up to our knowledge, the best-known leading constant in the cost for matrix multiplication algorithms with exponent $log_4(48)$. We further present an alternative basis version of this algorithm, reducing the leading term to $6.5 n^{\log_4(48)}$ by minimizing the extra cost after the change of basis.

2026-09-10T14:54:41Z Jean-Guillaume Dumas UGA, LJK, CASC Clément Pernet CASC Alexandre Sedoglavic CRIStAL Petr Tichavský http://arxiv.org/abs/2609.11588v1 2026-09-10T14:19:20Z

Direct evaluation of the defining product in the real Cayley--Dickson algebra $A_n$, of dimension $N=2^n$, has quadratic arithmetic complexity. This paper gives a uniform algorithm for multiplication using $O(N\log N)$ real arithmetic operations and $O(N)$ auxiliary storage. The algorithm reduces multiplication to the alternating product on the imaginary subspace, then evaluates that product by a two-call recursion over one fixed quadratic coefficient extension. For $n\ge1$, the resulting bilinear algorithm uses at most $(9n-15)2^{n-1}+10$ input-dependent real multiplications, and for $n\ge3$, the specified arithmetic schedule uses $(34n-83)2^{n-1}+50$ real operations in total. Under this counting convention, the quasilinear schedule uses fewer operations than direct multiplication for $N\ge16$ and than the uniform Cariow--Cariowa method for $N\ge32$. The algorithm is implemented in the MIT-licensed C11 library fastCD, with a NumPy-backed Python interface, and its results are checked against an independent implementation of the defining recursion. In single-core benchmarks against direct multiplication and the uniform Cariow--Cariowa method, the quasilinear implementation had the lowest mean time of the three at every tested dimension $N\ge32$, for both single and batched products, and was roughly $16$ times faster than direct multiplication at $N=1024$.

2026-09-10T14:19:20Z 20 pages Harrison Lemley http://arxiv.org/abs/2609.11210v1 2026-09-10T08:14:40Z

The discovery of the EML operator, sufficient to evaluate the standard explicit purely transcendental elementary functions, has led to considerable interest and discussion across multiple scientific disciplines. However, most authors have focused on the binary EML itself, while numerous similar variants with slightly different properties are now known. This article attempts to close this gap by enumerating and classifying them. We also take this opportunity to clarify common misconceptions related to the EML operator. The principal goal, symbolic regression within an architecture as close as possible to proven neural networks which combine matrix multiplication with a single univariate non-linear activation function, remains beyond reach. Instead, we propose a Möbius layer, with rational functions replacing matrix operations, and showcase the recently discovered activation function eml(x,1/x), which allows exp(x) and ln(x) to be recovered separately, and hence all elementary functions to be evaluated within a rational generalization of the neural network.

2026-09-10T08:14:40Z 25 pages, 2 figures, see also the TNG Big Techday conference recording at https://youtu.be/8942GJdrCYI?si=Q4XO0ZlQRK9JDAvK. Wolfram Mathematica implementation of a Goldstern-type single operator in the Appendix. Follow-up to arXiv:2603.21852 Andrzej Odrzywołek