Papers for

cryptography developers

Papers whose findings have a practical use for this group, as judged from the abstract. Open a paper to read what it means in practice.

New upper bound found for lengths of certain error-correcting codes

A Uniform Upper Bound on the Length of MDS Codes from Genus-Two Curves

Abstract: We study the maximal length of MDS algebraic geometry codes from genus-two curves over finite fields. Let $C_\mathcal{ L}(D,G)$ be such a code over $\mathbb F_q$, with length $n$ and dimension $k$. Assume that $3\leq k\leq n-3$. We prove that $n<(2q+10\sqrt q+16)/3$. This bound holds for every prime power $q$ and for both parities of $k$. It gives a uniform upper bound of $2q/3+O(\sqrt q)$ for the maximal length. The explicit bound is strictly smaller than $q+1$ when $q\geq125$.

Thu 29 OctInformation Theory
The gist
This paper finds a new limit on how long special error-correcting codes, called MDS codes from genus-two curves, can be. These codes help fix errors when sending data over noisy channels. The authors show that the length of these codes must be shorter than a specific formula depending on the size of the underlying field. This helps better understand the capabilities and limits of these particular codes in coding theory.
Open → 2610.39364v1

Random non-commutative codes achieve good error correction in certain groups

Random Non-Commutative Error-Correcting Codes

Abstract: Chapman, Dinur, and Lubotzky recently introduced the theory of non-commutative error-correcting codes, generalizing classical coding theory to arbitrary groups via $δ$-robust subsets used to detect proper subgroups. Building on this foundation, this paper systematically studies an analogue of random codes for arbitrary groups, exploring the extent to which the classical Gilbert-Varshamov (GV) bound holds in this non-commutative setting. While random universal codes of linear size in free groups are shown to be asymptotically bad, we establish a complete characterization for general families of finite groups. Specifically, a family of finite groups admits good random codes (forming a GV family) if and only if it exhibits uniform polynomial maximal-subgroup growth. Furthermore, we provide explicit quantitative bounds on the rate and optimal distance range based on intrinsic parameters, proving that families of finite solvable groups always form GV families and determining the exact probabilistic rate for direct powers of a fixed finite simple group.

Wed 28 OctInformation Theory
The gist
Error-correcting codes help detect and fix errors in data, usually using math where order doesn’t matter (commutative). This paper studies codes in settings where order matters (non-commutative groups). The authors find that random codes work well only in groups with specific growth properties, like solvable groups, while they perform poorly in free groups. They also provide exact measurements of how well these codes can work depending on the group.
Open → 2610.38804v1

Minimality conditions clarified for binary codes from weight layers and graph cuts

Minimality of Binary Codes From Weight Layers and Graph Cut Spaces

Abstract: Minimal binary linear codes play an important role in secret-sharing schemes and in the structural study of linear codes. We study the minimality of three classes of known constructions: codes from a single complete Hamming-weight layer, codes from arbitrary unions of such layers and graph cut-space codes. For the previously studied single-layer codes C, we give a complete minimality classification: C is minimal if and only if t is even. For t = 4, we determine the minimum and maximum weights, and show that the family strictly violates the binary Ashikhmin Barg sufficient condition for every k. We also calculate the minimum distance of the dual code. For arbitrary unions of complete Hamming-weight layers, we obtain an if-and-only-if classification of minimality and uniform criteria for evenness, self-orthogonality, the doubly even property and hull dimension. We further analyze the family for odd k. Finally, using the classical bond characterization of cuts, we translate minimality of graph cut space codes into a graph-theoretic condition: a nonempty simple graph has a minimal cut code precisely when it has one edge-containing component and that component is complete. We also give a graph-function realization of the known binary tetrahedron code and explicitly identify the resulting code equivalence.

Mon 26 OctInformation Theory
The gist
The paper studies when certain binary codes have a property called minimality, which is important in secret-sharing and understanding code structure. The authors fully describe when codes made from specific weight groups are minimal and explore other related code properties. They connect minimality in codes from graph cuts to a simple condition about the graph’s shape. This work sharpens the understanding of these code families and their key characteristics.
Open → 2610.35372v1

New results on odd prime field codes with self-orthogonality and weight analysis

Further Study of p-Ary Self-Orthogonal Codes From Square Functions

Abstract: In this paper, we investigate a family of trace codes over finite fields of odd characteristic defined by two quadratic trace conditions. By analyzing the quadratic forms associated with these trace conditions and evaluating the corresponding character sums, we obtain the parameters and complete weight distributions of the codes. We further exploit the natural multiplicative orbit structure of the defining sets to obtain punctured codes and determine their parameters, weight distributions and dual distances. Moreover, we establish self?orthogonality criteria and investigate divisibility and projectivity of the constructed codes. These results give a unified treatment for arbitrary odd prime fields and for extension degrees of both parities.

Mon 26 OctInformation Theory
The gist
This paper studies special error-correcting codes created from certain mathematical functions over fields with an odd number of elements. The authors analyze these codes by examining their defining quadratic conditions and counting related sums, which lets them find the code parameters and how weights are distributed. They also define smaller codes by removing some parts and check their properties, including when these codes are self-orthogonal (a useful symmetry). Their work applies broadly to codes over any odd prime field and for all extension sizes.
Open → 2610.35346v1

Grokking behavior in networks linked to structure of Latin squares

Mapping the Solution-Set Structure of Grokking on Latin Squares

