Shallow implementation of quantum fingerprinting with application to quantum finite automata

Abstract

Quantum fingerprinting is a technique that maps a classical input word to a quantum state. The obtained quantum state is much shorter than the original word, and its processing uses fewer resources, making it useful in quantum algorithms, communication, and cryptography. One of the examples of quantum fingerprinting is the quantum automata algorithm for languages, where p is a prime number. However, implementing such an automaton on current quantum hardware is not efficient. Quantum fingerprinting maps a word x∈{0, 1}ⁿ of length n to a state |ψ(x)〉 of O(logn) qubits, and uses O(n) unitary operations. Computing quantum fingerprint using all available qubits of the current quantum computers is infeasible due to many quantum operations. To make quantum fingerprinting practical, we should optimize the circuit for depth instead of width, in contrast to the previous works. We propose explicit methods of quantum fingerprinting based on tools from additive combinatorics, such as generalized arithmetic progressions (GAPs), and prove that these methods provide circuit depth comparable to a probabilistic method. We also compare our method to prior work on explicit quantum fingerprinting methods. We provide a series of numerical experiments with implementation of the quantum automata for MOD₁₇ language on noisy simulators of IBMQ quantum devices. We show that shallow implementation based on GAPs produces results with much smaller computational error compared to standard deep circuit implementation. Despite the fact that on the ideal quantum computational device, the opposite situation arises. We show that the shallow circuit for the quantum automaton is better for near-future quantum computational devices.

1 Introduction

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 , 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 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 , and makes transitions according to the operators of unitary matrices. After reading the whole input word, the final state is observed with respect to the accepting subspace .

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 , where U_w is the single transition matrix representing the multiplication of all transition matrices while reading w and . 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 . 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 , 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 . 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 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

• stream processing algorithms (Le Gall, 2009, 2006). Here, the technique allows authors to obtain an advantage in memory size for a quantum version of the model.

• Query model algorithms (Ablayev et al., 2022, 2024). Here, the quantum fingerprinting algorithm is applied as a base for the quantum algorithm for the string-matching problem. The algorithm uses less memory compared to existing quantum algorithms (Ramesh and Vinay, 2003; Montanaro, 2017; Khadiev and Serov, 2025).

• Online algorithms (Khadiev and Khadieva, 2021, 2022). Here, authors present a problem that can be solved by quantum online algorithms with restricted memory size (Khadiev et al., 2018, 2022b, 2023), but cannot be solved by randomized or deterministic counterparts in the case of logarithmic memory size.

• branching programs (Khadiev and Khadieva, 2017; Khadiev et al., 2022a; Ablayev et al., 2016c, 2018a). In these studies, authors present a specially constructed Boolean function that allows them to show a hierarchy of complexity classes for quantum read-k-times branching programs. The upper bound was proven using the quantum fingerprinting technique. For read-1-times branching programs, researchers (Gainutdinova, 2002; Ablayev et al., 2005; Ablayev and Vasiliev, 2009, 2013b) presented a Boolean function that can be computed by a quantum model with smaller complexity than by classical models.

• Development of quantum devices (Vasiliev, 2016b).

• Automata. The technique was introduced for automata model (Ambainis and Freivalds, 1998) and later improved in a study by Ambainis and Nahimovs (2009). At the same time, the same technique for the constant number of qubits was used for two-way automata with classical and quantum states (Ambainis et al., 2002; Ambainis and Watrous, 2002; Yakaryilmaz, 2013; Yakaryılmaz and Say, 2009). It allows authors to show a language that can be recognized by the model but cannot be recognized by the probabilistic two-way automata.

  Later, the same idea was used for one-way automata and promise problems (Ambainis and Yakaryılmaz, 2021; Gainutdinova and Yakaryılmaz, 2017; Yakaryılmaz and Say, 2010; Gainutdinova and Yakaryılmaz, 2018, 2015; Hu et al., 2020; Nakanishi and Yakaryılmaz, 2015).

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.

• The cyclic method, for some constant c>0:

• - the width is p^c/loglogp

• - the depth is p^c/loglogp

• - explored in the study by Ambainis and Nahimovs (2009).

• The AIKPS method:

• - the width is log^2+3ϵp

