We prove a conjecture of Yu, Lai, and Oh: their strengthened quantum Hamming bounds, a family that interpolates between Hamming-type bounds and the Singleton bound, hold for all quantum codes of dimension
K>1, including impure and nonadditive codes. The result covers every integer local dimension
p≥2, not necessarily a prime power, every integer
t≥1, both distances
2t+1 and
2t+2, and every interpolation parameter
e∈{0,…,t}. The case
e=0 implies the ordinary quantum Hamming bound for general codes, recently proved by Zhang and Chen. Yu, Lai, and Oh proved their bounds for pure codes and for general codes of distance three or four. More generally, for every integer
p≥2 and every quantum code of length
n, dimension
K>1 and distance
d≥3, we prove
Kf(0)≤pnEf(X), where
X∼Bin(n,1−p−2), for every real polynomial
f of degree less than
d that is nonnegative on
{0,…,n} and positive at zero. For pure codes this inequality is implicit in the argument of Yu, Lai, and Oh. The proof uses the linear-programming method with quantum weight enumerators.
The quantum Hamming bound was originally put forward as an upper bound on the parameters of nondegenerate quantum codes, but over the past few decades much work has been done to show that many degenerate quantum codes must also obey this bound. In this paper, we show that there is a Hamming-like bound stricter than the quantum Hamming bound that applies to degenerate
t-error-correcting stabilizer codes of length greater than some positive integer
N(t). We show that this bound holds for all single-error-correcting degenerate stabilizer codes, forcing all but a handful of optimal distance-3 stabilizer codes to be nondegenerate.
The quantum Hamming bound arises from a direct dimension estimate for exact quantum error-correcting codes. For nondegenerate codes, distinct correctable errors map the code space into orthogonal subspaces, so dimension counting directly gives the bound; degeneracy allows these subspaces to overlap and invalidates the argument. Although linear-programming, asymptotic, and structural approaches have advanced the problem from several directions, the general local-dimension case has remained open. Here we prove the quantum Hamming bound for every local dimension
q≥3. Building on the exact two-center Fourier reduction, we develop new overlap estimates for nonbinary Hamming spaces. For
q≥4, Jacobi estimates and monotonicity give a uniform gap; qutrits form the boundary case where the gap vanishes and are handled by a filtered correction. This completes the finite-length nonbinary case; together with the existing qubit result, it establishes the quantum Hamming bound for arbitrary local dimension.
We report two analytical bounds for quantum error-correcting codes that do not have preexisting classical counterparts. Firstly the quantum Hamming and Singleton bounds are combined into a single tighter bound, and then the combined bound is further strengthened via the well-known Lloyd's theorem in classical coding theory, which claims that perfect codes, codes attaining the Hamming bound, do not exist if the Lloyd's polynomial has some non-integer zeros. Our bound characterizes quantitatively the improvement over the Hamming bound via the non-integerness of the zeros of the Lloyd's polynomial. In the case of 1-error correcting codes our bound holds true for impure codes as well, which we conjecture to be always true, and for stabilizer codes there is a 1-logical-qudit improvement for an infinite family of lengths.
Low check weight is a crucial code property for fault-tolerant quantum computing, which underlies the strong interest in quantum low-density parity-check (qLDPC) codes. Here, we initiate the theory of weight-constrained stabilizer codes from various foundational perspectives including the complexity of computing code weight and the explicit boundary of feasible low-weight codes in both theoretical and practical settings. We first prove that computing the optimal generator weight of a stabilizer code is
NP-hard, motivating efficiently computable bounds. We derive analytical lower bounds on check weight in terms of code rate and distance, identifying the minimum weights needed for single-qubit error detection and correction, as well as the sharp distance and rate limits of weight-three error-detecting codes. Matching constructions show that these bounds are tight in several regimes. To establish refined finite-size constraints, we develop a linear programming framework based on quantum weight enumerators subject to generator-weight constraints, yielding exact optimal weights for all parameter combinations with
n≤9. Finally, we show that the same framework can incorporate architecture-dependent constraints, using the 127-qubit IBM Eagle chip as a concrete example. Our study brings the weight as a crucial parameter into coding theory and provides guidance for code design and utility in practical scenarios.