A quantum finite state automaton (QFA) is a generalization of a classical finite automaton (Say and Yakaryılmaz, 2014; Ambainis and Yakaryılmaz, 2021). Here we use the simplest QFA model (Moore and Crutchfield, 2000). Formally, a QFA is 5-tuple M=(Q,A∪{¢,$},|ψ0〉,U,ℋacc), where Q = {q₁, …, q_D} is a finite set of states, A is the finite input alphabet, ¢, $ are the left and right end-markers, respectively. The state of M is represented as a vector |ψ〉∈ℋ, where H is the D-dimensional Hilbert space spanned by {|q₁〉, …, |q_D〉} (here |q_j〉 is a zero column vector except its j-th entry that is 1). The automaton M starts in the initial |ψ0〉∈ℋ, and makes transitions according to the operators U={Ua∣a∈A} of unitary matrices. After reading the whole input word, the final state is observed with respect to the accepting subspace Hacc⊆H.

Quantum fingerprinting provides a method of constructing automata for certain problems. It maps an input word w∈{0, 1}ⁿ to much shorter quantum state, its fingerprint |ψ〉(w)=Uw|0m〉, where U_w is the single transition matrix representing the multiplication of all transition matrices while reading w and |0m〉=|0〉⊗⋯⊗ |0〉︸m times. The number of qubits in a fingerprint m can be exponentially less than the length of the word n. An example of such an automaton was first presented in the study by Ambainis and Freivalds (1998) and then improved as provided in the study by Ambainis and Nahimovs (2009). This result is discussed in this section. Quantum fingerprint captures essential properties of the input word that can be useful for computation.

One example of quantum fingerprinting applications is the QFA algorithms for the MOD_p language (Ambainis and Nahimovs, 2009). For a given prime number p, the language MOD_p is defined as MODp={ai∣iis divisible byp}. Let us briefly describe the construction of the QFA algorithms for MOD_p.

We start with a 2-state QFA M_k, where k∈{1, …, p−1}. The automaton M_k has two base states Q = {q₀, q₁}, it starts in the state |ψ₀〉 = |q₀〉, and it has the accepting subspace spanned by |q₀〉. At each step (for each letter), we perform the rotation

If w∈MOD_p, then the rotation U_a is applied i = r·p times, for some integer r. In that case, i is a multiple of p. Therefore, the total rotation angle is 2πkp·r·p=2πk·r, which is a multiple of 2π for any k. It means, the automaton is in the state |q₀〉 for any k, and it accepts the word with probability 1. It is the correct answer.

However, if w∉MOD_p, the probability of correct answer can be close to 0 rather than 1 (i.e., bounded below by 1 − cos²(π/p)). To boost the success probability we use d copies of this automaton, namely, M_k1, …, M_kd, as described below.

The QFA M for MOD_p has 2d states: Q = {q_{1, 0}, q_{1, 1}, …, q_{d, 0}, d_{d, 1}}, and it starts in the state |ψ0〉=1d∑i=1d|qi,0〉. In each step, it applies the transformation defined as follows:

Indeed, M enters into equal superposition of d sub-QFAs, and each sub-QFA applies its rotation. Thus, quantum fingerprinting technique associates the input word w = a^j with its fingerprint

Ambainis and Nahimovs (2009) proved that this QFA accepts the language MOD_p with error probability that depends on the choice of the coefficients k_i's. They also showed that for d = 2log(2p)/ε there is at least one choice of coefficients k_i's such that the error probability is less than ε. The proof uses a probabilistic method, so these coefficients are not explicit. They also suggest two explicit sequences of coefficients: cyclic sequence ki=gi(modp) for primitive root g modulo p and more complex AIKPS (Ajtai, Iwaniec, Komlós, Pintz, Szemerédi) sequences based on the results presented in the study by Ajtai et al. (1990).