• - the depth is (1+2ϵ)log^1+ϵploglogp

• - explored in the study by Razborov et al. (1993).

• The probabilistic method:

• - the width is 4log(2p)/ε

• - the depth is 2log(2p)/ε

• - explored in Ambainis and Nahimovs (2009).

• The GAPs method (this study):

• - the width is p/ε²

• - the depth is ⌈logp−2logε⌉+2

• - developed in this study.

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.

2 Preliminaries

Let us denote by two-dimensional Hilbert space, and by 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 . 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 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 .

We also denote the characteristic function of the set A as 1_A, and we define .

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

Basically, the additive energy E(A, A) and the Fourier bias 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.

3 Shallow fingerprinting

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

Figure 1

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).

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

Suppose that n is represented as , γ_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 and , α_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 .

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 (see Figure 3) with w = ⌈(1+2ε)loglogp⌉+1 wires.

Figure 3

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

Figure 4

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

                             ⎕

4 Numerical experiments

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.

Figure 5

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.

Figure 6

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.

4.1 Numerical experiments for a noisy device

The numerical experiments presented above were performed on an abstract machine with no noise, that is, all operators and measurements are always correct. In contrast, current real quantum devices are the NISQ era machines (Preskill, 2018), which means that each operator is noisy. Therefore, we invoke a new series of computational experiments to find a set of coefficients K for the automaton that recognizes the language MOD_p, so that we can separate members and non-members of the language when implementing the automaton on a noisy simulator of the IBMQ quantum machine. As an example, we set the p = 17 and m = 3 control qubits. So, our device uses 4 qubits. At the same time, it is known that any deterministic device needs at least 5 classical bits to recognize the MOD₁₇ language (Ambainis and Freivalds, 1998).

For these parameters, we invoke a brute-force algorithm to find the set K that satisfies two conditions:

• The probability of accepting member words should be as high as possible.

• The probability of accepting non-member words should be as small as possible.

For this reason, we minimize a value diff = P(6·p)−max{P(r):r mod p≠0, 1 ≤ r ≤ 6·p+9}, where P(i) is the acceptance probability for a word of length i. The resulting set is K = {4, 8, 12, 6}. After that, we execute the circuit for this automaton on input words of length at most 7·p+9 = 128. We use an optimization of the circuit from a study by Khadieva et al. (2024) that allows us to use the Rz operator instead of the Ry operator. It is presented in Figure 7.

Figure 7

It is important to use this optimization because the emulator of a real IBMQ device allows us to use only a limited set of possible gates. For instance, we cannot use the Ry operator, although the Rz gate is available.

We run the program 10,000 times and calculate the number of shots that return the state |0〉 (accepting state). We use the notation for this number, where i is the length of the word. These numbers for each length i for 1 ≤ i ≤ 129 are presented in Section 6 and Figure 8. We can say that it is a statistical representation of probability P(i).

Figure 8

Normally, for the bounded error QFA (Say and Yakaryılmaz, 2014), an input of length i is accepted if the probability of observing an accepting state is P(i)>0.5+ε for some ε>0 and is rejected if P(i) < 0.5−ε. In terms of the number of shots that return the accepting state in our experiment, we can say that the word is accepted if , and rejected if . In that case, we can execute an algorithm once, return its answer, and the result will be correct with probability more than one half. In that case, we can recognize only the word of length i = p because only , and for any i≠p due to the results of our numerical experiments. So, the automaton rejects all other words, including members and non-members.

Another type of QFA in terms of acceptance criteria is a QFA with an isolated cut-point (Chadha et al., 2013; Bertoni, 1975; Bertoni et al., 1977; Gimbert and Oualhadj, 2010; Rabin, 1963). In that case, we choose two constants 0 < λ < 1 and 0 < ε < min{λ, 1−λ}. A word of length i is accepted if P(i)>λ+ε, and rejected if P(i) < λ−ε. For our numerical experiments, we can set a threshold (or a cut-point) and accept a word of length i if ; and reject a word of length i if .

Analyzing the results of the experiments, we can say that each member i of MOD_p has . At the same time, each non-member i has .

So, we can choose any threshold . Here we choose the middle of the interval for more statistical safety. Finally, we can say that our algorithm accepts a word of length i if , and rejects it if .