Abstract: Grokking is a delayed transition from memorisation to generalisation. A network first fits observed examples while remaining near chance on held-out inputs, then generalises abruptly. Prior work has focused mainly on this delay, finding that the network's main loss becomes weight decay after the fitting phase. We name the solution to this optimization problem as the minimum-norm endpoint, and study which tasks make all minimum-norm endpoints generalise from partial observations. Specifically, we model pairwise input tasks as edge colourings of $K_{q,q}$, with Latin colourings as our structured family, and classify each observed instance as all-good, mixed, or no-good by its endpoint set. Furthermore, we prove two contrasting results: (1) Finite-abelian-group families are asymptotically all-good from partial observations; (2) Under a uniform random Latin square, all-good tasks become asymptotically rare for observation-based learners, leaving mixed or no-good behaviour. Moreover, experiments show that relabellings of addition generalise despite their dense polynomial representations. Finally, on tasks of composite order, finite-training results suggest that predictors learn a coarse part of the output before the full label.

Mon 26 OctMachine Learning
The gist
Grokking happens when a neural network suddenly shifts from just memorizing to truly understanding a task after some delay. The authors study this effect using mathematical objects called Latin squares, which represent structured problems, to see when networks can generalize well from partial data. They find that for certain structured tasks tied to groups, networks almost always generalize well, but for random Latin squares, good generalization becomes rare. The work helps explain when and why grokking happens by showing how problem structure influences the learning outcomes.
Open → 2610.35036v1

Explicit counts and limits for subcodes with fixed hull dimensions

Subcodes with Prescribed Hull Dimensions in Linear Codes:Enumeration, Containment, and Asymptotic Distributions

Abstract: Mass formulas for prescribed hull dimensions have mainly been studied for linear codes viewed as subspaces of the whole space. We study internal enumeration for an arbitrary fixed parent code. Let $C$ be an $[n,k]_q$ linear code with an $\ell$-dimensional hull, and let $s$ be the subcode dimension. We determine the number of subcodes with prescribed dimension, hull dimension, and type over finite fields of both even and odd characteristic. We decompose the parent code into an LCD complement and its hull, and use projection to reduce enumeration to the corresponding problem inside the LCD complement. This yields explicit formulas refined by complete type and shows that the counts depend only on the relevant parameters, not on the particular parent code or its length. The known whole-space mass formulas and the enumeration of LCD subcodes of LCD codes arise as special cases. Motivated by code extension, we also study the dual containment problem: for a fixed code, we enumerate larger codes containing it with prescribed hull dimension and type. By duality, this problem is converted into the subcode enumeration problem already solved above, leading to corresponding conditional mass formulas. Finally, we investigate the asymptotic distributions arising from the exact enumeration formulas. When both the subcode dimension $s$ and $k-\ell-s$ tend to infinity, the hull distribution is governed by the LCD complement, and the limiting proportions are explicit constants determined by the field, the prescribed hull dimension, and the relevant type. When $s$ approaches or exceeds the dimension $k-\ell$ of the LCD complement, we determine the asymptotic proportion of subcodes attaining the minimum possible hull dimension and establish the associated concentration behavior. Analogous asymptotic results are obtained for the containment problem.

Mon 26 OctInformation Theory
The gist
This paper studies how many smaller parts (subcodes) of a bigger code can have certain shared properties related to their 'hull,' a part used in error correction and data security. The authors work out exact formulas for counting such subcodes inside any fixed code, no matter its size or shape. They also solve a related puzzle about bigger codes that contain a given code with specified hull properties. Finally, they describe how these counts behave when code sizes get very large, revealing predictable patterns. Their work builds on and generalizes earlier results for codes inside the whole space.
Open → 2610.34937v1

Four-valued cross-correlation found between sequences with different periods

A class of Niho type four-valued cross-correlation functions between sequences of different periods

Abstract: Determining the cross-correlation distributions between $m$-sequences and their decimated sequences is an important problem in sequence design. For two positive integers $n$ and $k$ with $n=2k$, this paper investigates the cross-correlation function between a binary $m$-sequence $\{u(t)\}$ of period $2^{n}-1$ and its $2^{\gcd(s,k)}+1$ short-period decimated sequences $\{u(dt+l)\}$, where the decimation $d=\frac{2^s}{2^s+1}(2^k-1)+1$ satisfies $1<s<n$ and $v_2(s)>v_2(k)$. The cross-correlation function is proved to be four-valued and its value distribution is completely determined. Several previously known binary cross-correlation functions are included in our result as special cases.

Sun 25 OctInformation Theory
The gist
Understanding how certain repeating sequences interact is important for communication and data processing. This paper shows that when you look at a specific kind of binary sequence and a related shorter sequence created from it, their interaction has exactly four possible values. The authors provide a full description of these values and how often each occurs. Their result also includes some previously known cases as special examples.
Open → 2610.34010v1

Integer determinant reveals key length rules for binary Type II codes

An integer determinant approach to the length of Type II codes and the weights of shadows

Abstract: It is well known that the length $n$ of a binary Type II code is divisible by $8$. The classical proof relies on Gleason's theorem on weight enumerators. Motivated by a question of Vera Pless, we give elementary proofs of this fact that avoid invariant theory. Our main tool is a congruence modulo $8$ for the determinant of the integer Gram matrix $AA^{\mathsf T}$ of a binary orthogonal matrix $A$, obtained directly from the Leibniz expansion. It gives a short proof of a theorem of Janusz: the number of rows of weight congruent to $3 \pmod 4$ in a binary orthogonal matrix is divisible by $4$. From this single statement we derive both the length restriction for Type II codes and the theorem of Conway and Sloane that every vector in the shadow of a binary self-dual code of length $n$ has weight congruent to $n/2 \pmod 4$. We also give two short character-theoretic proofs of the length restriction and explain how all of these arguments detect the Arf invariant of a quadratic form.