Quantum fingerprinting is versatile and has several applications. Buhrman et al. (2001) in their study provided an explicit definition of quantum fingerprinting for constructing an efficient quantum communication protocol for equality checking. The technique was applied to branching programs in the studies by Ablayev and Vasiliev (2009, 2011, 2013b); this computational model can be considered as a non-uniform automata. They show examples of Boolean functions that can be computed by a quantum branching program with exponentially smaller complexity (width or states in terms of automata) than the deterministic ones. Based on this research, they developed the concept of cryptographic quantum hashing (Ablayev and Vasiliev, 2013a, 2014; Ablayev et al., 2014; Ablayev and Ablayev, 2015). Later, they generalized the technique and suggested a family of quantum hashes that allow us to see a trade-off between one-way resistance and collision resistance of the hash function (Ablayev et al., 2016a; Vasiliev, 2016a; Vasiliev et al., 2017; Ablayev et al., 2020). The question of computing cryptographic quantum hashes with a restricted size of memory was discussed in the study by Ablayev et al. (2018b). Connection of the approach with Quantum Fourier transom where presented in the study by Ablayev and Vasiliev (2020); Khadieva (2024). A survey on cryptographic quantum hashes can be found in the study by Ablayev et al. (2016b, 2018a). The experimental implementation on real devices was considered in the study by Vasiliev et al. (2019); Turaykhanov et al. (2021), and optimization for emulators of quantum computers was explored in the study by Zinnatullin et al. (2023). Different versions of hash functions were applied that are hash functions in the case of finite Abelian groups (Vasiliev, 2016c) and arbitrary groups (Ziatdinov, 2016b); functions based on graphs (Ziatdinov, 2016a; Zinnatullin, 2023). The technique was extended to qudits (Ablayev and Vasiliev, 2022; Vasiliev, 2023). This approach has been widely used in various areas such as

At the same time, the technique is not practical for the currently available real quantum computers. The main obstacle is that quantum fingerprinting uses an exponential (in the number m of qubits) circuit depth (e.g., see Khadieva and Ziatdinov, 2023; Birkan et al., 2021; Salehi and Yakaryılmaz, 2021; Zinnatullin et al., 2023 for some implementations of the aforementioned automaton M). Therefore, the required quantum volume¹ V_Q is roughly 2^|w|·^2m. For example, IBM reports (IBM, 2022) that its Falcon r5 quantum computer has 27 qubits with a quantum volume of 128. It means that we can use only 7 of the 27 qubits for the fingerprint technique.

This study investigates how to obtain better circuit depth by optimizing the coefficients used by M: k₁, …, k_d. We use generalized arithmetic progressions to generate a set of coefficients and show that such sets have a circuit depth comparable to the set obtained by the probabilistic method.

Additionally, we implement the circuit for the noisy emulator of the IBMQ quantum machine (IBM, 2025). The emulator emulates the behavior of real IBMQ quantum machines and allows us to see the results closely compared to the results we can obtain on real machines. Note that IBMQ is a device that allows to invoke of a quantum circuit with universal basic gates. Therefore, we can implement any unitary transformation on this machine that gives us universality (Möttönen et al., 2004). At the same time, the current quantum devices are in the Noisy Intermediate-Scale Quantum (NISQ) era (Preskill, 2018), which is why the noise and other effects do not allow for the implementation of any quantum algorithm. Our shallow circuit will enable us to obtain useful results for the quantum fingerprinting algorithm for MOD₁₇ language on 4 qubits. At the same time, it is known that we cannot recognize this language using classical automata with 4 qubits of memory (Ambainis and Freivalds, 1998). Moreover, the standard circuit for the quantum fingerprinting algorithm (not the shallow one) does not give us any useful results, even if it gives a smaller error probability in “ideal” (not noisy) devices.

We summarize the previous and our results in the following list.

Note that p is exponential in the number of qubits m. The depth of the circuits is discussed in Section 3.

The study is an extended version of the Ziiatdinov et al. (2023) conference paper presented at the AFL2023 conference.