The criteria based on isolated cut-point are not as good as in the bounded error automata, but are also useful. For practical implementation, we should invoke our algorithm at least O(1/λ) times to have a reasonable statistic that approximates P(i).

We perform similar experiments for the standard circuit for the automaton for the MOD_p language. Since m = 3, we need to calculate 2^m = 8 integer parameters as coefficients for the rotation angles. For this case, using the brute force algorithm for parameter finding is unrealistic because the standard circuit execution on the IBMQ simulator takes much more time than in the case of the shallow circuit execution. We use three approaches:

• The coordinate descent method (Wright, 2015) for finding the first six parameters and the brute force approach for calculating the last two parameters.

• Simulated annealing algorithm (Press, 1992) for finding all parameters.

• Genetic algorithm (Mitchell, 1998) for finding all parameters.

The objective function for minimization is mod p≠0, 1 ≤ r ≤ 2·p+10}. We compute , which is the number of shots that return the state |0〉 (accepting state).

We use these three algorithms, obtain the results, and choose the best result among them. The target parameters are K = {14, 9, 6, 7, 10, 4, 2, 16}.

Then we invoke the circuit for the automaton using these parameters on input words of length at most 7·p+9 = 128. The program is executed 10,000 times, and we calculate . These numbers are presented in Section 6 and Figure 9.

Figure 9

When analyzing the data, we can see that no member word i has , which means that the probability P(i) < 0.5 for any input i. Therefore, if the automaton is the QFA with bounded error, we cannot separate members from non-members using this acceptance criterion.

However, if the automaton is the QFA with an isolated cut-point, then we can see that several members of the language, for instance, i = p, i = 2p, i = 4p, and i = 7p, can be separated from non-members. Nevertheless, other members of MOD_p are not separable from non-members, for example, i = 3p, i = 5p, and i = 6p. In addition, we can note that the number . Our algorithm cannot find a set K that violates this condition. At the same time, we can ignore the case i = 1 because it can be processed separately. Even if we fix the issue with i = 1, the algorithm still detects only some members. For the members i = p, i = 2p, i = 4p, and i = 7p, the minimal value of is 828. For the non-members except i = 1, the maximum value of is 823. As a threshold , we can choose 824 or 825. Nevertheless, we cannot separate the members i = 3p, i = 5p, and i = 6p from non-members for any threshold.

Note that in the case of the shallow circuit, is much higher than in the case of the standard circuit. For instance, for the shallow circuit, which corresponds to P(p)>0.51; while for the standard circuit, the corresponding probability would be much smaller than 0.5 (approximately 0.1).

Finally, we can see that the shallow circuit is more efficient on noisy devices (emulators) than the standard circuit. However, in the case of an “ideal” noise-free device, we have an opposite situation.

5 Conclusion

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?

6 Numerical experiments for noisy devices

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.

References

• 1

  Ablayev F. Ablayev M. (2015). On the concept of cryptographic quantum hashing. Laser Phys. Lett. 12:125204. 10.1088/1612-2011/12/12/125204

  • CrossRef
  • Google Scholar

• 2

  Ablayev F. Ablayev M. Khadiev K. Salihova N. Vasiliev A. (2022). “Quantum algorithms for string processing,” in Mesh Methods for Boundary-Value Problems and Applications, Vol. 141 (Lecture Notes in Computational Science and Engineering), 1–14. 10.1007/978-3-030-87809-2_1

  • CrossRef
  • Google Scholar

• 3

  Ablayev F. Ablayev M. Khadiev K. Vasiliev A. (2018a). Classical and quantum computations with restricted memory. LNCS11011, 129–155. 10.1007/978-3-319-98355-4_9

  • CrossRef
  • Google Scholar

• 4

  Ablayev F. Ablayev M. Vasiliev A. (2016a). On the balanced quantum hashing,” in J. Physics: Conference Series (IOP Publishing), 012019. 10.1088/1742-6596/681/1/012019

  • CrossRef
  • Google Scholar

• 5

  Ablayev F. Ablayev M. Vasiliev A. (2018b). “Computing quantum hashing in the model of quantum branching programs,” in AIP Conference Proceedings (AIP Publishing LLC), 020020. 10.1063/1.5025458

  • CrossRef
  • Google Scholar

