arXiv subjects

Priyanka Mukhopadhyay

Publications and source records attributed to Priyanka Mukhopadhyay.

At least 19 recordsLinked to original sources

arXiv2026

Improved quantum circuits for division

Arithmetic operations are an important component of many quantum algorithms. Optimizing quantum circuits for these operations therefore leads to more efficient implementations of the corresponding algorithms. In this paper, we develop new fault-tolerant quantum circuits for various integer division algorithms (both reversible and non-reversible). These circuits, when implemented in the Clifford+T gate set, achieve improvements in the asymptotic T-count and CNOT-count from $O(n^2)$ to $O(nm)$, and in the asymptotic T-depth from $O(n^2)$ to $O(n \log m)$, where $n$ and $m$ are the bit lengths of the dividend and divisor, respectively. The qubit counts are significantly lower than those in previous works. We achieve this through careful modifications of the division algorithms and by expressing them in terms of a primitive we call COMP-N-SUB that compares two integers and conditionally subtracts them. We show that this primitive can be implemented at a cost, in terms of both Clifford and non-Clifford gates, comparable to that of one addition. By contrast, performing comparison and conditional subtraction separately would cost roughly as much as a controlled addition plus a regular addition.

quant-ph↗

arXiv2026

Graphical and algebraic methods for Boolean factoring

The problem of factoring Boolean polynomials has significant applications in both classical and quantum computing technology. In this paper we have developed novel algorithms for factoring both ESOP and SOP expressions. Our aim is to optimize the AND-count. The AND-count plays a key role in determining the number of AND and Toffoli gates required to implement a reversible function with classical and quantum circuits, respectively. The first type of algorithms that we develop, are graphical. We reduce the problem of Boolean factoring to covering a bipartite graph with bicliques, and so optimizing the number of bicliques required to cover the bipartite graph, leads to reduced number of factors, and hence AND-count. The second type of algorithm is algebraic, and is derived from multivariate Horner method. We have compared the performances of our algorithms with existing popular methods like EXORCISM-4 and EPOEM2, on random functions of up to 12 variables. We have observed that our multivariate Horner method is substantially faster, while our biclique-based method achieves the maximum AND-count reduction. In fact, compared to EXORCISM-4 our biclique based method achieves up to 5 times reduction in AND-count.

quant-ph↗

arXiv2026

Scattering Processes from Quantum Simulation Algorithms for Scalar Field Theories

We provide practical simulation methods for scalar field theories on a quantum computer that yield improved asymptotics as well as concrete gate estimates for the simulation and physical qubit estimates using the surface code. We achieve these improvements through two optimizations. First, we consider a finite volume approach for estimating the elements of the S-matrix. This approach is appropriate in general for 1+1D and for certain low-energy elastic collisions in higher dimensions. Second, we implement our approach using a series of different fault-tolerant simulation algorithms for Hamiltonians formulated both in the field occupation basis and field amplitude basis. Our algorithms are based on either second-order Trotterization or qubitization. The cost of Trotterization in occupation basis scales as $O(λN^7 |Ω|^3/(M^{5/2} ε^{3/2}))$ where $λ$ is the coupling strength, $N$ is the occupation cutoff, $|Ω|$ is the volume of the spatial lattice, $M$ is the mass of the particles and $ε$ is the uncertainty in the energy calculation used for the $S$-matrix determination. Qubitization in the field basis scales as $O(|Ω|^2 (k^2 Λ+kM^2)/ε)$ where $k$ is the cutoff in the field and $Λ$ is a scaled coupling constant. We find in both cases that the bounds suggest physically meaningful simulations can be performed using on the order of $4\times 10^6$ physical qubits and $10^{12}$ $T$-gates which corresponds to roughly one day on a superconducting quantum computer with surface code and a cycle time of 100 ns. This places the simulation of scalar field theory within striking distance of the gate counts for the best available chemistry simulation results.

quant-ph↗

arXiv2025

Optimizing the non-Clifford-count in unitary synthesis using Reinforcement Learning