In addition, we perform computational experiments for computing parameters K that minimize the error probability for our circuit and the standard circuit. We show that in the case of an “ideal” non-noisy quantum device, the error probability for the proposed circuit is at most twice as large as that of the standard circuit. At the same time, in the case of noisy quantum devices (current and near-future ones), the error probability is much less than that of the standard circuit, and allows us to implement QFA for MOD₁₇ language using 4 qubits.

The rest of the article is organized as follows. In Section 2, we give the necessary definitions and results on quantum computation and additive combinatorics to follow the rest of the article. Section 3 contains the construction of the shallow fingerprinting function and the proof of its correctness. Then, we present several numerical simulations in Section 4. We conclude the article with Section 5 by presenting some open questions and discussions for further research.

Let us denote by H2 two-dimensional Hilbert space, and by (H2)⊗m 2^m-dimensional Hilbert space (i.e., the space of m qubits). We use bra- and ket-notations for vectors in Hilbert space. For any natural number N, we use ℤ_N to denote the cyclic group of order N.

Let us describe in detail how the automaton M works. As we outlined in the introduction, the automaton M has 2d states: Q = {q_{1, 0}, q_{1, 1}, …, q_{d, 0}, d_{d, 1}}, and it starts in the state |ψ0〉=1d∑i=1d|qi,0〉. After reading a symbol a, it applies the transformation U_a defined by Equations 1, 2:

After reading the right endmarker $, it applies the transformation U_$ defined in such way that U_$|ψ₀〉 = |q_{1, 0}〉. The automaton measures the final state and accepts the word if the result is q_{1, 0}.

So, the quantum state after reading the input word w = a^j is

If j≡0 (mod p), then |ψ〉 = |ψ₀〉, and U_$ transforms it into accepting state |q_{1, 0}〉, therefore, in this case, the automaton always accepts. If the input word w∉MOD_p, then the quantum state after reading the right endmarker $ is

and the error probability is

In simpler terms, the automaton maintains d angles in different subspaces. After encountering the symbol a, the automaton performs d rotations: it rotates by 2πk_i/p in the i-th subspace. Since rotating p times would have the same result as not rotating at all, the automaton counts the number of a symbols modulo p. The coefficients k_i ensure that the small error probability: even if some of angles are close to 0, other subspaces are far from 0, so the whole state is far from the state q_{1, 0}.

In the rest of the article, we denote by m the number of qubits in the quantum fingerprint, by d = 2^m the number of parameters in the set K, by p the size of domain of the quantum fingerprinting function, and by U_a(K) the transformation defined above, which depends on the set K.

Let us also define a function ε:ℤpd→ℝ as follows:

Note that P_e ≤ ε(K).

We also use some tools from additive combinatorics. We refer the reader to the textbook by Tao and Vu (2006) for a deeper introduction to additive combinatorics.

An additive set A⊆Z is a finite non-empty subset of Z, an abelian group with group operation +. We refer to Z as the ambient group.

If A, B are additive sets in Z, we define the sum set A+B = {a+b∣a∈A, b∈B}. We define additive energy E(A, B) between A, B to be

Let us denote by e(θ) = e^2πiθ, and by ξ·x = ξx/p bilinear form from ℤ_p×ℤ_p into ℝ/ℤ. Fourier transform of f:ℤ_p → ℤ_p is f^(ξ)=Ex∈Zf(x)e(ξ·x)¯.

We also denote the characteristic function of the set A as 1_A, and we define PZ(A)=1A^(0)=|A|/|Z|.

Definition 1 (Tao and Vu, 2006). Let Z be a finite additive group. If A⊆Z, we define Fourier bias ||A||U of the set A to be

Basically, the additive energy E(A, A) and the Fourier bias ||A||U tell how “structured” the set A is with respect to addition. The additive energy E(A, A) measures how many pairwise sums a+a′ of elements a, a′∈A coincide; for a random set we expect many different pairwise sums, and for an arithmetic progression the pairwise sums mostly coincide.

There is a connection between the Fourier bias and the additive energy.