• 6

  Ablayev F. Ablayev M. Vasiliev A. (2020). “Quantum hashing and fingerprinting for quantum cryptography and computations,” in International Computer Science Symposium in Russia (Springer), 1–15. 10.1007/978-3-030-50026-9_1

  • CrossRef
  • Google Scholar

• 7

  Ablayev F. Ablayev M. Vasiliev A. Ziatdinov M. (2016b). Quantum fingerprinting and quantum hashing. Computational and cryptographical aspects. Baltic J. Modern Comput. 4, 860–875. 10.22364/bjmc.2016.4.4.17

  • CrossRef
  • Google Scholar

• 8

  Ablayev F. Gainutdinova A. Karpinski M. Moore C. Pollett C. (2005). On the computational power of probabilistic and quantum branching program. Inf. Comput. 203, 145–162. 10.1016/j.ic.2005.04.003

  • CrossRef
  • Google Scholar

• 9

  Ablayev F. Gainutdinova A. Khadiev K. Yakaryılmaz A. (2016c). Very narrow quantum OBDDs and width hierarchies for classical OBDDs. Lobachevskii J. Mathem. 37, 670–682. 10.1134/S199508021606007X

  • CrossRef
  • Google Scholar

• 10

  Ablayev F. Salikhova N. Ablayev M. (2024). Hybrid classical-quantum text search based on hashing. Mathematics12:1858. 10.3390/math12121858

  • CrossRef
  • Google Scholar

• 11

  Ablayev F. Vasiliev A. (2009). On quantum realisation of boolean functions by the fingerprinting technique. Discrete Mathem. Applic. 19, 555–572. 10.1515/DMA.2009.037

  • CrossRef
  • Google Scholar

• 12

  Ablayev F. Vasiliev A. (2011). “Classical and quantum parallelism in the quantum fingerprinting method,” in International Conference on Parallel Computing Technologies (Springer), 1–12. 10.1007/978-3-642-23178-0_1

  • CrossRef
  • Google Scholar

• 13

  Ablayev F. Vasiliev A. (2013a). Cryptographic quantum hashing. Laser Phys. Lett. 11:025202. 10.1088/1612-2011/11/2/025202

  • CrossRef
  • Google Scholar

• 14

  Ablayev F. Vasiliev A. (2014). “Computing boolean functions via quantum hashing,” in Computing with New Resources: Essays Dedicated to Jozef Gruska on the Occasion of His 80th Birthday, 149–160. 10.1007/978-3-319-13350-8_11

  • CrossRef
  • Google Scholar

• 15

  Ablayev F. Vasiliev A. (2020). “Quantum hashing and fourier transform,” in Journal of Physics: Conference Series (IOP Publishing), 012001. 10.1088/1742-6596/1680/1/012001

  • CrossRef
  • Google Scholar

• 16

  Ablayev F. Vasiliev A. (2022). “Quantum hashing on the high-dimensional states,” in International Conference on Micro-and Nano-Electronics 2021 (SPIE), 565–570. 10.1117/12.2624628

  • CrossRef
  • Google Scholar

• 17

  Ablayev F. M. Ablayev M. F. Vasilev A. V. (2014). Universal quantum hashing. Uchenye Zapiski Kazanskogo Universiteta. Seriya Fiziko-Matematicheskie Nauki156, 7–18. Available online at: https://www.mathnet.ru/eng/uzku1261

  • Google Scholar

• 18

  Ablayev F. M. Vasiliev A. (2013b). Algorithms for quantum branching programs based on fingerprinting. Int. J. Softw. Inform. 7, 485–500. Available online at: https://openurl.ebsco.com/EPDB%3Agcd%3A12%3A22738220/detailv2?sid=ebsco%3Aplink%3Ascholar&id=ebsco%3Agcd%3A95709941&crl=c&link_origin=scholar.google.com

  • Google Scholar

• 19

  Ajtai M. Iwaniec H. Komlós J. Pintz J. Szemerédi E. (1990). Construction of a thin set with small fourier coefficients. Bull. London Mathem. Soc. 22, 583–590. 10.1112/blms/22.6.583

  • CrossRef
  • Google Scholar