Thu 22 OctInformation Theory
The gist
Certain special binary codes called Type II codes only come in lengths divisible by 8, but the usual proof for this is complicated. The authors provide a new, simpler proof using integer determinants and properties of binary orthogonal matrices. Their approach also explains patterns in related structures called shadows of these codes and connects these findings to a mathematical concept called the Arf invariant. This work avoids advanced tools from invariant theory, making the results more accessible.
Open → 2610.30809v1

Maximum length limits of special cyclic error correcting codes

On the maximum length of cyclic MDS codes

Abstract: We study the maximum length of nontrivial simple-root cyclic maximum distance separable (MDS) codes over ${\mathbb F}_q$. We prove $n\le q+1$ if $\gcd(n,q^2-1)>2$, or if the dimension is even and $\gcd(n,q^2-1)>1$. The bound also holds for all lengths whose prime factors lie in $\{2,3,5,7\}$. We obtain further cases involving primes $\ell\ge11$ with $(\ell-1)/2$ prime, under conditions on the exponents and the characteristic. The proofs combine Fourier supports, locality bounds and field descent with arithmetic restrictions on multiplicative orders and prime-adic valuations.

Wed 21 OctInformation Theory
The gist
This paper studies the longest possible size of a type of error-correcting code called cyclic MDS codes, which are used to detect and fix errors in data. The authors found new rules that limit how long these codes can be based on mathematical properties of their size and the field they work over. They use advanced algebra and number theory tools to prove that, under certain conditions, these codes cannot exceed a specific length related to the size of the field. This helps clarify when such codes are possible and when they are not.
Open → 2610.29810v1

Polynomial support patterns simplify constacyclic code structure over rings

Support periods of polynomials and support-primitive decomposition of constacyclic codes over Galois rings

Abstract: Let \(A=\GR(p^e,r)\) have residue field \(\F_q\), and let \(λ\in A^\times\). We relate coefficient compression of monic divisors of \(X^N-λ\) to support-primitive decomposition of constacyclic codes. At a simple-root length, the support period of every nonconstant monic divisor is preserved at each coefficient precision and equals the order of the multiplicative stabilizer of its root set. For a cyclic Frobenius-orbit polynomial, the multiple equal-difference structure determines its support period, core degree, and least relative degree of an unramified extension over which all its basic-irreducible factors are binomials. Coordinate projections give every constacyclic code over a finite commutative ring a unique maximal interleaving into copies of one support-primitive code. At simple-root lengths over \(A\), the intrinsic period of a code is the greatest common divisor of the periods of its torsion codes. The decomposition yields distance and duality formulas and the arithmetic Singleton bound for free codes. At every length, a nonzero code over \(A\) has the same minimum Hamming distance as its highest torsion code, which gives a refined bound. At repeated-root lengths, identical torsion filtrations can occur with different intrinsic periods, while a class of nonzero codes obtained by substitution from simple-root generators retains the same core and minimum distance. Trace matrices recover the coefficients of basic-irreducible cores using unit pivots, and local Hensel corrections lift compressed factors directly. For \(X^n-1\) with \(p\nmid n\), lifting and output have quasi-linear bit cost in the compressed representation when the arithmetic data and residue factorizations are given.

Wed 21 OctInformation Theory
The gist
The paper studies certain types of error-correcting codes, called constacyclic codes, over complex algebraic structures known as Galois rings. It shows how breaking down these codes into simpler pieces based on patterns in polynomial coefficients helps understand their properties like error detection and correction strength. The authors connect these patterns to unique decompositions that reveal important distances and dual codes. Their work also provides efficient methods for calculations, especially when codes have simple constraints on their length.
Open → 2610.29284v1

Algorithms for solving noisy k-XOR problems under various noise and sample sizes

A Short Note on Algorithms For The Noisy $k$-XOR Problem

Abstract: This mostly expository note studies the sample-noise regimes in which the testing problem for noisy $k$-XOR in dimension $n$ can be efficiently solved. Concretely, we ask what pairs $(β, δ)$ admit algorithms running in time $n^{O(k)}$ where $m = n^β, β\in [0,k]$ is the number of samples and $\mathsf{Bern}(n^{-δ}),δ\in (0,+\infty)$ is the noise distribution. The current state-of-the-art algorithms are: I. A folklore algorithm when $β> 1, δ>1$ based on Gaussian elimination; II. A folklore algorithm when $β\ge k/2$ based on the birthday paradox; III. A recent algorithm in the regime $β> δ+ k(1-δ), δ\in (0,1)$ based on a reduction to the first algorithm [DJ24,CSZ24]. IV. Extending [AF09], we strictly improve the last regime to $β> δ+ (k-1)(1-δ), δ\in (0,1).$ These algorithms correspond to efficiently finding short cycles in uniform hypergraphs and can be equivalently phrased as algorithmic Moore bounds.

Mon 19 OctData Structures and AlgorithmsComputational Complexity
The gist
The paper looks at when and how noisy k-XOR problems can be solved efficiently, considering how many samples and how much noise affect the process. Noisy k-XOR problems involve finding hidden patterns in data where errors or noise are present. The authors discuss known algorithms that work in different ranges of sample quantity and noise level, and they improve on one specific range where the problem can be solved faster. Their work connects these problems to finding certain structures called short cycles in complex networks.
Open → 2610.27147v1

Frobenius profiles of polynomial-based maximum rank distance codes studied