In this paper we study the potential of using reinforcement learning (RL) in order to synthesize quantum circuits, while optimizing the T-count and CS-count, of unitaries that are exactly implementable by the Clifford+T and Clifford+CS gate sets, respectively. We have designed our RL framework to work with channel representation of unitaries, that enables us to perform matrix operations efficiently, using integers only. We have also incorporated pruning heuristics and a canonicalization of operators, in order to reduce the search complexity. As a result, compared to previous works, we are able to implement significantly larger unitaries, in less time, with much better success rate and improvement factor. Our results for Clifford+T synthesis on two qubit unitaries achieve close-to-optimal decompositions for up to 100 T gates, 5 times more than previous RL algorithms and to the best of our knowledge, the largest instances achieved with any method to date. Our RL algorithm is able to recover previously-known optimal linear complexity algorithm for T-count-optimal decomposition of 1 qubit unitaries. We illustrate significant reduction in the asymptotic T-count estimate of important primitives like controlled cyclic shift (43%), controlled adder (14.3%) and multiplier (14%), without adding any extra ancilla. For 2-qubit Clifford+CS unitaries, our algorithm achieves a linear complexity, something that could only be accomplished by a previous algorithm using SO(6) representation.

quant-ph↗

arXiv2025

A quantum random access memory (QRAM) using a polynomial encoding of binary strings

Quantum algorithms claim significant speedup over their classical counterparts for solving many problems. An important aspect of many of these algorithms is the existence of a quantum oracle, which needs to be implemented efficiently in order to realize the claimed advantages. A quantum random access memory (QRAM) is a promising architecture for realizing these oracles. In this paper we develop a new design for QRAM and implement it with Clifford+T circuit. We focus on optimizing the T-count and T-depth since non-Clifford gates are the most expensive to implement fault-tolerantly. Integral to our design is a polynomial encoding of bit strings and so we refer to this design as $\text{QRAM}_{poly}$. Compared to the previous state-of-the-art bucket brigade architecture for QRAM, we achieve an exponential improvement in T-depth, while reducing T-count and keeping the qubit count same. Specifically, if $N$ is the number of memory locations, then $\text{QRAM}_{poly}$ has T-depth $O(\log\log N)$, T-count $O(N-\log N)$ and qubit count $O(N)$, while the bucket brigade circuit has T-depth $O(\log N)$, T-count $O(N)$ and qubit count $O(N)$. Combining two $\text{QRAM}_{poly}$ we design a quantum look-up-table, $\text{qLUT}_{poly}$, that has T-depth $O(\log\log N)$, T-count $O(\sqrt{N})$ and qubit count $O(\sqrt{N})$. A qLUT or quantum read-only memory (QROM) has restricted functionality than a QRAM and needs to be compiled each time the contents of the memory change. The previous state-of-the-art CSWAP architecture has T-depth $O(\sqrt{N})$, T-count $O(\sqrt{N})$ and qubit count $O(\sqrt{N})$. Thus we achieve a double exponential improvement in T-depth while keeping the T-count and qubit-count asymptotically same. Additionally, with our polynomial encoding of bit strings, we develop a method to optimize the Toffoli-count of circuits, specially those consisting of multi-controlled-NOT gates.

quant-ph↗

arXiv2024

Quantum Simulation of the First-Quantized Pauli-Fierz Hamiltonian

We provide an explicit recursive divide and conquer approach for simulating quantum dynamics and derive a discrete first quantized non-relativistic QED Hamiltonian based on the many-particle Pauli Fierz Hamiltonian. We apply this recursive divide and conquer algorithm to this Hamiltonian and compare it to a concrete simulation algorithm that uses qubitization. Our divide and conquer algorithm, using lowest order Trotterization, scales for fixed grid spacing as $\widetilde{O}(ΛN^2η^2 t^2 /ε)$ for grid size $N$, $η$ particles, simulation time $t$, field cutoff $Λ$ and error $ε$. Our qubitization algorithm scales as $\widetilde{O}(N(η+N)(η+Λ^2) t\log(1/ε)) $. This shows that even a naïve partitioning and low-order splitting formula can yield, through our divide and conquer formalism, superior scaling to qubitization for large $Λ$. We compare the relative costs of these two algorithms on systems that are relevant for applications such as the spontaneous emission of photons, and the photoionization of electrons. We observe that for different parameter regimes, one method can be favored over the other. Finally, we give new algorithmic and circuit level techniques for gate optimization including a new way of implementing a group of multi-controlled-X gates that can be used for better analysis of circuit cost.