• 20

  Ambainis A. Freivalds R. (1998). “1-way quantum finite automata: strengths, weaknesses and generalizations,” in FOCS'98 (IEEE), 332–341. 10.1109/SFCS.1998.743469

  • CrossRef
  • Google Scholar

• 21

  Ambainis A. Nahimovs N. (2009). Improved constructions of quantum automata. Theor. Comput. Sci. 410, 1916–1922. 10.1016/j.tcs.2009.01.027

  • CrossRef
  • Google Scholar

• 22

  Ambainis A. Nayak A. Ta-Shma A. Vazirani U. (2002). Dense quantum coding and quantum finite automata. J. ACM49, 496–511. 10.1145/581771.581773

  • CrossRef
  • Google Scholar

• 23

  Ambainis A. Watrous J. (2002). Two-way finite automata with quantum and classical states. Theor. Comput. Sci. 287, 299–311. 10.1016/S0304-3975(02)00138-X

  • CrossRef
  • Google Scholar

• 24

  Ambainis A. Yakaryılmaz A. (2021). “Automata and quantum computing,” in Handbook of Automata Theory, ed. J. Éric Pin (European Mathematical Society Publishing House), 1457–1493. 10.4171/automata-2/17

  • CrossRef
  • Google Scholar

• 25

  Bergholm V. Vartiainen J. J. Möttönen M. Salomaa M. M. (2005). Quantum circuits with uniformly controlled one-qubit gates. Phys. Rev. A71:052330. 10.1103/PhysRevA.71.052330

  • CrossRef
  • Google Scholar

• 26

  Bertoni A. (1975). The Solution of Problems Relative to Probabilistic Automata in the Frame of the Formal Languages Theory. GI-4. Jahrestagung: Berlin, 107–112. 10.1007/978-3-662-40087-6_6

  • CrossRef
  • Google Scholar

• 27

  Bertoni A. Mauri G. Torelli M. (1977). “Some recursively unsolvable problems relating to isolated cutpoints in probabilistic automata,” in Automata, Languages and Programming: Fourth Colloquium, University of Turku, Finland (Springer), 87–94. 10.1007/3-540-08342-1_7

  • CrossRef
  • Google Scholar

• 28

  Birkan U. Salehi Ö. Olejar V. Nurlu C. Yakaryılmaz A. (2021). “Implementing quantum finite automata algorithms on noisy devices,” in International Conference on Computational Science (Springer), 3–16. 10.1007/978-3-030-77980-1_1

  • CrossRef
  • Google Scholar

• 29

  Buhrman H. Cleve R. Watrous J. de Wolf R. (2001). Quantum fingerprinting. Phys. Rev. Lett. 87:167902. 10.1103/PhysRevLett.87.167902

  • Pubmed Abstract
  • CrossRef
  • Google Scholar

• 30

  Chadha R. Sistla A. P. Viswanathan M. (2013). “Probabilistic automata with isolated cut-points,” in International Symposium on Mathematical Foundations of Computer Science (Springer), 254–265. 10.1007/978-3-642-40313-2_24

  • CrossRef
  • Google Scholar

• 31

  Cross A. W. Bishop L. S. Sheldon S. Nation P. D. Gambetta J. M. (2019). Validating quantum computers using randomized model circuits. Phys. Rev. A100:032328. 10.1103/PhysRevA.100.032328

  • CrossRef
  • Google Scholar

• 32

  Gainutdinova A. (2002). On relative complexity of quantum and classical branching programs. Discrete Mathem. Applic. 12, 515–526. 10.1515/dma-2002-0510

  • CrossRef
  • Google Scholar

• 33

  Gainutdinova A. Yakaryılmaz A. (2015). “Unary probabilistic and quantum automata on promise problems,” in Developments in Language Theory (Springer), 252–263. 10.1007/978-3-319-21500-6_20

  • CrossRef
  • Google Scholar

• 34

  Gainutdinova A. Yakaryılmaz A. (2017). “Nondeterministic unitary obdds,” in Computer Science - Theory and Applications- 12th International Computer Science Symposium in Russia, CSR 2017, Kazan, Russia, June 8–12, 2017, Proceedings, volume 10304 of Lecture Notes in Computer Science (Springer), 126–140. 10.1007/978-3-319-58747-9_13

  • CrossRef
  • Google Scholar