Theorem 1 (Tao and Vu, 2006). Let A be an additive set in a finite additive group Z. Then

Definition 2 (Tao and Vu, 2006). A generalized arithmetic progression (GAP) of dimension d is a set

where x₀, x₁, …, x_d, N₁, …, N_d∈Z. The size of GAP is a product N₁⋯N_d. If the size of set A, |A|, equals to N₁⋯N_d, we say that GAP is proper.

The GAPs generalize the usual notion of arithmetic progressions by allowing multiple differences x₁, …, x_d instead of just one x₁. The proper GAP has differences such that its elements are all distinct, i.e., its elements cannot be represented as a sum of differences in two ways.

Quantum fingerprint can be computed using the quantum circuit shown in Figure 1. The last qubit is rotated by a different angle 2πk_jx/q in different subspaces enumerated by |j〉. The circuit rotates the qubit for all possible angles. The j-th rotation is controlled by first m qubits and applied if the values of these qubits are j. Therefore, the circuit depth is |K| = t = 2^m. As the set K is random, the depth is unlikely to be less than |K|.

Let us note that fingerprinting is similar to the quantum Fourier transform. Quantum Fourier transform computes the following transformation:

where ω_N = e(1/N). Here is the quantum fingerprinting transform:

The depth of the circuit that computes quantum Fourier transform is O((logN)²), and it heavily relies on the fact that in Equation 3 the sum runs over all k = 0, …, N−1. Therefore, to construct a shallow fingerprinting circuit, we desire to find a set K with a special structure.

Suppose that we construct a coefficient set K⊂ℤ_p in the following way. We start with a set T = {t₁, …, t_m} and construct the set of coefficients as a set of sums of all possible subsets:

where we sum modulo p.

The quantum fingerprinting function with these coefficients can be computed by a circuit of depth O(m) (Kālis, 2018) (see Figure 2).

Finally, let us prove why the construction of the set K⊂ℤ_p works.

Theorem 2. Let ε>0, let m = ⌈logp−2logε⌉ and d = 2^m.

Suppose that the number t₀∈ℤ_p and the set T = {t₁, …, t_m}⊂ℤ_p are such that

is a proper GAP.

Then the set A defined as

has ε(A) ≤ ε.

Let us outline the proof of this theorem. First, we estimate the number of solutions to a+b = n. Second, we use it to bound the additive energy E(A, A) of the set A. Third, we bound the Fourier bias ||A||U. Finally, we get a bound on ε(A) in terms of p and m.

Proof. Let us denote a set R_n(A) of solutions to a+b = n, where a, b∈A and n∈ℤ_p:

Note that we have E(A,A)=∑n∈ZRn(A)2.

Suppose that n is represented as n=2t0+∑i=1mγiti, γ_i∈{0, 1, 2}. It is unique if such a representation exists because B is a proper GAP. Let us denote c₀: = {i∣γ_i = 0}, c₁: = {i∣γ_i = 1}, c₂: = {i∣γ_i = 2}. It is clear that c₀⊎c₁⊎c₂ = [m].

Suppose that n = a+b for some a, b∈A. But a=t0+∑iαiti and b=t0+∑iβiti, α_i, β_i∈{0, 1}. We get that if i∈c₀ or i∈c₂ then the corresponding coefficients α_i and β_i are uniquely determined. Consider i∈c₁. Then we have two choices: either α_i = 1;β_i = 0, or α_i = 0;β_i = 1. Therefore, we have Rn(A)=2|c1(n,A)|.

We have that

Using the fact that |c₀(n, A)|+|c₁(n, A)|+|c₂(n, A)| = m, we see that

We can bound the Fourier bias by Theorem 1:

Finally, we have

We prove the theorem by substituting the definitions of d and m.                     ⎕

Corollary 1. The depth of the circuit that computes U_a(A) is ⌈logp−2logϵ⌉.

Theorem 3 (Circuit depth for AIKPS sequences). For given ε>0, let