Frobenius Profiles of Polynomial-Multiple MRD Codes

Abstract: We study Frobenius intersection profiles of maximum rank distance (MRD) codes arising from ordinary polynomial multiples over finite fields. We prove that every numerically admissible profile is realized within this family over every sufficiently large extension, using a root-exponent pattern independent of the extension degree. A factor-orbit gap formula provides the underlying structural description, while effective extension-degree bounds guarantee realization. We also establish a lower bound valid for all polynomial generators and show that the upper and lower bounds differ by only $O_q(\log n)$ along an infinite family of parameters. Finally, we characterize the generalized Gabidulin members and obtain non-generalized-Gabidulin realizations of every profile with initial loss at least two over infinitely many extensions.

Mon 19 OctInformation Theory
The gist
This paper explores special patterns called Frobenius intersection profiles in certain error-correcting codes known as maximum rank distance (MRD) codes. These codes are built using polynomials over finite fields, and the authors show that all possible profiles (within certain numerical limits) can be achieved with their constructions. They provide formulas to describe the structure and give bounds on how large the underlying fields need to be. They also identify which codes belong to the well-known Gabidulin family and discover new examples outside of that family with specific profile properties.
Open → 2610.25722v1

Learning group elements from their actions reveals dimension gaps

Learning a Group Element from Its Action: Galois Correspondences, Optimal ERM, and an Abel-Ruffini Threshold for the Natarajan Dimension

Abstract: We study learning an unknown element $g$ of a group acting with finite orbits on a countable set, from examples $(x,gx)$. After a sample on $A$, the consistent hypotheses are the restrictions of a coset of the pointwise stabilizer of $A$, and the sample forces exactly the labels of points this stabilizer fixes; for a Galois group, they form the field generated by the data. Through this correspondence, multiclass dimensions become group invariants: the DS and graph dimensions equal the height, the Littlestone dimension the longest irredundant sequence length, and the teaching dimension the minimal base size. Among deterministic learners, symmetry makes empirical risk minimization optimal: on nondegenerate classes every consistent learner, whatever its tie-breaking, attains the optimal realizable sample complexity up to constant factors, and every consistent online learner the optimal mistake bound. Agnostically, every ERM's sample complexity exceeds the known lower bound by at most the DS-to-Natarajan ratio, up to constants. For finite Galois extensions of countable fields, the Natarajan dimension equals a group invariant, the coset-cube number, which is at least the number of complemented factors of any chief series of any subgroup. Hence the dimensions coincide for every solvable Galois group, while for the groups $A_5$ and $S_5$ of the quintic they are $2<3$ and $3<4$, and $A_5$ is the smallest group with a gap. For the Galois group $S_n$ of the general equation of degree $n$, they coincide exactly when $n\le 4$, i.e., in characteristic zero, exactly when the equation is solvable by radicals; the implication is one-way, as the simple group $\mathrm{PSL}(2,8)$ has no gap. For linear, orthogonal and unitary maps of $\mathbb R^d$ or $\mathbb C^d$ both dimensions equal $d$, and a two-fibered pseudo-cube is a disjoint union of Natarajan cubes exactly when its monodromy group is abelian.

Tue 13 OctMachine Learning
The gist
This work looks at how to figure out an unknown group element by seeing how it transforms items in a set. The authors connect the learning problem to classical group theory concepts, showing that several complexity measures in learning correspond to group invariants. They find that for certain well-understood groups, these dimension measures match, but for more complex groups like those related to solving fifth-degree equations, gaps appear. This relationship ties deeply into the classical Abel-Ruffini theorem about solvability of equations by radicals. They also prove that simple learning methods work optimally in these settings.
Open → 2610.18154v1

Matrix multiplication advances improve 3SUM and shortest path algorithms

Thin matrix products up to D <= N^0.172 and lossless reductions for 3SUM, Exact Triangle and APSP, with 3SUM over abelian groups and a dichotomy for coordinatewise problems

Abstract: Alman and Vassilevska Williams (arXiv:2610.06783) gave the first polynomial improvements over the textbook algorithms for 3SUM and APSP: deterministic algorithms with exponents 1.9992 for 3SUM, 2.9983 for Exact Triangle and 2.99942 for APSP. Their algorithm has two steps: a matrix theorem, computing N^2/sqrt(D) prescribed entries of the product of an N x D and a D x N integer matrix in time N^2/D^gamma, gamma > 0, when D <= N^eps, for every eps < 0.1204; and reductions from the three problems to the lopsided sparse triangle problem. We improve both. With Schönhage's five-term partial-product tensor, the matrix theorem holds for every eps < 0.172. The preprint's reductions keep a quarter of the matrix theorem's saving for 3SUM and a half for Exact Triangle and APSP; ours keep all of it, by calling the counting version of the triangle problem adaptively and building composite moduli one prime at a time. Together this gives deterministic 3SUM in n^{1.9945+o(1)}, and Exact Triangle, (min,+)-product and APSP in n^{2.9945+o(1)}. We also improve on the preprint's proof sketch for 3XOR and solve it deterministically in O(n^{1.99451}). Which other problems on three lists does the method make truly subquadratic? It solves 3SUM over F_p^d for every fixed prime p with 3XOR's exponents, and over every finite abelian group of exponent p^2, such as Z_4^d, in O(n^{1.99726}). For coordinatewise problems with a fixed relation P on every coordinate triple, a certified exhaustive computation shows that every Boolean P, and every functional P over three letters, either is the solution set of an equation over Z, F_2 or F_3, and the problem is then truly subquadratic, or has a gadget for Orthogonal Vectors, and the problem is then hard under the Orthogonal Vectors hypothesis. Over four letters, just four functional relations, up to symmetry, satisfy neither condition.