• 35

  Gainutdinova A. Yakaryılmaz A. (2018). Unary probabilistic and quantum automata on promise problems. Quant. Inf. Proc. 17:28. 10.1007/s11128-017-1799-0

  • CrossRef
  • Google Scholar

• 36

  Gimbert H. Oualhadj Y. (2010). “Probabilistic automata on finite words: decidable and undecidable problems,” in Automata, Languages and Programming: 37th International Colloquium, ICALP 2010, Bordeaux, France, July 6–10, 2010, Proceedings, Part II 37 (Springer), 527–538. 10.1007/978-3-642-14162-1_44

  • CrossRef
  • Google Scholar

• 37

  Hu Y. Melnyk D. Wang Y. Wattenhofer R. (2020). “Space complexity of streaming algorithms on universal quantum computers,” in Theory and Applications of Models of Computation: 16th International Conference, TAMC 2020, Changsha, China, October 18–20, 2020, Proceedings 16 (Springer), 275–286. 10.1007/978-3-030-59267-7_24

  • CrossRef
  • Google Scholar

• 38

  IBM (2022). Eagle's quantum performance progress. Available online at: https://www.ibm.com/quantum/blog/eagle-quantum-processor-performance (accessed April 30, 2024).

  • Google Scholar

• 39

  IBM (2025). Qiskit SDK v2.0.0. GenericBackendV2. https://docs.quantum.ibm.com/api/qiskit/qiskit.providers.fake_provider.GenericBackendV2 (accessed March 23, 2025).

  • Google Scholar

• 40

  Kālis M. (2018). Kvantu algoritmu realizācija fiziskā kvantu datorā (quantum algorithm implementation on a physical quantum computer). Master's thesis, University of Latvia.

  • Google Scholar

• 41

  Khadiev K. Khadieva A. (2017). “Reordering method and hierarchies for quantum and classical ordered binary decision diagrams,” in CSR 2017 (Springer), 162–175. 10.1007/978-3-319-58747-9_16

  • CrossRef
  • Google Scholar

• 42

  Khadiev K. Khadieva A. (2021). Quantum online streaming algorithms with logarithmic memory. Int. J. Theor. Phys. 60, 608–616. 10.1007/s10773-019-04209-1

  • CrossRef
  • Google Scholar

• 43

  Khadiev K. Khadieva A. (2022). Quantum and classical log-bounded automata for the online disjointness problem. Mathematics10:143. 10.3390/math10010143

  • CrossRef
  • Google Scholar

• 44

  Khadiev K. Khadieva A. Knop A. (2022a). Exponential separation between quantum and classical ordered binary decision diagrams, reordering method and hierarchies. Nat. Comput. 22, 723–736. 10.1007/s11047-022-09904-3

  • CrossRef
  • Google Scholar

• 45

  Khadiev K. Khadieva A. Mannapov I. (2018). Quantum online algorithms with respect to space and advice complexity. Lobachevskii J. Mathem. 39, 1210–1220. 10.1134/S1995080218090421

  • CrossRef
  • Google Scholar

• 46

  Khadiev K. Khadieva A. Ziatdinov M. Mannapov I. Kravchenko D. Rivosh A. et al . (2022b). Two-way and one-way quantum and classical automata with advice for online minimization problems. Theor. Comput. Sci. 920, 76–94. 10.1016/j.tcs.2022.02.026

  • CrossRef
  • Google Scholar

• 47

  Khadiev K. Serov D. (2025). “Quantum algorithm for the multiple string matching problem,” in International Conference on Current Trends in Theory and Practice of Computer Science (Springer), 58–69. 10.1007/978-3-031-82697-9_5

  • CrossRef
  • Google Scholar

• 48

  Khadiev K. and Khadieva A. Kravchenko D. Mannapov I. Rivosh A. Yamilov R. (2023). Quantum versus classical online streaming algorithms with logarithmic size of memory. Lobachevskii J. Mathem. 44, 687–698. 10.1134/S1995080223020208

  • CrossRef
  • Google Scholar