where r⁻¹ is the inverse of r modulo p.

Then the depth of the circuit that computes U_a(T) is less than (1+2ϵ)log^1+ϵploglogp.

Proof. Let us denote the elements of R by r₁, r₂, …. Let S·{r⁻¹} be a set {s·r⁻¹∣s∈S}.

Consider the following circuit Cj (see Figure 3) with w = ⌈(1+2ε)loglogp⌉+1 wires.

The circuit Cj has depth ⌈(1+2ε)loglogp⌉+1 and computes the transformation Ua(S·{rj-1}). By repeating the same circuit for all r_j∈R we get the required circuit for U_a(T) (see Figure 4).

Since |R| < (logp)^1+ε, we obtain that the depth of the circuit U_a(T) is less than

                             ⎕

We conduct the following numerical experiments. We compute sets of coefficients K for the automaton for the language MOD_p with minimal computational error.

Finding an optimal set of coefficients is an optimization problem with many parameters, and the running time of a brute force algorithm is large, especially with an increasing number m of control qubits and large values of parameter p. Then, the original automaton has 2d states, where d = 2^m. We observe circuits for several m values and use a heuristic method for finding the optimal sets K with respect to an error minimization. For this purpose, the coordinate descent method (Wright, 2015) is used.

We find an optimal set of coefficients for different values of p and m and compare computational errors of original and shallow fingerprinting algorithms for the automaton (see Figure 5). Namely, we set m = 3, 4, 5 and find sets using the coordinate descent method for each case that minimizes ε(K). Even heuristic computing, for s>5, takes exponentially more computational time andis hard to implement on our devices.

One can note that the difference between errors increases with increasing m, especially for higher values of p. The program code and numerical data are presented in a git repository (Khadieva, 2023).

The graphics in Figure 6 show a proportion of the errors of the original automaton over the errors of the shallow automaton for m = 3, 4, 5 and the prime numbers until 1013.

As we see, for a number of control qubits m = 3, the difference between the original and shallow automata errors is approximately constant. The ratio of values fluctuates between 1 and 1.2. In the case m = 4, this ratio is approximately 1.5 for almost all observed values p. The ratio of errors is nearly between 1.5 and 3, for m = 5.

According to the results of our experiments, the circuit depth m+1 is enough for valid computations, while the original circuit uses O(2^m) gates. Since the shallow circuit is much simpler than the original one, its implementation on real quantum machines is much easier. For instance, in such machines as IBMQ Manila or Baidu quantum computer, a “quantum computer” is represented by a linearly connected sequence of qubits. CX-gates can be applied only to the neighbor qubits. For such a linear structure of qubits, the shallow circuit can be implemented using 3m+3 CX-gates. Whereas a nearest-neighbor decomposition (Bergholm et al., 2005) of the original circuit requires O(dlogd) = O(m2^m) CX-gates.

We show that generalized arithmetic progressions generate some sets of coefficients k_i for the quantum fingerprinting technique with provable properties. These sets have large sizes, but their depth is small and comparable to that of the sets obtained by the probabilistic method. These sets can be used to implement quantum finite automata on current quantum hardware.

We perform numerical simulations. In the case of “ideal” (noise-free) devices, the experiments show that the error probability for the shallow circuit is close to the error probability for the standard circuit. At the same time, we show that the shallow circuit is much more efficient than the standard circuit when implemented on IBMQ noisy device simulators.

The depth optimization of quantum finite automata is also an open question. The lower bound on the size of K with respect to p and ε is already known (Ablayev et al., 2016b). Therefore, for given p and ε, quantum finite automata cannot have less than O(logp/ε) states. However, to our knowledge, a lower bound on the circuit depth of the transition function implementation is unknown. Thus, we pose an open question: Is it possible to implement a transition function with a depth less than O(logp)? What is the lower bound?

The data for the shallow circuit for fingerprinting are tabulated in Table 1.

The data for the standard circuit for fingerprinting are tabulated in Table 2.