Mon 12 OctData Structures and Algorithms
The gist
Some important math and computer problems, like finding triples that add to zero (3SUM) or shortest paths in graphs (APSP), were thought to require very long times to solve. The authors improved earlier work that made these problems a bit faster, by extending a key math tool to work with bigger matrices. They also made smarter ways to reduce these problems to easier ones, keeping all the speed gains. This means they have slightly faster guaranteed methods to solve several core problems in computer science, including special versions over certain mathematical groups.
Open → 2610.17420v1

Synchronous tile systems can simulate complex computations with simple setups

The Rhythm of the Tiles: Narrow and Low Temperature Computation and Simulation in Synchronous Tile Self-Assembly

Abstract: In this paper, we prove that the synchronicity provided by the syncTAM can be leveraged to perform two additional feats impossible in the asynchronous aTAM. The aTAM has long been known to be equivalent to finite automata in the one-dimensional case. For our first set of results, we prove that this still holds when a finite, fixed amount of space is available in the second dimension. Yet, surprisingly, in the synchronous setting, a small, fixed, width is enough to simulate a Turing Machine. This holds even in the non-cooperative setting. For our second set of main results we prove that there exists a single set of syncTAM tiles that can be used to simulate any syncTAM system simply by using those tiles to create a scaled version of the seed structure of the original system and then letting the tiles from that set self-assemble from the scaled seed structure. While it has been shown (FOCS 2012) that such a tile set also exists in the aTAM for simulating all aTAM systems, that "intrinsically universal" (IU) tile set requires cooperativity (and is impossible without cooperativity as shown in SODA 2014). We prove there exists an IU tile set in the syncTAM that works without cooperativity. Furthermore, there exists a tile set that is IU for the class of directed systems (i.e. systems which each have a single terminal assembly) while remaining directed during simulation. This was shown to be impossible in the aTAM (FOCS 2016).

Mon 12 OctComputational Geometry
The gist
Some tiny building blocks called tiles can stick together to form patterns and perform computations. The authors show that when these tiles stick in a synchronized way, even a narrow strip of tiles can do very complex calculations similar to a full computer. They also find a special set of tiles that can mimic any other tile system’s behavior without needing any extra cooperation. This level of control and simplicity in tile-based computation was not possible before without coordination.
Open → 2610.17112v1

Hyperderivative Reed-Solomon codes decoding radius and difficult cases studied

Covering Radius and Deep Holes of Hyperderivative Reed-Solomon Codes under the NRT Metric

Abstract: The deep hole problem is a fundamental problem in coding theory, and it has many important applications in code constructions and cryptography. The deep hole problem of Reed-Solomon codes has gained a lot of attention. As a generalization of Reed-Solomon codes under Hamming metric, we study the covering radius and deep holes of Hyperderivative Reed-Solomon (HRS) codes under the Niederreiter-Rosenbloom-Tsfasman (NRT) metric. We determine the NRT covering radius of HRS code and characterize its NRT deep holes via Maximum Distance Separable (MDS) extensions and polynomial remainder conditions. We further relate the enumeration of NRT deep holes to the characteristic polynomial of an associated hyperplane arrangement. We also provide three classes of explicit NRT deep-hole constructions, propose a Cheng-Murray type conjecture for HRS codes under the NRT metric and obtain a conditional low-layer description. Using these characterizations, we derive exact enumeration formulas in several special cases.

Mon 12 OctInformation Theory
The gist
This paper studies a type of error-correcting code called Hyperderivative Reed-Solomon codes, which are used to protect data. The authors focus on how far off a received message can be from any valid codeword—the covering radius—and identifying particularly tricky received messages called deep holes. They describe these deep holes using mathematical properties related to polynomials and geometric structures, and provide several explicit examples. They also make a conjecture about the codes’ behavior and offer formulas to count these difficult cases in some situations.
Open → 2610.16643v1

More than 83 percent of zeros of the Riemann zeta function are distinct

More than 83.69% of the zeros of the Riemann zeta function are distinct

Abstract: The lower asymptotic proportion of distinct nontrivial zeros of the Riemann zeta function, counted with multiplicity, is at least $0.8369928814\ldots$. The previous bound was $0.83625\ldots$. As in the proof of that bound, an unconditional version of Montgomery's pair-correlation theorem gives an asymptotic energy estimate. The new ingredient is a short matrix inequality with a free clipping parameter. It strengthens the lower bound for this energy in terms of the number of distinct zeros. The gain is a nonnegative correction from overlaps between different nearby zeros on the critical line, which is retained even when some of these zeros are double. The matrix inequality, the threshold lemma, the block dichotomy, the counting assembly and the exact arithmetic are proved formally in Lean 4. The constant relies on a computer-assisted local inequality from recent work that has not yet been refereed. That computation was re-run independently, and every imported input is listed. This paper is primarily an experiment in AI-assisted mathematical research (Section 4).

Sun 27 SeptArtificial IntelligenceLogic in Computer Science
The gist
The Riemann zeta function is a key object in mathematics connected to the distribution of prime numbers. Its zeros—special points where the function equals zero—are important to study, especially whether these zeros are distinct or repeated. This paper shows that at least about 83.7% of these zeros are unique, improving previous estimates. The authors use advanced mathematical tools and computer assistance, including formal proofs verified by software, to achieve this refined result.
Open → 2609.33043v1