• 49

  Khadieva A. (2023). Optimal parameters computing code. Available online at: https://github.com/aliyakhadi/Parameters_counting (accessed April 30, 2025).

  • Google Scholar

• 50

  Khadieva A. (2024). Quantum hashing algorithm implementation. Technical report. arXiv:quant-ph/2024.

  • Google Scholar

• 51

  Khadieva A. Salehi O. Yakaryılmaz A. (2024). “A representative framework for implementing quantum finite automata on real devices,” in Proceedings of UCNC 2024. 10.1007/978-3-031-63742-1_12

  • CrossRef
  • Google Scholar

• 52

  Khadieva A. Ziatdinov M. (2023). Deterministic construction of qfas based on the quantum fingerprinting technique. Lobachevskii J. Mathem. 44, 713–723. 10.1134/S199508022302021X

  • CrossRef
  • Google Scholar

• 53

  Le Gall F. (2006). “Exponential separation of quantum and classical online space complexity,” in SPAA '06: Proceedings of the Eighteenth Annual ACM Symposium on Parallelism in Algorithms and Architectures (ACM), 67–73. 10.1145/1148109.1148119

  • CrossRef
  • Google Scholar

• 54

  Le Gall F. (2009). Exponential separation of quantum and classical online space complexity. Theory Comput. Syst. 45, 188–202. 10.1007/s00224-007-9097-3

  • CrossRef
  • Google Scholar

• 55

  Mitchell M. (1998). An Introduction to Genetic Algorithms. London: MIT press.

  • Google Scholar

• 56

  Montanaro A. (2017). Quantum pattern matching fast on average. Algorithmica77, 16–39. 10.1007/s00453-015-0060-4

  • CrossRef
  • Google Scholar

• 57

  Moore C. Crutchfield J. P. (2000). Quantum automata and quantum grammars. Theor. Comput. Sci. 237, 275–306. 10.1016/S0304-3975(98)00191-1

  • CrossRef
  • Google Scholar

• 58

  Möttönen M. Vartiainen J. J. Bergholm V. Salomaa M. M. (2004). Quantum circuits for general multiqubit gates. Phys. Rev. Lett. 93:130502. 10.1103/PhysRevLett.93.130502

  • Pubmed Abstract
  • CrossRef
  • Google Scholar

• 59

  Nakanishi M. Yakaryılmaz A. (2015). “Classical and quantum counter automata on promise problems,” in International Conference on Implementation and Application of Automata (Springer), 224–237. 10.1007/978-3-319-22360-5_19

  • CrossRef
  • Google Scholar

• 60

  Preskill J. (2018). Quantum computing in the nisq era and beyond. Quantum2:79. 10.22331/q-2018-08-06-79

  • CrossRef
  • Google Scholar

• 61

  Press W. H.. (1992). The Art of Scientific Computing. Cambridge: Cambridge University Press.

  • Google Scholar

• 62

  Rabin M. O. (1963). Probabilistic automata. Inf. Control6, 230–245. 10.1016/S0019-9958(63)90290-0

  • CrossRef
  • Google Scholar

• 63

  Ramesh H. Vinay V. (2003). String matching in quantum time. J. Discr. Algor. 1, 103–110. 10.1016/S1570-8667(03)00010-8

  • CrossRef
  • Google Scholar

• 64

  Razborov A. Szemerédi E. Wigderson A. (1993). Constructing small sets that are uniform in arithmetic progressions. Combinat. Probab. Comput. 2, 513–518. 10.1017/S0963548300000870

  • CrossRef
  • Google Scholar

• 65

  Salehi Ö. Yakaryılmaz A. (2021). Cost-efficient QFA algorithm for quantum computers. arXiv:2107.02262.

  • Google Scholar

• 66

  Say A. C. C. Yakaryılmaz A. (2014). “Quantum finite automata: a modern introduction,” in Computing with New Resources (Springer), 208–222. 10.1007/978-3-319-13350-8_16

  • CrossRef
  • Google Scholar

• 67

  Tao T. Vu V. (2006). Additive Combinatorics, volume 105 of Cambridge Studies in Advanced Mathematics. Cambridge: Cambridge University Press. 10.1017/CBO9780511755149

  • CrossRef
  • Google Scholar