quant-ph↗

arXiv2024

Synthesizing Toffoli-optimal quantum circuits for arbitrary multi-qubit unitaries

In this paper we study the Clifford+Toffoli universal fault-tolerant gate set. We introduce a generating set in order to represent any unitary implementable by this gate set and with this we derive a bound on the Toffoli-count of arbitrary multi-qubit unitaries. We analyse the channel representation of the generating set elements, with the help of which we infer $|\mathcal{J}_n^{Tof}|<|\mathcal{J}_n^T|$, where $\mathcal{J}_n^{Tof}$ and $\mathcal{J}_n^T$ are the set of unitaries exactly implementable by the Clifford+Toffoli and Clifford+T gate set, respectively. We develop Toffoli-count optimal synthesis algorithms for both approximately and exactly implementable multi-qubit unitaries. With the help of these we prove $|\mathcal{J}_n^{Tof}|=|\mathcal{J}_n^{CS}|$, where $\mathcal{J}_n^{CS}$ is the set of unitaries exactly implementable by the Clifford+CS gate set.

quant-ph↗

arXiv2023

Synthesizing efficient circuits for Hamiltonian simulation

We provide a new approach for compiling quantum simulation circuits that appear in Trotter, qDRIFT and multi-product formulas to Clifford and non-Clifford operations that can reduce the number of non-Clifford operations by a factor of up to $4$. In fact, the total number of gates reduce in many cases. We show that it is possible to implement an exponentiated sum of commuting Paulis with at most $m$ (controlled)-rotation gates, where $m$ is the number of distinct non-zero eigenvalues (ignoring sign). Thus we can collect mutually commuting Hamiltonian terms into groups that satisfy one of several symmetries identified in this work which allow an inexpensive simulation of the entire group of terms. We further show that the cost can in some cases be reduced by partially allocating Hamiltonian terms to several groups and provide a polynomial time classical algorithm that can greedily allocate the terms to appropriate groupings. We further specifically discuss these optimizations for the case of fermionic dynamics and provide extensive numerical simulations for qDRIFT of our grouping strategy to 6 and 4-qubit Heisenberg models, $LiH$, $H_2$ and observe a factor of 1.8-3.2 reduction in the number of non-Clifford gates. This suggests Trotter-based simulation of chemistry in second quantization may be even more practical than previously believed.

quant-ph↗

arXiv2023

T-count and T-depth of any multi-qubit unitary