Eigenvalues of special matrices follow semicircle law accurately

Comment on "Symmetric Pseudo-Random Matrices"

Abstract: In 2018, Soloveychik, Xiang and Tarokh considered a pseudo-random symmetric circulant matrix constructed from binary Golomb sequences of length $n=2^m-1$, and claimed a proof that its empirical spectral distribution converges almost surely to the semicircle law as $n$ grows to infinity by the method of moments. In this comment note we show that their argument contains several technical flaws and inappropriate applications of technical lemmas. Instead we demonstrate that the eigenvalues of the matrix are simply a normalized twisted Kloosterman sum varying over the multiplicative character, to which we apply Katz's result directly to establish the asymptotically semicircle spectral distribution deterministically.

Fri 25 SeptInformation Theory
The gist
Some researchers previously claimed that certain large symmetrical matrices built from special binary sequences behave in a predictable way when looking at their eigenvalues. This paper points out flaws in their proof and provides a clearer and more reliable understanding by connecting these eigenvalues to well-studied mathematical sums. Using known results from number theory, the authors show that the eigenvalues of these matrices follow a specific pattern called the semicircle distribution without relying on probabilistic arguments.
Open → 2609.30689v1

Algorithms refute semirandom linear equations faster than known methods

Strongly Refuting Semirandom Linear Systems in Subexponential Time

Abstract: In this paper, we consider the problem of refuting $\mathbb{F}_2$-linear equations with random right-hand sides. Formally, we give a sub-exponential $2^{O(n/\log n)}$-time randomized algorithm that takes as input an arbitrary $m \times n$ matrix $A$ and a uniformly random vector $b \in \mathbb{F}_2^m$, and outputs a witness showing that no assignment satisfies more than a $\frac{1}{2}+ε$ fraction of the equations provided that $m \geq 2^{O(n/\log n)}$. The setting above is the semirandom refutation variant of the famous work [BKW03] that gives a $2^{O(n/\log n)}$-time search algorithm for the learning parity with noise (LPN) problem with $m \geq 2^{O(n/\log n)}$ equations. Building on the search algorithm of [Lyub05], we also give a $2^{O(n/\log \log n)}$-time refutation algorithm that succeeds with only $m \geq n^{1 + γ}$ equations, for a small constant $γ$. Finally, we prove that our algorithm is not captured by the sum-of-squares hierarchy by proving a degree-$Ω(n)$ sum-of-squares lower bound, showing that ''[BKW03]-style'' algorithms achieve better runtime than can be done under sum-of-squares. We thus obtain a natural example of a noise-tolerant signal recovery problem that exhibits a nontrivial gap between the performance of efficient algorithms and that of those based on the sum-of-squares hierarchy.

Thu 24 SeptData Structures and Algorithms
The gist
The paper tackles the problem of proving that certain systems of equations with random components cannot be mostly satisfied by any assignment. The authors develop new algorithms that work faster than previously known ones for finding such proofs under specific conditions. They also show that a common powerful mathematical technique, the sum-of-squares method, cannot match their algorithm’s performance in this task. This provides a clearer understanding of the limits of existing tools for solving noisy linear problems.
Open → 2609.30052v1

Quantum circuit design speeds up solving equations in any finite field

A Quantum Circuit for Gaussian Elimination

Abstract: A quantum circuit for Gaussian elimination is developed in this work. While previous quantum implementations of Gaussian elimination were restricted to $\mathrm{GF}(2)$, the proposed design is generalized to any finite field. Compared with previous works in $\mathrm{GF}(2)$, the developed circuit achieves garbage-free construction while retaining the best known asymptotic Toffoli depth up to logarithmic factors.

Thu 24 SeptEmerging Technologies
The gist
Solving systems of equations is important for many tasks in science and engineering. The authors developed a new quantum circuit that can perform Gaussian elimination, a common method for solving equations, but now on any finite field, not just simple binary ones. Their approach avoids unnecessary extra computations and keeps the process efficient in terms of the key quantum operations needed. This advancement could help in applying quantum computing to a wider range of mathematical problems.
Open → 2609.28901v1

OpenAI bound clarifies limits on binary code performance

On the OpenAI whole-cube bound

Abstract: This is an essentially derivative note, whose goal is to interpret the 'whole-cube' bound of OpenAI for binary codes in a possibly somewhat more accessible way. This is attained, in part, by connecting it to some previously known results. All of the heavy technical lifting in the interpretation below is also due to the OpenAI language models ChatGPT 5.6 and ChatGPT 6. With that, we hope that the statements of the main results, the ensuing discussion, and the arguments themselves may be of some interest.

Tue 22 SeptInformation Theory
The gist
This paper looks at a mathematical rule called the 'whole-cube' bound related to binary codes, which are ways of organizing data using just two symbols. The authors explain OpenAI's bound in a simpler way by linking it to older results. They used OpenAI’s own language models to help with the heavy math. Their explanation may help people better understand how this bound works and what it means for coding theory.
Open → 2609.26050v1

Code equivalence links to automorphism group problems for error correcting codes

Code Equivalence and Automorphism Problems for Codes

Abstract: We study the complexity of the Code Equivalence problem and show that it is polynomially equivalent to several computational automorphism problems for codes. These problems ask for the cardinality (ACOUNT), an orbit partition (APART), and a generating set (AGEN) for the permutation automorphism group of a code. We present deterministic, polynomial-time reductions between Permutation Code Equivalence (PCE) and each of these problems, including a one-shot reduction from search-PCE to AGEN that makes a single oracle call. We present similar reductions between Linear Code Equivalence (LCE) and analogous problems for the monomial automorphism group of a code. All of our reductions work for any linear codes.