• 68

  Turaykhanov D. Akat'ev D. Vasiliev A. Ablayev F. Kalachev A. (2021). Quantum hashing via single-photon states with orbital angular momentum. Phys. Rev. A104:052606. 10.1103/PhysRevA.104.052606

  • CrossRef
  • Google Scholar

• 69

  Vasiliev A. (2016a). Binary quantum hashing. Russian Mathem. 60, 61–65. 10.3103/S1066369X16090073

  • CrossRef
  • Google Scholar

• 70

  Vasiliev A. (2016b). “A model of quantum communication device for quantum hashing,” in Journal of Physics: Conference Series (IOP Publishing), 012020. 10.1088/1742-6596/681/1/012020

  • CrossRef
  • Google Scholar

• 71

  Vasiliev A. (2016c). Quantum hashing for finite abelian groups. Lobachevskii J. Mathem. 37, 753–757. 10.1134/S1995080216060184

  • CrossRef
  • Google Scholar

• 72

  Vasiliev A. (2023). Constant-depth algorithm for quantum hashing. Russian Microelectr. 52, S399–S402. 10.1134/S106373972360067X

  • CrossRef
  • Google Scholar

• 73

  Vasiliev A. Latypov M. Ziatdinov M. (2017). Minimizing collisions for quantum hashing. J. Eng. Appl. Sci. 12, 877–880. 10.3923/jeasci.2017.877.880

  • CrossRef
  • Google Scholar

• 74

  Vasiliev A. Vasilov A. Latypov M. (2019). Analysis of properties of quantum hashing. J. Mathem. Sci. 241, 117–124. 10.1007/s10958-019-04412-9

  • CrossRef
  • Google Scholar

• 75

  Wack A. Paik H. Javadi-Abhari A. Jurcevic P. Faro I. Gambetta J. M. et al . (2021). Quality, speed, and scale: three key attributes to measure the performance of near-term quantum computers. arXiv:2110.14108.

  • Google Scholar

• 76

  Wright S. J. (2015). Coordinate descent algorithms. Mathem. Program. 151, 3–34. 10.1007/s10107-015-0892-3

  • CrossRef
  • Google Scholar

• 77

  Yakaryılmaz A. (2013). Log-space counter is useful for unary languages by help of a constant-size quantum register. arXiv preprint arXiv:1309.4767.

  • Google Scholar

• 78

  Yakaryılmaz A. Say A. C. (2009). Efficient probability amplification in two-way quantum finite automata. Theor. Comput. Sci. 410, 1932–1941. 10.1016/j.tcs.2009.01.029

  • CrossRef
  • Google Scholar

• 79

  Yakaryılmaz A. Say A. C. C. (2010). Languages recognized by nondeterministic quantum finite automata. Quantum Inf. Comput. 10, 747–770. 10.26421/QIC10.9-10-3

  • CrossRef
  • Google Scholar

• 80

  Ziatdinov M. (2016a). From graphs to keyed quantum hash functions. Lobachevskii J. Mathem. 37, 705–712. 10.1134/S1995080216060202

  • CrossRef
  • Google Scholar

• 81

  Ziatdinov M. (2016b). Quantum hashing group approach. Lobachevskii J. Mathem. 37, 222–226. 10.1134/S1995080216020165

  • CrossRef
  • Google Scholar

• 82

  Ziiatdinov M. Khadieva A. Yakaryılmaz A. (2023). “Gaps for shallow implementation of quantum finite automata,” in Proceedings of the 16th International Conference on Automata and Formal Languages (AFL 2023), Eger, Hungary, eds. S. I. Zsolt Gazdag and G. Kovasznai (Open Publishing Association), 269–280. 10.4204/EPTCS.386.21

  • CrossRef
  • Google Scholar

• 83

  Zinnatullin I. (2023). Cryptographic properties of the quantum hashing based on expander graphs. Lobachevskii J. Mathem. 44, 776–787. 10.1134/S1995080223020397

  • CrossRef
  • Google Scholar

• 84

  Zinnatullin I. Khadiev K. Khadieva A. (2023). Efficient implementation of amplitude form of quantum hashing using state-of-the-art quantum processors. Russian Microelectr. 52, S390–S394. 10.1134/S1063739723600620

  • CrossRef
  • Google Scholar