While implementing a quantum algorithm it is crucial to reduce the quantum resources, in order to obtain the desired computational advantage. For most fault-tolerant quantum error-correcting codes the cost of implementing the non-Clifford gate is the highest among all the gates in a universal fault-tolerant gate set. In this paper we design provable algorithm to determine T-count of any $n$-qubit ($n\geq 1$) unitary $W$ of size $2^n\times 2^n$, over the Clifford+T gate set. The space and time complexity of our algorithm are $O\left(2^{2n}\right)$ and $O\left(2^{2n\mathcal{T}_ε(W)+4n}\right)$ respectively. $\mathcal{T}_ε(W)$ ($ε$-T-count) is the (minimum possible) T-count of an exactly implementable unitary $U$ i.e. $\mathcal{T}(U)$, such that $d(U,W)\leqε$ and $\mathcal{T}(U)\leq\mathcal{T}(U')$ where $U'$ is any exactly implementable unitary with $d(U',W)\leqε$. $d(.,.)$ is the global phase invariant distance. Our algorithm can also be used to determine the (minimum possible) T-depth of any multi-qubit unitary and the complexity has exponential dependence on $n$ and $ε$-T-depth. This is the first algorithm that gives T-count or T-depth of any multi-qubit ($n\geq 1$) unitary. For small enough $ε$, we can synthesize the T-count and T-depth-optimal circuits. Our results can be used to determine the minimum count (or depth) of non-Clifford gates required to implement any multi-qubit unitary with a universal gate set consisting of Clifford and non-Clifford gates like Clifford+CS, Clifford+V, etc. To the best of our knowledge, there were no such optimal-synthesis algorithm for arbitrary multi-qubit unitaries in any universal gate set.

quant-ph↗

arXiv2023

Adaptive estimation of quantum observables

The accurate estimation of quantum observables is a critical task in science. With progress on the hardware, measuring a quantum system will become increasingly demanding, particularly for variational protocols that require extensive sampling. Here, we introduce a measurement scheme that adaptively modifies the estimator based on previously obtained data. Our algorithm, which we call AEQuO, continuously monitors both the estimated average and the associated error of the considered observable, and determines the next measurement step based on this information. We allow both for overlap and non-bitwise commutation relations in the subsets of Pauli operators that are simultaneously probed, thereby maximizing the amount of gathered information. AEQuO comes in two variants: a greedy bucket-filling algorithm with good performance for small problem instances, and a machine learning-based algorithm with more favorable scaling for larger instances. The measurement configuration determined by these subroutines is further post-processed in order to lower the error on the estimator. We test our protocol on chemistry Hamiltonians, for which AEQuO provides error estimates that improve on all state-of-the-art methods based on various grouping techniques or randomized measurements, thus greatly lowering the toll of measurements in current and future quantum applications.

quant-ph↗

arXiv2022

Reducing the CNOT count for Clifford+T circuits on NISQ architectures

While mapping a quantum circuit to the physical layer one has to consider the numerous constraints imposed by the underlying hardware architecture. Connectivity of the physical qubits is one such constraint that restricts two-qubit operations, such as CNOT, to "connected" qubits. SWAP gates can be used to place the logical qubits on admissible physical qubits, but they entail a significant increase in CNOT-count. In this paper we consider the problem of reducing the CNOT-count in Clifford+T circuits on connectivity constrained architectures, like noisy intermediate-scale quantum (NISQ) computing devices. We "slice" the circuit at the position of Hadamard gates and "build" the intermediate {CNOT,T} sub-circuits using Steiner trees, significantly improving on previous methods. We compared the performance of our algorithms while mapping different benchmark and random circuits to some well-known architectures such as 9-qubit square grid, 16-qubit square grid, Rigetti 16-qubit Aspen, 16-qubit IBM QX5 and 20-qubit IBM Tokyo. Our methods give less CNOT-count compared to Qiskit and TKET transpiler as well as using SWAP gates. Assuming most of the errors in a NISQ circuit implementation are due to CNOT errors, then our method would allow circuits with few times more CNOT gates be reliably implemented than the previous methods would permit.

quant-ph↗

arXiv2022

A (quasi-)polynomial time heuristic algorithm for synthesizing T-depth optimal circuits

We investigate the problem of synthesizing T-depth optimal quantum circuits over the Clifford+T gate set. First we construct a special subset of T-depth 1 unitaries, such that it is possible to express the T-depth-optimal decomposition of any unitary as product of unitaries from this subset and a Clifford (up to global phase). The cardinality of this subset is at most $n\cdot 2^{5.6n}$. We use nested meet-in-the-middle (MITM) technique to develop algorithms for synthesizing provably \emph{depth-optimal} and \emph{T-depth-optimal} circuits for exactly implementable unitaries. Specifically, for synthesizing T-depth-optimal circuits, we get an algorithm with space and time complexity $O\left(\left(4^{n^2}\right)^{\lceil d/c\rceil}\right)$ and $O\left(\left(4^{n^2}\right)^{(c-1)\lceil d/c\rceil}\right)$ respectively, where $d$ is the minimum T-depth and $c\geq 2$ is a constant. This is much better than the complexity of the algorithm by Amy et al.(2013), the previous best with a complexity $O\left(\left(3^n\cdot 2^{kn^2}\right)^{\lceil \frac{d}{2}\rceil}\cdot 2^{kn^2}\right)$, where $k>2.5$ is a constant. We design an even more efficient algorithm for synthesizing T-depth-optimal circuits. The claimed efficiency and optimality depends on some conjectures, which have been inspired from the work of Mosca and Mukhopadhyay (2020). To the best of our knowledge, the conjectures are not related to the previous work. Our algorithm has space and time complexity $poly(n,2^{5.6n},d)$ (or $poly(n^{\log n},2^{5.6n},d)$ under some weaker assumptions).

quant-ph↗

arXiv2021

Faster provable sieving algorithms for the Shortest Vector Problem and the Closest Vector Problem on lattices in $\ell_p$ norm

In this work, we give provable sieving algorithms for the Shortest Vector Problem (SVP) and the Closest Vector Problem (CVP) on lattices in $\ell_p$ norm ($1\leq p\leq\infty$). The running time we obtain is better than existing provable sieving algorithms. We give a new linear sieving procedure that works for all $\ell_p$ norm ($1\leq p\leq\infty$). The main idea is to divide the space into hypercubes such that each vector can be mapped efficiently to a sub-region. We achieve a time complexity of $2^{2.751n+o(n)}$, which is much less than the $2^{3.849n+o(n)}$ complexity of the previous best algorithm. We also introduce a mixed sieving procedure, where a point is mapped to a hypercube within a ball and then a quadratic sieve is performed within each hypercube. This improves the running time, especially in the $\ell_2$ norm, where we achieve a time complexity of $2^{2.25n+o(n)}$, while the List Sieve Birthday algorithm has a running time of $2^{2.465n+o(n)}$. We adopt our sieving techniques to approximation algorithms for SVP and CVP in $\ell_p$ norm ($1\leq p\leq\infty$) and show that our algorithm has a running time of $2^{2.001n+o(n)}$, while previous algorithms have a time complexity of $2^{3.169n+o(n)}$.

cs.DS↗

arXiv2021

Composability of global phase invariant distance and its application to approximation error management

Many quantum algorithms can be written as a composition of unitaries, some of which can be exactly synthesized by a universal fault-tolerant gate set, while others can be approximately synthesized. A quantum compiler synthesizes each approximately synthesizable unitary up to some approximation error, such that the error of the overall unitary remains bounded by a certain amount. In this paper we consider the case when the errors are measured in the global phase invariant distance. Apart from deriving a relation between this distance and the Frobenius norm, we show that this distance composes. If a unitary is written as a composition (product and tensor product) of other unitaries, we derive bounds on the error of the overall unitary as a function of the errors of the composed unitaries. Our bound is better than the sum-of-error bound (Bernstein,Vazirani,1997), derived for the operator norm. This indicates that synthesizing a circuit using global phase invariant distance maybe done with less number of resources. Next we consider the following problem. Suppose we are given a decomposition of a unitary. The task is to distribute the errors in each component such that the T-count is optimized. Specifically, we consider those decompositions where $R_z(θ)$ gates are the only approximately synthesizable component. We prove analytically that for both the operator norm and global phase invariant distance, the error should be distributed equally among these components (given some approximations). The optimal number of T-gates obtained by using the global phase invariant distance is less. Furthermore, we show that in case of approximate Quantum Fourier Transform, the error obtained by pruning rotation gates is less when measured in this distance.

quant-ph↗

arXiv2021

A polynomial time and space heuristic algorithm for T-count

This work focuses on reducing the physical cost of implementing quantum algorithms when using the state-of-the-art fault-tolerant quantum error correcting codes, in particular, those for which implementing the T gate consumes vastly more resources than the other gates in the gate set. More specifically, we consider the group of unitaries that can be exactly implemented by a quantum circuit consisting of the Clifford+T gate set, a universal gate set. Our primary interest is to compute a circuit for a given $n$-qubit unitary $U$, using the minimum possible number of T gates (called the T-count of unitary $U$). We consider the problem COUNT-T, the optimization version of which aims to find the T-count of $U$. In its decision version the goal is to decide if the T-count is at most some positive integer $m$. Given an oracle for COUNT-T, we can compute a T-count-optimal circuit in time polynomial in the T-count and dimension of $U$. We give a provable classical algorithm that solves COUNT-T (decision) in time $O\left(N^{2(c-1)\lceil\frac{m}{c}\rceil}\text{poly}(m,N)\right)$ and space $O\left(N^{2\lceil\frac{m}{c}\rceil}\text{poly}(m,N)\right)$, where $N=2^n$ and $c\geq 2$. This gives a space-time trade-off for solving this problem with variants of meet-in-the-middle techniques. We also introduce an asymptotically faster multiplication method that shaves a factor of $N^{0.7457}$ off of the overall complexity. Lastly, beyond our improvements to the rigorous algorithm, we give a heuristic algorithm that outputs a T-count-optimal circuit and has space and time complexity $\text{poly}(m,N)$, under some assumptions. While our heuristic method still scales exponentially with the number of qubits (though with a lower exponent, there is a large improvement by going from exponential to polynomial scaling with $m$.

quant-ph↗

arXiv2021

The Projection Games Conjecture and the Hardness of Approximation of super-SAT and related problems

The Super-SAT or SSAT problem was introduced by Dinur et al.(2002,2003) to prove the NP-hardness of approximation of two popular lattice problems - Shortest Vector Problem(SVP) and Closest Vector Problem(CVP). They conjectured that SSAT is NP-hard to approximate to within a factor of $n^c$ ($c>0$ is constant), where $n$ is the size of the SSAT instance. In this paper we prove this conjecture assuming the Projection Games Conjecture(PGC), given by Moshkovitz (2012). This implies hardness of approximation of SVP and CVP within polynomial factors, assuming PGC. We also reduce SSAT to the Nearest Codeword Problem(NCP) and Learning Halfspace Problem(LHP), as considered by Arora et al.(1997). This proves that both these problems are NP-hard to approximate within a factor of $N^{c'/\log\log n}$($c'>0$ is constant) where $N$ is the size of the instances of the respective problems. Assuming PGC these problems are proved to be NP-hard to approximate within polynomial factors.

cs.CC↗

arXiv2018

Improved algorithms for the Shortest Vector Problem and the Closest Vector Problem in the infinity norm

Blomer and Naewe[BN09] modified the randomized sieving algorithm of Ajtai, Kumar and Sivakumar[AKS01] to solve the shortest vector problem (SVP). The algorithm starts with $N = 2^{O(n)}$ randomly chosen vectors in the lattice and employs a sieving procedure to iteratively obtain shorter vectors in the lattice. The running time of the sieving procedure is quadratic in $N$. We study this problem for the special but important case of the $\ell_\infty$ norm. We give a new sieving procedure that runs in time linear in $N$, thereby significantly improving the running time of the algorithm for SVP in the $\ell_\infty$ norm. As in [AKS02,BN09], we also extend this algorithm to obtain significantly faster algorithms for approximate versions of the shortest vector problem and the closest vector problem (CVP) in the $\ell_\infty$ norm. We also show that the heuristic sieving algorithms of Nguyen and Vidick[NV08] and Wang et al.[WLTB11] can also be analyzed in the $\ell_{\infty}$ norm. The main technical contribution in this part is to calculate the expected volume of intersection of a unit ball centred at origin and another ball of a different radius centred at a uniformly random point on the boundary of the unit ball. This might be of independent interest.

cs.DS↗

arXiv2018

Lifting randomized query complexity to randomized communication complexity

We show that for a relation $f\subseteq \{0,1\}^n\times \mathcal{O}$ and a function $g:\{0,1\}^{m}\times \{0,1\}^{m} \rightarrow \{0,1\}$ (with $m= O(\log n)$), $$\mathrm{R}_{1/3}(f\circ g^n) = Ω\left(\mathrm{R}_{1/3}(f) \cdot \left(\log\frac{1}{\mathrm{disc}(M_g)} - O(\log n)\right)\right),$$ where $f\circ g^n$ represents the composition of $f$ and $g^n$, $M_g$ is the sign matrix for $g$, $\mathrm{disc}(M_g)$ is the discrepancy of $M_g$ under the uniform distribution and $\mathrm{R}_{1/3}(f)$ ($\mathrm{R}_{1/3}(f\circ g^n)$) denotes the randomized query complexity of $f$ (randomized communication complexity of $f\circ g^n$) with worst case error $\frac{1}{3}$. In particular, this implies that for a relation $f\subseteq \{0,1\}^n\times \mathcal{O}$, $$\mathrm{R}_{1/3}(f\circ \mathrm{IP}_m^n) = Ω\left(\mathrm{R}_{1/3}(f) \cdot m\right),$$ where $\mathrm{IP}_m:\{0,1\}^m\times \{0,1\}^m\rightarrow \{0,1\}$ is the Inner Product (modulo $2$) function and $m= O(\log(n))$.

cs.CC↗