Mon 21 SeptComputational Complexity
The gist
Sometimes, we need to tell if two error-correcting codes are basically the same, just arranged differently. This paper shows that figuring this out is just as hard as certain problems about the symmetries of these codes. The authors connect these problems through ways that let one solution quickly turn into another, for any kind of linear code. This helps understand and organize code comparison and symmetry problems as one set of related challenges.
Open → 2609.25483v1

Adaptive encoding reduces matrix multiplication steps on Nvidia tensor cores

AWE: Adaptive Weight Encoding for Exact Integer Matrix Products with Fewer GEMMs on FP4 Tensor Cores

Abstract: 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.

Mon 21 SeptMathematical SoftwareHardware Architecture
The gist
Multiplying big integer matrices exactly can be slow when using very low precision floating-point units like FP4, which are fast but limited in number size. The authors found a way to represent the numbers with flexible weights, reducing the number of smaller fast multiplications needed from 9 to 6 for 8-bit integers. This new method also applies to other settings and can speed up accurate matrix calculations on hardware like Nvidia B200 and B300 GPUs. They provide the detailed encodings to help others use these improvements.
Open → 2609.24519v1

Twisted Roth-Lempel codes offer new error correction options

On Twisted Roth-Lempel Codes

Abstract: In 1989, Roth and Lempel constructed a well-known family of non-Reed-Solomon maximum distance separable (MDS) codes. For decades, this family of codes has attracted extensive research attention due to its algebraic structure, low-complexity decoding, and broad applications in cryptography and data storage. In this paper, we present a class of twisted Roth-Lempel codes. We investigate their minimum distance, MDS and NMDS properties. Specifically, we determine the necessary and sufficient conditions for the TRL codes to have minimum distance n-k or n-k+1. Furthermore, we determine the necessary and sufficient conditions for the TRL code to be an MDS or NMDS code. Moreover, we show that the dimension of the Schur square of the TRL code is at least 2k+1, and thus the TRL code is a non-RS code inequivalent to the corresponding RL code.

Tue 15 SeptInformation Theory
The gist
Error correction codes help protect data from mistakes or losses. Roth and Lempel created a special type of such codes that many use in data storage and cryptography. This paper studies a new twist on those codes, called twisted Roth-Lempel (TRL) codes, and finds exact conditions when they work best. The authors also show these new codes differ from the old ones in important mathematical ways, which might help in applications needing strong, efficient error correction.
Open → 2609.17304v1

Quantum communication can beat classical for total functions

Improved Separations between Quantum and Classical Communication Complexity of Total Functions

Abstract: We refine Gavinsky's framework (arXiv:2608.18784) for exponential separations between quantum and randomized communication complexity of total functions and obtain larger separations: polylogarithmic quantum communication versus $\tildeΩ(\sqrt n)$ randomized communication with two quantum messages, and versus $Ω(n^{1-\varepsilon})$ for every fixed $0<\varepsilon<1$ with more quantum messages.

Tue 15 SeptComputational Complexity
The gist
This paper looks at how quantum communication compares to classical communication when solving certain problems. The authors build on an existing method and improve it, showing that quantum communication can use much less information than classical methods for some tasks. Specifically, they find cases where only a tiny amount of quantum information needs to be exchanged, but classical communication has to be very large to do the same. This strengthens the evidence that quantum communication can be much more efficient for certain kinds of problems.
Open → 2609.16726v1

Ideal lattice problems shown as hard as generic lattice problems

NP-hardness of ideal lattice problems

Abstract: We establish the worst-case hardness of several ideal lattice problems (including SVP and CVP) in the $\ell_2$ norm by providing a dimension-preserving, deterministic polynomial time reduction from their generic lattice versions. The reduction constructs an ideal lattice in the canonical embedding of a number field that approximates some input lattice up to scaling and orthogonal transformation. The integers defining the ideal and the ambient number ring, in particular its discriminant, are all polynomial in bit length relative to the generic input lattice. Furthermore, the ideal is invertible, the ring is monogenic, and the number field is totally real. If the number ring is also required to be a full ring of integers, the reduction conjecturally succeeds in bounded-error quantum polynomial time.

Mon 14 SeptComputational Complexity
The gist
Certain problems involving ideal lattices, which are special mathematical structures, are as difficult to solve as their more general lattice counterparts. The authors found a way to transform these general lattice problems into ideal lattice problems without making them easier to solve, using an efficient and deterministic method. This means that breaking these ideal lattice problems is at least as hard as breaking the generic ones, which is important in cryptography and computational theory. They also consider quantum computing scenarios for related constructions.
Open → 2609.15813v1

Weight patterns revealed for specific generalized Reed Muller codes

Weight spectra of some families of GRM codes

Abstract: Let $\mathrm{RM}_q(r,m)$ denote the generalized Reed--Muller code of order $r$ and length $q^m$ over the finite field $\mathbb{F}_q$. We completely determine the weight spectra of $\mathrm{RM}_3(2m-i,m)$ for $i=3,4$, $\mathrm{RM}_4(3m-i,m)$ for $i=2,3$, $\mathrm{RM}_5(4m-4,m)$, and $\mathrm{RM}_7(6m-4,m)$, in the ranges of $m$ specified in the corresponding results. The proofs proceed by induction on $m$, using a sumset inclusion for GRM weight spectra together with results on low-weight codewords. The required base cases are established by computations in Magma and, for certain ternary cases, exact constraint solving with Z3.

