Hankel Submatrices with Bounded Word Length: Dimension Tradeoffs in Probabilistic and Quantum Automata

arXiv:2610.21797 · quant-ph, cs.IT, math.IT · Submitted 2026-10-15 · Read on arXiv

Listen

Transcript

Introduction to the show: ident: Quantum Radio. Generated commentary on the latest quantum physics and condensed matter papers.

Kai: Today's paper: "Controlled-Memory Identification with Shared Generators".

Mira: The gist: Four shared generators attain the static code-size orders within optimal quadratic and linear word length,

Kai: First, who's behind it and why it matters.

Paper summary: Mira: So to wrap up this paper on "Controlled-Memory Identification with Shared Generators: Dimension--Horizon Tradeoffs and Quantum--Classical Separation," the core idea is that four shared generators are enough to reach the static code-size orders for identification in optimal quadratic and linear word lengths (<ref:2610.21797#pg1>).

Kai: And what this means for us is that we can establish a clear quadratic quantum--classical separation when looking at the fully dimension-limited regime, meaning quantum systems scale better with dimension than classical maps do in terms of logarithmic code size (<ref:2610.21797#pg1>).

Lev: From an engineering standpoint, it’s telling us that if you build a system where four generators are shared across the whole process, you can hit these theoretical limits using word lengths that scale polynomially with d, specifically d squared or d (<ref:2610.21797#pg1>).

Mira: And the authors show how to achieve these bounds using explicit constructions, like rank-theta lambda two(d) projections in the quantum model and inverse scan words in the classical agreement-scan construction (<ref:2610.21797#pg6>, <ref:2610.21797#pg7>).

Kai: They also nail the zero false acceptance boundary where it yields a logarithmic dimension bound of theta min ln d, T for all four dynamical classes (<ref:2610.21797#pg3>).

Lev: The paper states its limitations are that they're focused on fixed-horizon identification and the stability discussion is still open, but the construction provides explicit generators that are stable under polynomial perturbations at a noise scale of order d minus two (<ref:2610.21797#pg8>).

Mira: So in simple terms, it proves that four letters are sufficient to hit these static code-size orders in optimal word lengths for both quantum and classical systems, opening up the metric-packing regime when there's any false acceptance allowed (<ref:2610.21797#pg3>).

Conclusion: Kai: So we're at the end of this paper about "Controlled-Memory Identification with Shared Generators: Dimension--Horizon Tradeoffs and Quantum--Classical Separation." Basically, they figured out how many shared generators you need for identification in a system like this.

Mira: The big takeaway is that four generators are enough to reach the static code-size limits for both quantum and classical systems when word lengths are at their best.

Lev: When we look at what this means for real hardware, it suggests we can build these identification mechanisms using word lengths that grow quadratically with the dimension of the system, like d squared.

Kai: That quadratic scaling is what really caught my attention. I'm thinking about how we actually build these kinds of quantum circuits and measure them on our superconducting chips.

Mira: From a theorist standpoint, it means the assumptions they made about those shared generators are holding up under rigorous testing for both CPTP maps and stochastic ones.

Lev: If you're trying to run this on actual quantum error-correcting hardware, we're looking at overhead that lands somewhere around d minus two for stability when we talk about noise scaling.

Kai: And they’ve shown explicit ways to get those bounds using things like rank-theta lambda two(d) projections in the quantum model, which gives us a concrete blueprint.

Mira: It really shows that for any fixed positive false acceptance tolerance, you open up this metric-packing regime described in their theorem.

Lev: But there's a sharp boundary at zero false acceptance where things change completely, moving into a logarithmic dimension limit instead of the quadratic one.

Kai: That zero false acceptance part is interesting because it forces an exclusive witness constraint on every message.

Mira: So, the paper points to four letters being sufficient for this separation, but whether two or three generators are enough for smaller alphabet sizes is still an open question.

Lev: That's right, and that leads us into what we need to know about those alphabet reductions in the next part of our discussion.

Beijing Key Laboratory of Fault-Tolerant Quantum Computing · Beijing Academy of Quantum Information Sciences · Beijing National Laboratory for Condensed Matter Physics · Institute of Physics, Chinese Academy of Sciences · University of Chinese Academy of Sciences

quant-ph, cs.IT, math.IT

Submitted: 2026-10-15

Updated: 2026-10-19

License: http://arxiv.org/licenses/nonexclusive-distrib/1.0/

Importance score: 83/100

The gist: The gist: Four shared generators attain the static code-size orders within optimal quadratic and linear word length, establishing a quadratic quantum–classical separation in logarithmic code size

Key concepts

Finite-Horizon Identification: This framework tries to determine the minimum length of a message prefix and query suffix needed to uniquely identify a memory's state within a limited time horizon. It involves encoding messages with prefix words and verifying them with candidate-dependent queries followed by a shared terminal test.
Shared Generators: This refers to using only four common, time-homogeneous operations (like unitary conjugations or permutations) to manipulate the memory state. The goal is to see if these limited tools can still achieve high identification limits, even when dealing with complex quantum or classical systems.
Metric-Packing Regime: This regime occurs when a fixed positive error tolerance ($\lambda_2 > 0$) is used during identification. It describes how the identification size scales based on the interplay between the dimension ($d$), word length ($T$), and the error tolerances, showing a specific scaling law for these conditions.
Quadratic Quantum--Classical Separation: This is a key finding where quantum systems (using unitary generators) require identification sizes scaling quadratically with dimension ($\Theta(d^2)$), while classical systems (using permutation generators) scale linearly ($\Theta(d)$). This demonstrates a clear difference in the efficiency of identification between quantum and classical models.

Terminology

Generator — 1× in this paper · explained in 2 episodes

Summary

The gist: Four shared generators attain the static code-size orders within optimal quadratic and linear word length, establishing a quadratic quantum–classical separation in logarithmic code size

Model Formalization

The paper introduces a finite-horizon identification framework where messages are encoded as bounded prefix words from a common root and tests as bounded query suffixes followed by a shared terminal measurement The central resource question is what lengths these prefix and query words must have for a constant-size discrete control interface to attain the static identification limits For each resource tuple (d, T, λ1, λ2), the root ρ, terminal effect E, and four generators—for instance, unitary conjugations induced by elements of U(d) in the unitary model—are optimized jointly with the code and shared across all message–candidate pairs The formulation also admits a natural automata-theoretic representation where each experimental run realizes a single candidate test, yielding the response table pij:= Pr[accept candidate i message j] = Tr[EΦvi(Φuj(ρ))]

Main Results and Scaling Laws

The main results establish the fixed-error finite-horizon laws for identification sizes across different dynamical classes

**((4) ln NU,4(d, T; λ1, λ2) = Θλ1,λ2(min[d squared, T]) for arbitrary CPTP generators and ln NS,4(d, T; λ1, λ2) = Θλ1,λ2(min[d squared, T]) for stochastic maps The unitary and permutation constructions show that four shared reversible generators attain the static code-size orders within O(d 2) and O(d) word length, respectively **

**((5) ln NP,4(d, T; λ1, λ2) = Θλ1,λ2(min[d, T]) for every fixed λ2 > 0 and λ1 + λ2 < 1 The general CPTP and stochastic converses establish matching upper bounds for every fixed alphabet budget Because the lower bounds hold for four letters, they immediately extend to every budget q ≥ 4 by padding the alphabet with unused letters **

Phase Diagram and Regimes

Figure 1 summarizes the resulting horizon regimes and the sharp change at zero false acceptance For fixed positive false-acceptance tolerance, the resource laws divide the horizon into three regimes: ln NQ,4 ln NS,4 T ≲ d T T d ≲ T ≲ d squared T d squared d For every fixed λ2 > 0 with λ1 +λ2 < 1 opens the metric-packing regime described by Theorem II.2 The face λ2 = 0, 0 ≤ λ1 < 1, forms a distinct identification phase where every message then has an exclusive support witness, which yields N ≤ d in both quantum and classical settings

Achievability Constructions

The paper constructs explicit generator realizations to achieve the lower bounds

**((6) In the quantum model, a rank-Θλ2(d) projection supplies both the normalized root state and the terminal effect. Four explicit orthogonal, hence unitary, letters—including a dimension-dependent Householder reflection that drives a signed-reflection recursion—generate a radius-Oλ2(d 2) word ball Each query suffix is the exact chronological inverse of its encoding prefix, ensuring unit diagonal acceptance and converting Grassmann overlap directly into off-diagonal error **

**((7) In the classical model, four permutations scan a block carrier to write the symbols of a constant-rate agreement code; inverse scan words then turn normalized support intersection into the complete acceptance table, yielding exp(omegaλ2(d)) messages within Oλ2(d) steps **

Zero-False-Acceptance Boundary

The endpoint behavior is governed specifically by false acceptance At the zero-false-acceptance boundary λ2 = 0 with 0 ≤ λ1 < 1, every message must retain a nonzero accepting component that is absent from all other messages. The resulting unambiguous-discrimination dimension bound, combined with word counting, is matched by a binary prefix-tree construction, yielding ln NX,4(d, T; λ1, 0) = Θ(min[ln d, T]) This boundary defines the logarithmic-dimension boundary

Stability and Extensions

The four quantum generators are explicit and remain stable under inverse-closed finite-precision perturbations at polynomially small operator-norm scale The unitary construction also has a finite-precision stability margin, suggesting a per-step noise scale of order d−2 as a sufficient polynomial benchmark Open problems include noisy-channel implementations, derandomized endpoint families, fixed-generator orbit identification, and the minimum alphabet size The framework suggests three groups of extensions: circuit realization problem, explicit and efficiently indexable endpoint families, and fixing a supplied generator tuple

Conclusion

Four shared generators suffice for the full quantum–classical identification separation established here; whether two or three generators suffice remains an open alphabet-reduction problem The four-letter prefix-tree construction simultaneously matches this dimension bound and the word-count bound, yielding ln N = Θ(min[ln d, T]) for all four dynamical classes Every fixed λ2 > 0 with λ1 +λ2 < 1 opens the metric-packing regime described by Theorem II.

Improvements for AI systems

The AI system can perform identification in quantum or classical settings with finite resources by utilizing a shared control interface of only four generators, achieving optimal static code-size orders based on dimension and horizon: ln NQ,4 = Θλ1,λ2 (min(d squared, T)) and ln NS,4 = Θλ1,λ2 (min(d, T)).
The system can implement a quantum identification protocol using a bounded-word Grassmannian packing generated by four inverse-closed orthogonal letters to realize the optimal lower bound: four shared generators produce the packing.
The system can execute a classical identification protocol by employing four permutations in an agreement-scan construction, allowing it to generate codes with exact diagonal response and meet the linear horizon scaling: four permutations implementing an agreement-scan construction achieve the classical lower bound.
The system can operate under zero false acceptance constraints where every message requires an exclusive witness, resulting in a dimension-limited bound of ln NX,4(d, T; λ1, 0) = Θ(min(ln d, T)) for all four dynamical classes.
The system exhibits finite-precision stability under inverse-closed unitary perturbations at a polynomially small operator-norm scale: an operator-norm tolerance of order d−2 suffices for fixed error parameters.