Sat 12 SeptInformation Theory
The gist
Generalized Reed–Muller codes are mathematical tools used to detect and correct errors in data transmissions. The authors figured out exactly which weights (or error-correcting capabilities) appear in certain families of these codes when the parameters follow specific patterns. Their method uses mathematical induction combined with computer calculations to confirm the patterns. This helps expand what we know about these codes and how they might perform.
Open → 2609.13653v1

Deterministic algorithm improves permanent matrix approximation accuracy

Subexponential Approximation of the Permanent in Deterministic Polynomial Time

Abstract: We give the first deterministic polynomial time algorithm that approximates the permanent of arbitrary nonnegative rational matrices within a subexponential factor. For a matrix of order $n$, the approximation factor is \[ \exp\!\left(O\!\left(\frac{n(\log\log n)^2}{\log n}\right)\right)=\exp(o(n)). \] All previously known deterministic polynomial time guarantees for unrestricted inputs had approximation factors $\exp(Ω(n))$. Our proof uses convex optimization to tighten an upper bound on the permanent. The bound is based on weighted sums over all matchings in a bipartite graph representing the matrix, and correlations between unmatched vertices control its error. We approximate these sums deterministically using correlation decay and a bound on the effect of vertex deletion.

Wed 9 SeptData Structures and AlgorithmsComputational Complexity
The gist
Calculating the permanent of a matrix is important in math and computer science but is very hard to do exactly. This paper presents a new algorithm that can approximate the permanent for any nonnegative matrix much more closely than before using a fast, predictable method. The key idea is to use clever math tools to better estimate important sums related to the matrix, improving previous methods that had much larger errors. This makes it possible to get a good approximation in a reasonable amount of time for bigger problems than before.
Open → 2609.10516v1

Sparse polynomial gcd algorithms achieve linear complexity in key parameters

Sparse Polynomial GCD Algorithms Asymptotically Linear in All Fundamental Parameters

Abstract: Let $A, B \in \mathbb{Z}[x_1, \dots, x_n]$ be multivariate polynomials with integer coefficients and let $G = \gcd(A, B)$. We present an algorithm for computing $G$ whose expected bit complexity is asymptotically linear in all fundamental parameters: the number of variables $n$, the term count $T = \max\{\|A\|_0, \|B\|_0, \|G\|_0\}$, the total degree $D$, and the logarithmic coefficient sizes $\log\Hi$ and $\log\Ho$, where $\Hi$ bounds the coefficients of the inputs and $\Ho$ bounds those of the GCD. The bit complexity is characterized by the clean bound \[ \widetilde{O}\bigl( n \cdot T \cdot D \cdot \log\Hi \cdot \log\Ho \bigr). \] To our knowledge, this is the first sparse GCD algorithm over the integers that achieves linear complexity in all these parameters simultaneously. The integer algorithm is built upon a new field GCD algorithm. For $A, B \in \K[x_1, \dots, x_n]$ over a field $\K$ with $\operatorname{char}(\K) = 0$ or $\operatorname{char}(\K) > °G$, we give the first algorithm that computes $G = \gcd(A,B)$ with expected \[ \widetilde{O}\bigl( n \cdot T \cdot D \bigr) \] field operations, which is both input- and output-sensitive. The key technical contribution behind both algorithms is a derivative-aided separated Hensel lifting technique introduced in this paper. By introducing an auxiliary variable and leveraging derivative information, our scheme extracts all partial exponents via a single $z^2$-lift per variable, achieving constant sequential depth $O(1)$. This stands in sharp contrast to classical Hensel lifting, which requires $O(D)$ sequential lifting steps and suffers from representation densification in the sparse setting. The field algorithm is then extended to the integer case through modular reduction and rational reconstruction.

Tue 8 SeptData Structures and Algorithms
The gist
Calculating the greatest common divisor (GCD) of two complicated polynomials with many variables and large coefficients is usually slow and hard. This paper introduces new algorithms that speed up this process, making it roughly proportional to the size and complexity of the polynomials. The authors use a clever method that leverages derivatives and a special lifting technique, reducing what used to take many steps to just a few. This breakthrough works both for polynomials with coefficients in fields and those with integer coefficients.
Open → 2609.08074v1

Polynomial time tests for surjective maps between certain finite groups

Algorithms for Finite Group Epimorphism Testing

Abstract: The Group Epimorphism Problem (GpEpi) asks, given two finite groups $G_1$ and $G_2$, whether there exists a surjective group homomorphism, or epimorphism, from $G_1$ to $G_2$. When the input groups are given by their multiplication (Cayley) tables, the problem admits a quasipolynomial-time algorithm in general, but little is known about its complexity for structured classes of finite groups. In this paper, we study the computational complexity of GpEpi for several well-studied classes of finite groups. Our main results are polynomial-time epimorphism tests for several classes of groups for which polynomial-time isomorphism testing was previously known: Groups with Abelian normal Hall subgroups with cyclic complement; Groups with (product of) elementary Abelian normal Hall subgroup with elementary Abelian complement; and Groups with some constraints on their Abelian chief factors.

Mon 7 SeptData Structures and AlgorithmsComputational Complexity
The gist
The problem studied is how to decide if you can map one finite group onto another in a way that covers every element of the second group (called a surjective homomorphism). The authors look at groups with special internal structure and develop algorithms that decide this question quickly, in time that grows reasonably with the size of the groups. These results build on previous work that could quickly test if two such groups were basically the same (isomorphic). Their methods work for several important types of groups that mathematicians often study.
Open → 2609.07429v1