Error Mitigation in the NISQ Era: Applying Measurement Error Mitigation Techniques to Enhance Quantum Circuit Performance

Abstract

In quantum computing, noisy intermediate-scale quantum (NISQ) devices offer unprecedented computational capabilities but are vulnerable to errors, notably measurement inaccuracies that impact computation accuracy. This study explores the efficacy of error mitigation techniques in improving quantum circuit performance on NISQ devices. Techniques such as dynamic decoupling (DD), twirled readout error extraction (T-REx) and zero-noise extrapolation (ZNE) are examined through extensive experimentation on an ideal simulator, IBM Kyoto, and IBM Osaka quantum computers. Results reveal significant performance discrepancies across scenarios, with error mitigation techniques notably enhancing both estimator result and variance values, aligning more closely with ideal simulator outcomes. The comparison results with ideal simulator (having expected result value 0.8284) shows that T-Rex has improved results on IBM Kyoto and enhanced average expected result value from 0.09 to 0.35. Similarly, DD has improved average expected result values from 0.2492 to 0.3788 on IBM Osaka. These findings underscore the critical role of error mitigation in bolstering quantum computation reliability. The results suggest that selection of mitigation technique depends upon quantum circuit and its depth, type of hardware and operations to be performed.

1. Introduction

Quantum computing is the ultimate game-changer in the world of technology, bringing about revolutionary changes and unparalleled computational power. With its transformative potential, this cutting-edge technology promises to revolutionize industries. The global quantum technology market, valued at approximately USD 875.49 million in 2022, is projected to skyrocket to around USD 4312.09 million by 2030, reflecting a remarkable compound annual growth rate (CAGR) of roughly 22.06% between 2023 and 2030 [1]. This exponential growth underscores the escalating interest and investment in quantum computing technologies worldwide. In 2015, Google and NASA reported a groundbreaking achievement with their 1097-qubit D-Wave quantum computer, highlighting the transformative capabilities of quantum computing [2]. The machine processed a task within seconds that would take a classical computer 10,000 years to accomplish, demonstrating the immense potential of quantum computing in solving optimization problems [3].

Significant strides have been made in fabricating, controlling, and deploying quantum computing systems in recent years, pushing qubit counts to approximately 1000 or more. This development offers glimpses of potential advantages over classical computation methods in selected scenarios. However, realizing such advantages is impeded by various noise sources and errors inherent in quantum computers, compromising their efficacy in tackling problems of substantial scale. Quantum bits are highly susceptible to environmental disturbances, leading to computational errors. Three primary categories of errors afflict quantum computing [4]:

• Phase Flip Errors (Dephasing): Result from environmental factors causing a qubit to lose phase information.
• Bit Flip Errors (Depolarization): Arise when qubits flip states due to external influences like thermal vibrations and others.
• Gate Operation Errors: Errors introduced during the manipulation of qubits by quantum gates.

In quantum computing, noise introduces deviations from the desired outputs, resulting in inaccuracies [5]. The cumulative effect of noise on quantum circuits necessitates examining how each gate amplifies or alters the impact of errors and how noise occurs during the final measurement stage due to several factors at different stages of computations. During the final measurement stage, a more straightforward form of noise emerges. In this phase, the circuit’s primary objective is to extract a bit string from the existing qubits as an output. For an n-qubit final measurement, this process involves selecting one of the 2ⁿ possible states. To illustrate the noise within this framework, one can envision a scenario where the measurement initially selects an output ideally without any noise. However, subsequently, noise disrupts this ideal output by randomly perturbing it before presenting it to the user.

Understanding of patterns and characteristics of quantum noise [6] and errors [5] is essential for effectively mitigating their impacts on quantum computations. A common understanding is that quantum noise can lead to errors, where the presence of noise in quantum states or operations increases the likelihood of errors occurring during computational processes. Quantum noise poses a significant challenge in harnessing the full potential of quantum computing, stemming from environmental factors like temperature or electromagnetic radiation, which disrupt the delicate quantum states of qubits, leading to errors and system integrity issues [6]. Various types of quantum noise, including thermal, phonon, and photon noise, originate from different sources and impact qubits differently, with effects ranging from calculation errors to complete failures, particularly pronounced in large-scale quantum systems [7]. Mitigation strategies such as measurement error correction circuits, calibration circuits, error-correcting codes and dynamical decoupling techniques offer avenues to safeguard quantum systems from noise-induced errors, enhancing reliability and paving the way for more robust quantum computing [8]. Here are some critical aspects regarding the need for quantum error mitigation and correction:

• Fragility of quantum states: Quantum states used in computing are exceedingly delicate and prone to errors, with even minor disturbances causing computational inaccuracies. For instance, a single absorbed or scattered photon can induce a qubit flip, leading to errors.
• Exponential error rate growth: With the quantum computer’s size expansion, error probabilities escalate, with errors propagating throughout the system, resulting in a steep rise in error rates. Hence, there is a crucial need for error detection and correction mechanisms.

Quantum error correction [9] is vital for constructing large-scale quantum computers, enabling error detection and correction crucial for reliable and accurate computation outcomes. One important thing that must be discussed here is distinguishing between error mitigation and correction. Error mitigation techniques aim to lessen the impact of errors through statistical methods; Quantum Error Correction (QEC) directly detects and corrects errors [10]. Today, we are in the Noisy Intermediate-Scale Quantum (NISQ) era as quantum devices have limited qubit counts and error rates, mitigating measurement errors emerges as a critical imperative [11]. The NISQ era marks a pivotal phase in quantum computing, wherein the focus shifts towards harnessing the potential of available quantum hardware while navigating the constraints imposed by noise and errors. To address the challenges posed by measurement errors and other noise sources, publications from Google Quantum AI and International Business Machines Corporation (IBM) [12] showcase progress in creating more stable logical qubits and fault-tolerant quantum gates. However, scalability remains a significant concern, given various control signals required when scaling the number of physical qubits. These approaches encompass error correction codes, error mitigation strategies, and calibration protocols aimed at enhancing the performance and reliability of quantum circuits.

In this paper, we have utilized a quantum circuit for simulating quantum bits through Trotterization techniques on the ideal IBM simulator and on IBM quantum computers and then mitigate the measurement error using multiple error mitigation techniques. The major contributions of this paper are listed below.

• The paper investigates quantum Trotter circuits (QTC) with some modifications and evaluates their performance with error mitigation techniques.
• It compares results from an ideal simulator with those from IBM Quantum Computers, highlighting discrepancies.
• Error mitigation techniques such as dynamic decoupling (DD), twirled readout error extinction (T-REx), and Zero-noise extrapolation (ZNE) are applied, and their effectiveness is quantitatively analyzed.
• Significant improvements in both expected values and variances (variance analysis reveals varying degrees of stability and reliability among different error mitigation techniques) are observed when error mitigation techniques are implemented.
• This study identifies that DD, T-Rex and ZNE have different enhancement capabilities depending upon circuit, its depth and type of quantum hardware.
• Recommendations are made for selecting appropriate error mitigation techniques based on overall performance.
• The study underscores the challenges and opportunities in harnessing quantum computers in the NISQ era.
• The findings emphasize the importance of error mitigation techniques in enhancing the reliability and accuracy of quantum computations on NISQ devices.

The remaining article is divided as follows: Section 2 discusses the IBM Quantum resources and processor specifications used for the experimentation and readout & measurement error concept, Section 3 describes in detail Trotterization, QTC and how they are designed, Section 4 sheds light on the in-depth theory and mathematics behind different error mitigation techniques, and Section 5 is reserved for Results and Section 6 presents Discussion, followed by Section 7 which is the Conclusion. The overall steps adopted during the implementation of the proposed methodology/experimentation are shown in Figure 1.

2. IBM Quantum Resources

In quantum computing, the choice of quantum processor can significantly impact the success and efficiency of computational tasks. IBM offers several quantum processors, each with unique characteristics and performance metrics. Here, the specifications and error rates of two openly available IBM quantum processors—IBM Osaka (IBM_O) [13], IBM Kyoto (IBM_K) [14]—are discussed in addition to one IBM quantum simulator. The designed quantum circuits were implemented on these quantum hardwares/simulator and their results were then improved by applying three error mitigation techniques for analysis and comparison.

2.1. Processor Specifications

Table 1. Technical specification comparison of IBM Kyoto vs. IBM Osaka.

Parameter	IBM Kyoto	IBM Osaka	Relational Equation
Qubits	127	127	${Qubit}_{{IBM}_O}={Qubit}_{{IBM}_K}$
EPLG	3.6%	3%	${ELPG}_{{IBM}_O}<{ELPG}_{{IBM}_K}$
CLOPS	5K	5K	${CLOPS}_{{IBM}_O}={CLOPS}_{{IBM}_K}$
Median ECR Error	9.468 × 10−3	8.428 × 10−3	${MECRE}_{{IBM}_O}<{MECRE}_{{IBM}_K}$
Median SX Error	3.142 × 10−4	2.630 × 10−4	${MSE}_{{IBM}_O}<{MSE}_{{IBM}_K}$
Median Readout Error	1.720 × 10−2	2.290 × 10−2	${MRE}_{{IBM}_O}>{MRE}_{{IBM}_K}$
Median T1	207.58 us	296.87 us	${T1}_{{IBM}_O}>{T1}_{{IBM}_K}$
Median T2	93.28 us	141.93 us	${T2}_{{IBM}_O}>{T2}_{{IBM}_K}$
Processor Type	Eagle r3	Eagle r3	Similar
Version	1.2.38	1.1.8	IBM Kyoto version is more advanced

highlights the detailed comparison of IBM_K vs. IBM_O based upon 10 parameters, the details of which are given below [5,6,7,8,9,11,12,13].

• Number of qubits: the available number of qubits in each system.
• Error Probability per Logic Gate (EPLG): the likelihood of an error occurring during the execution of a logical gate operation in a quantum processor.
• Composite Logical Operations per Second (CLOPS): the computational speed of a quantum processor, measuring the rate at which logical operations are executed.
• Error Correcting Rate (ECR): the rate at which errors are corrected in a quantum system.
• Median ECR Error (MECRE): the average error rate associated with quantum gates operating within an error-corrected environment, providing insight into the reliability and precision of computational outcomes.
• Single-Qubit X Gate (SX): used to rotate around the Bloch sphere’s X-axis, altering the state of a single qubit in a quantum circuit.
• Median SX Error (MSXE): the median error rate related to the SX gate operation, indicating the accuracy of single-qubit quantum operations.
• Median Readout Error (MER): the average error rate during the measurement stage of a quantum computation, reflecting the fidelity of output results.
• Median T1/Coherence Time: the duration for which a quantum state can maintain its coherence or superposition, highlighting the stability and robustness of quantum operations.
• Median T2/Decay Time: the duration until the coherence of a quantum state is lost due to environmental interactions, offering insight into the temporal limitations of quantum computations.

The comparison between IBM quantum computers Kyoto and Osaka by measuring the above-mentioned parameters [13,14] generates a general picture of technical details and is presented in Table 1. The parameters shown in Table 1 were collected in July 2024 and they may improve as IBM is improving the performance of all their computers.

2.1.1. IBM Osaka

IBM_O features 127 qubits but presents a slightly lower error rate of 3% EPLG utilizing the same Eagle r3 architecture. However, it has a higher median readout error of 2.290 × 10⁻², potentially impacting computational accuracy despite its slightly longer median T1 of 296.87 microseconds [14].

2.1.2. IBM Kyoto

IBM_K, another 127-qubit processor, showcases a marginally higher error rate of 3.6% EPLG compared to its counterparts. It operates on the Eagle r3 architecture, providing similar CLOPS capabilities and basis gates. However, IBM_K presents a median readout error of 1.720 × 10⁻² and a median T1 of 207.58 microseconds, indicating a balance between error rate and stability [15].

2.1.3. IBM QASM Simulator

IBM QASM simulator (IBMQS) is a tool for simulating quantum circuits, providing ideal results, environment and realistic models incorporating noise [16]. Quantum Assembly Language (QASM) is the language used to describe quantum circuits and define operations and transformations performed on qubits. With 32 qubits, the simulator allows for the exploration and analysis of various quantum algorithms and protocols. Unlike IBM’s actual quantum computers, which are subject to physical limitations and imperfections, the QASM simulator operates purely in software, offering a controlled environment for experimentation. While real quantum devices showcase unique error rates and characteristics, the QASM simulator provides a controlled environment where users can explore quantum circuits’ behavior without physical hardware constraints.

2.1.4. Computer Resources

Initial circuit testing and quantum experimentation were conducted in Python 3.9 on a Windows OS, powered by an Intel Core i9-9700F CPU running at 3.00 GHz, supported by 16 GB of RAM, and a 2x RTX 3090 GPU with 48 GB of GPU memory for enhanced performance. The IBM quantum platform was accessed using an RTX 3090 GPU and all results were simulated and collected from the IBM platform.

2.2. Readout Assignment Error and Measurement Error

Readout assignment error [16] occurs when the outcome of a measurement does not match the expected outcome based on the assigned logical state. Mathematically, if we denote the assigned logical state as ∣ψ⟩ and the observed outcome as ∣m⟩, the readout assignment error $P_{\mathrm{r}\mathrm{e}\mathrm{a}\mathrm{d}\mathrm{o}\mathrm{u}\mathrm{t}}$ can be quantified as follows:

$$P_{\mathrm{r}\mathrm{e}\mathrm{a}\mathrm{d}\mathrm{o}\mathrm{u}\mathrm{t}}=\mathrm{P}\mathrm{r}(\psi \mid m)$$

(1)

This error arises due to imperfections in the readout process, such as crosstalk between qubits, imperfect calibration of measurement devices, or noise in the measurement apparatus. It can be estimated during the device calibration process by comparing the expected logical states with the observed outcomes.

Measurement error [17] refers to inaccuracies in the measurement process itself, encompassing various sources of noise and imperfections. It includes errors stemming from limitations of the measurement devices, environmental noise, and decoherence effects during the measurement operation. While devices can estimate these errors through statistical analysis, some transient and environmental factors may not be fully captured. Mathematically, it can be expressed as follows:

$$P_{\mathrm{M}\mathrm{e}\mathrm{a}\mathrm{s}\mathrm{u}\mathrm{r}\mathrm{e}\mathrm{m}\mathrm{e}\mathrm{n}\mathrm{t}}=\mathrm{P}\mathrm{r}(\psi \mid {\mathrm{m}}^{\prime })$$

(2)

where ∣m′⟩ represents the true quantum state measured with error.

Figure 2 provides a detailed visualization of the readout assignment error for each qubit in the IBM_K (Figure 2a) and IBM_O (Figure 2b) quantum processors. The x-axis represents the individual qubits number, and the y-axis shows the readout assignment error values. Higher readout assignment error values indicate qubits that are more prone to readout errors. This figure shows that qubit numbers 117 and 78 in IBM_K and IBM_O respectively had the highest readout assignment error. Roughly, it shows that 7 percent of the total qubits are more prone to errors. This figure is essential for understanding the distribution and severity of readout errors across different qubits in both processors. Figure 3 illustrates the error connection rates between pairs of qubits with eagle architecture. The connection error rates corresponding to IBM_K (Figure 3a) and IBM_O (Figure 3b) clearly show that roughly 7% of connections have more pairwise error trends. The x-axis shows the pairs of qubits involved in the error connection rate and the y-axis represents the error connection rate value. The data utilized in plotting Figure 2 and Figure 3 were acquired from the IBM platform in July 2024 [11,12,13].

Measurement error [17] and readout assignment error [16] are distinct in quantum computing. Measurement error refers to inaccuracies arising from imperfections in the measurement process itself, including noise in measurement devices, environmental disturbances, and decoherence effects during the measurement operation. It encompasses a broad range of factors affecting the fidelity of measurement outcomes. In contrast, readout assignment error specifically pertains to discrepancies between the expected and observed outcomes due to imperfections in the readout process, such as crosstalk between qubits, calibration errors in measurement devices, or noise in the readout apparatus. Unlike measurement error, readout assignment error focuses solely on errors related to the correct assignment of logical states during the measurement operation. Therefore, while measurement error encompasses various sources of inaccuracies in measurement, readout assignment error is a specific type of error that occurs during the assignment of measured outcomes to logical states. To address both types of errors, we apply error mitigation techniques, including DD, T-REx, and ZNE aiming to reduce the impact of these errors and improve the reliability of quantum computations. These techniques help to encompass inestimable errors by providing a more stable measurement environment, enhancing the overall accuracy of quantum circuits simulated on IBM quantum computers. The focus of this paper is to apply mitigation techniques to reduce generated measurement error in quantum circuits simulated on IBM quantum computers.

3. Quantum Trotter Circuit

3.1. Hamiltonian in Quantum Mechanics

“Hamiltonian solution” typically refers to finding the eigenvalues and eigenvectors of a Hamiltonian operator, which describes the total energy of a system. A Hamiltonian is a mathematical operator that corresponds to the total energy of a system, encompassing both kinetic and potential energies. Solving the Hamiltonian involves finding its eigenvalues (possible energy levels of the system) and eigenvectors (quantum states corresponding to those energy levels).

3.2. Trotter-Suzuki Decomposition

The Trotter-Suzuki decomposition is a method to approximate the exponential of a sum of non-commuting operators. For a Hamiltonian $H$ that can be decomposed into a sum of simpler terms $\mathrm{H}=\mathrm{H}1+\mathrm{H}2+\cdots +\mathrm{H}\mathrm{n}$, the time evolution operator $e^{-\mathrm{i}\mathrm{H}\mathrm{t}}$ can be approximated as: $e^{-\mathrm{i}H\mathrm{t}}\approx e^{\frac{-iH1t}{ne}}{e}^{\frac{-iH2t}{ne}}\dots e^{\frac{-iHnt}{ne}}$ as $\mathrm{n}\to \mathrm{\infty }.$ This allows the complex exponential to be broken down into a sequence of simpler operations, each involving only one part of the Hamiltonian.

3.3. Trotterization

In quantum computing, Trotterization is a method used to approximate the evolution of a quantum system over time by decomposing the time evolution operator into a series of small, discrete steps [18]. This approach is particularly useful for simulating complex quantum systems which are difficult to solve analytically. Several Trotterization techniques have been developed to improve the accuracy and efficiency of quantum simulations:

First-Order Trotterization: This technique involves dividing the time interval into equal subintervals and applying the Trotter-Suzuki decomposition with only one Trotter step (m = 1) [19].

Higher-Order Trotterization: Higher-order Trotterization methods utilize multiple Trotter steps (m > 1) to achieve higher accuracy. By incorporating additional terms in the Trotter-Suzuki expansion, higher-order methods reduce the Trotterization error [20].

Adaptive Trotterization: Adaptive Trotterization techniques dynamically adjust the number of Trotter steps based on the local properties of the Hamiltonian. This adaptive approach optimizes the trade-off between accuracy and computational cost [21].

3.4. Quantum Trotter Circuit (QTC)

For this study, a Trotter circuit is a quantum circuit that implements the Trotter-Suzuki decomposition. It breaks down the unitary evolution $e^{-iHt}$ into a series of gates that correspond to the simpler exponentials $e^{iHkt/n}$. This allows the quantum computer to simulate the evolution of a quantum system under a Hamiltonian by applying a sequence of simpler quantum gates.

QTC is a quantum circuit designed to approximate the time evolution operator of a quantum system by iteratively applying smaller unitary operators [18,19,20,21]. Let H(t) denote the time-dependent Hamiltonian of the quantum system. The time evolution operator U(t) corresponding to H(t) can be expressed as follows:

$$U\left(t\right)=e^{-iH\left(t\right)}$$

(3)

The Trotter-Suzuki decomposition approximates $U\left(t\right)$ as a product of $n$ commuting operators:

$$\mathrm{U}(\delta t) \approx e^{-\mathrm{i}\mathrm{H}1 \mathsf{\delta }\mathrm{t}}{e}^{-\mathrm{i}\mathrm{H}2 \mathsf{\delta }\mathrm{t}}\dots e^{-\mathrm{i}\mathrm{H}\mathrm{n} \mathsf{\delta }\mathrm{t}}$$

(4)

where the time step $\delta t=\frac{t}{n}$, and $H1,H2,..., Hn$ are the components of the Hamiltonian. The Trotterization error decreases with decreasing $\delta t.$

Algorithm 1 constructs Trotter circuits iteratively based on two parameters, number of qubits and number of Trotter steps. It initializes by defining the number of qubits and creates a quantum circuit object to build the Trotter layer. It then proceeds to construct each Trotter circuit by iterating through defined Trotter steps. For each step, a new quantum circuit object is created. Within each circuit construction loop, Rx gates with a specified angle are applied to all qubits, followed by CNOT gates between selected qubit pairs and Rz gates with predefined angles applied to specific qubits. This sequence is repeated for each increment of circuit depth. The resulting Trotter circuit for each iteration is appended to a list. Finally, the algorithm measures the final state of each circuit. It returns the list of constructed Trotter circuits, each tailored to simulate the time evolution of a Hamiltonian through sequential approximations using quantum gates.

Algorithm 1: Constructing Trotter Circuits

Require: $n_{\mathrm{q}\mathrm{u}\mathrm{b}\mathrm{i}\mathrm{t}\mathrm{s}}$, $N_{\mathrm{T}\mathrm{r}\mathrm{o}\mathrm{t}\mathrm{t}\mathrm{e}\mathrm{r}\mathrm{s}\mathrm{t}\mathrm{e}\mathrm{p}\mathrm{s}}$ Initialization (1–2) 1: Define the number of qubits: $n_{\mathrm{q}\mathrm{u}\mathrm{b}\mathrm{i}\mathrm{t}\mathrm{s}}$ 2: Create a Quantum circuit object for the Trotter layer Construct Trotter circuits (3–14) 3: for i = 1 to $N_{\mathrm{T}\mathrm{r}\mathrm{o}\mathrm{t}\mathrm{t}\mathrm{e}\mathrm{r}\mathrm{s}\mathrm{t}\mathrm{e}\mathrm{p}\mathrm{s}}$ do 4:    Create a new Quantum Circuit object for the Trotter circuit 5:    for j = 1 to i do 6:      Apply Rx gates with angle 0.1 to all qubits 7:      Apply CNOT gates between qubits 0 and 1, and qubits 2 and 3 8:      Apply Rz gate with angle −0.2 to qubits 1 and 3 9:      Apply CNOT and then Rz gates 10:   end for 11:   Append the Trotter circuit to the list of Trotter circuits 12:   Measure the final state of the circuit 13:   end for 14: return Final Trotter circuits

Simulating quantum Trotter circuits on a quantum computer is crucial because it enables the efficient approximation of the exponential of a Hamiltonian operator. This task is computationally intensive on classical hardware. The Trotter-Suzuki decomposition breaks down the exponential of a sum of non-commuting Hamiltonian terms into a sequence of simpler operations. On a classical computer, this process involves significant computational overhead due to the need for high-precision matrix exponentiation and manipulation, often requiring techniques such as diagonalization or numerical integration. The classical methods, although effective for small systems, become infeasible for larger quantum systems due to the exponential growth of the Hilbert space with the number of particles or qubits. Consequently, simulating these circuits on a quantum computer not only aligns naturally with the quantum nature of the problem but also leverages quantum parallelism and entanglement to perform these calculations exponentially faster, thereby making the simulation of complex quantum systems and their time evolution tractable.

Trotter circuits and their modifications with different depths and gates are designed so that error analysis could be thoroughly investigated. The quantum circuit constructed in Figure 4a–e consists of a Trotter layer as defined in Algorithm 1. Each subfigure (a) through (e) corresponds to circuits with 1, 2, 3, 4, and 5 Trotter steps, respectively. These circuits are constructed by implementing the Trotter layer defined in Algorithm 1. The quantum circuit in each subfigure uses a total of 4 qubits, with multiple Trotter layers repeated to simulate the time evolution of a quantum system. Each iteration in the circuit represents a discrete time step, enabling the simulation of quantum dynamics over several intervals for a more accurate depiction of the system’s behavior. ${TC}_1$ with 1 Trotter step (shown in Figure 4a): depth is 7 containing 13 gates, ${TC}_2$ with 2 Trotter steps (shown in Figure 4b): depth is 14 containing 26 gates, ${TC}_3$ with 3 Trotter steps (shown in Figure 4c): depth is 21 containing 39 gates, ${TC}_4$ with 4 Trotter steps (shown in Figure 4d): depth is 28 containing 52 gates, and ${TC}_5$ with 5 Trotter steps (shown in Figure 4e): depth is 35 containing 65 gates. The percentage increase in the number of gates and depth between each successive Trotter circuit is consistent at 100% with respect to TC₁. One important point is that depth means number of sequence for applying gates. This linear scaling shows the growing complexity with each additional Trotter step, making classical simulation impractical due to exponential computational growth. Quantum computers, however, can handle this increased complexity more efficiently through parallelism and entanglement, solving these problems in a feasible time frame compared to classical methods.

4. Error Mitigation Techniques

Error mitigation techniques play a crucial role in improving the performance of quantum circuits on quantum computers [22]. By applying techniques such as DD, T-REx, ZNE and others, it is possible to mitigate the adverse effects of errors, particularly measurement errors, which are common in NISQ devices. When applied to Trotter circuits, these error mitigation techniques help to improve the accuracy and reliability of quantum computations performed on quantum computers, leading to more consistent and reliable results. The details of applied error mitigation techniques are discussed below.

4.1. Dynamic Decoupling

DD is a technique used to mitigate measurement errors in quantum circuits as depicted in Algorithm 2. It involves the application of sequences of pi-pulses at specific time intervals. These pulses flip the qubit’s state, effectively mitigating the noise and measurement errors [23]. By carefully designing the timing and sequence of these pulses, DD can significantly improve the reliability of quantum computations, especially in the presence of noisy environments. Mathematically, DD can be represented by the application of a sequence of pulses, at regular intervals τ:

$$DD\approx f\left(\mathrm{X}\mathrm{k}\right(\mathsf{\alpha }\left)\right)=f\left(exp\left(-i\left(\mathsf{\alpha }/2\right)k\right)\right)$$

(5)

where X is the Pauli-X operator, and $\mathsf{\alpha }$ is the angle of rotation around axis k and the total number of pulses applied depends upon the application/circuit under consideration. This sequence effectively introduces a series of perturbations that counteract the accumulation of noise and measurement errors over time.

DD serves as a potent tool for mitigating measurement errors by continuously “resetting” the qubit’s state throughout the computation. This continual intervention helps to suppress the influence of environmental noise and fluctuations, thereby enhancing the fidelity of measurement outcomes. Additionally, the flexibility in designing the timing and composition of pulse sequences allows for tailored error mitigation strategies that can adapt to specific quantum circuit architectures and noise profiles. Algorithm 2 shows the detailed steps of DD applied to reduce measurement error on IBM_O and IBM_K. This algorithm aims to mitigate decoherence effects in quantum systems by applying a series of control pulses. It begins by initializing the qubits to a known state. Over N iterations, for each qubit i, it applies a pulse π to flip the qubit’s state, waits for a duration τ to allow environmental noise to accumulate, and then applies another pulse to reverse the state back. This sequence of operations effectively introduces periodic interruptions in the qubit evolution, reducing the impact of noise-induced phase errors that can degrade quantum information. By repeatedly applying these pulses, the algorithm aims to extend the coherence time of the qubits, thereby preserving quantum states and enhancing the reliability of quantum computations. The final output is the decoupled quantum state |φ⟩, which ideally retains its coherence for a longer duration compared to unmitigated systems.

Algorithm 2: Dynamic Decoupling Algorithm

Require: $n_{\mathrm{q}\mathrm{u}\mathrm{b}\mathrm{i}\mathrm{t}\mathrm{s}},$N$\mathrm{Number} \mathrm{of} \mathrm{pulses}, \tau$ Pulse duration    Initialization (1) 1: Apply initial state preparation to the qubits DD to prepared state (2–7) 2: for i = 1 to N do 3:     Apply a $\pi$-pulse to each qubit 4:     Wait for a duration of $\tau$ 5:     Apply another $\pi$-pulse to each qubit 6: end for 7: return Decoupled $|\varnothing$ ⟩

4.2. Twirled Readout Error Extinction (T-REx)

T-REx, an error mitigation technique, uses Pauli twirling to diminish the noise induced during the quantum measurement process, assuming no specific form of noise, rendering it highly versatile and efficient [24]. T-REx helps to mitigate measurement errors by introducing diversity in the quantum state prior to measurement, thereby reducing the impact of systematic errors associated with the readout process. By “twirling” the quantum state, T-REx effectively spreads out the probability distribution of measurement outcomes, making it less susceptible to biases and inaccuracies in the measurement apparatus. One notable advantage of T-REx is its versatility and adaptability to different quantum computing architectures and error models. The randomized nature of the twirling operation allows for flexible implementation strategies that can be tailored to specific hardware configurations and noise profiles. Algorithm 3 shows the detailed steps of T-REx applied to reduce measurement error on IBM_O and IBM_K. This algorithm is designed to mitigate readout errors in quantum computing systems using a statistical approach. It operates on qubits and involves two sets of data: $f\left(\rho 0\right)$, which represents measurements of the zero state with randomized bit flips, and $f\left(\rho \right)$, which represents measurements of the desired (potentially noisy) quantum state with the same randomized bit flips. Over N iterations, the algorithm calculates a figure of merit $f\left(\rho 0\right)$ for the zero state data and $f\left(\rho \right)$ for the desired state data before measurement. It then computes the ratio $\frac{f\left(\rho 0\right) }{f\left(\rho \right)}$ to quantify the difference between the desired and measured states, thereby correcting for systematic errors introduced during measurement. By iterating this process, the algorithm aims to improve the accuracy of quantum state measurements by statistically adjusting the observed outcomes based on the relative probabilities derived from the initial data sets $f(\rho 0$) and $f\left(\rho \right)$. The corrected measurement outcome is returned, providing a more reliable representation of the intended quantum state despite the presence of readout errors.

Algorithm 3: Twirled Readout Error Extinction Algorithm

Require: $n_{\mathrm{q}\mathrm{u}\mathrm{b}\mathrm{i}\mathrm{t}\mathrm{s},}$${\rho }_0$: Data for the zero state with randomized bit flips, $\rho$: Data for the desired (noisy) state with randomized bit flips. 1: for i = 1 to N do: 2:    Calculate f(${\rho }_0$) for the zero state data—before measurement 3:    Calculate f($\rho$) for the desired state data—before measurement 4:    Compute the ratio $\frac{\mathrm{f}\left(\rho \right)}{\mathrm{f}\left({\rho }_0\right)}$ 5: end for 6: return Corrected measurement outcome

4.3. Zero-Noise Extrapolation

This involves computing the expectation value at various noise levels and extrapolating the ideal expectation value to the zero-noise limit [25]. ZNE facilitates the mitigation of measurement errors by effectively “correcting” for the distortions introduced by noise in the measurement process. By extrapolating measurement outcomes to a noise-free regime, ZNE provides a more accurate representation of the underlying quantum state, thereby reducing the impact of measurement errors as shown in Algorithm 4. This algorithm aims to estimate the ideal expectation value ⟨ϕ∣O∣ϕ⟩ of an observable O in a quantum system by leveraging data obtained from multiple noise levels. The algorithm initializes by defining the number of qubits n, setting the number of noise levels N, and choosing an extrapolation model f (⋅). In Step 1, noise scaling techniques are applied to increase the noise levels in the quantum system intentionally. This results in obtaining noisy expectation values for O across different levels of noise. In Step 2, the algorithm fits the chosen extrapolation model f (⋅) to the measured noisy expectation values. By extrapolating these values to the noiseless limit (zero noise), the algorithm estimates the ideal expectation value ⟨ϕ∣O∣ϕ⟩ under ideal conditions. This approach helps to mitigate the impact of noise in quantum computations, allowing for more accurate predictions of quantum states and observables even in the presence of significant environmental disturbances. One of the key advantages of ZNE is its ability to adapt to different noise profiles and error sources encountered in quantum computing systems, thereby optimizing the mitigation of measurement errors.

Algorithm 4: Zero-noise Extrapolation Algorithm

Require: $n_{\mathrm{q}\mathrm{u}\mathrm{b}\mathrm{i}\mathrm{t}\mathrm{s}}$, Number of noise levels N, Extrapolation model f(.) Ensure Estimated ideal expectation value $<\varnothing | \mathrm{O} | \varnothing >$ Initialization (1–3) 1: Define the number of qubits: n 2: Set the number of noise levels: N 3: Choose an extrapolation model: f(.) Step 1: Intentionally scale noise (4–5) 4: Apply noise scaling techniques to increase noise levels 5: Obtain noisy expectation values for different noise levels Step 2: Extrapolate to the noiseless limit (6–8) 6: Fit the extrapolation model f(.) to the measured noisy expectation values 7: Estimate the ideal expectation value $<\varnothing | \mathrm{O} | \varnothing >$ at zero noise using the fitted model 8: return Estimated ideal expectation value $<\varnothing | \mathrm{O} | \varnothing >$

4.4. Techniques Comparison

The comparison of methods mentioned in

Table 2. Theoritical Comparison of Error Mitigation Techniques.

Aspect	Dynamic Decoupling	Twirled Readout Error Extinction	Zero-Noise Extrapolation
Concept	Applies sequences of pi-pulses to mitigate noise	Introduces randomness via Pauli twirling to reduce readout errors	Extrapolates expectation values to zero-noise limit
Applicability	Effective in noisy environments and for long coherence times	Versatile across different quantum computing architectures	Adaptable to various noise profiles and error sources
Implementation Flexibility	Requires precise timing and sequence design of pi-pulses	Flexible due to randomized nature of Pauli twirling	Depends on accurate characterization of noise characteristics
Effectiveness	Effective in reducing decoherence and measurement errors	Efficient in spreading out probability distribution of outcomes	Effective in correcting distortions caused by noise
Quantum System Impact	Acts periodically to counteract noise accumulation	Introduces variability to mitigate systematic readout errors	Improves fidelity by extrapolating to noise-free conditions
Practical Complexity	Complex due to timing constraints and pulse sequence design	Moderate complexity in implementation, depends on hardware specifics	Complex in data processing and noise characterization

gives a brief overlook on mitigation techniques those enhances the accuracies of quantum computations in different scenarios. The core aim of researchers in quantum computation field is to stabilize quantum computations, aligning observed outcomes closer to theoretical predictions. The global expectation serves as a metric of success, reflecting the cumulative impact of error mitigation strategies on quantum algorithm performance. As quantum computing evolves towards practical applications, the requirement of refining quantum techniques becomes pivotal for achieving reliable and reproducible results essential for advancing quantum technology across scientific, industrial, and computational domains.

5. Results

QTCs comprises four qubits in total, and each Trotter layer is iteratively replicated/modified to generate a sequence of Trotter circuits. Trotter circuits are shown in Figure 4a–e as TC₁, TC₂, TC₃, TC₄ and TC₅. Each of the circuits TC₁–TC₅ have been implemented on both of quantum hardware, i.e., IBM_O & IBM_K with and without three error mitigation techniques. Additionally, all Trotter circuits TC₁–TC₅ have been simulated on the IBM QASM simulator (${SIM}_{IBMQ}$). Each iteration corresponds to a time step in the quantum system’s evolution, as depicted in Figure 5 illustrating the quantum circuit at each Trotter step. Figure 5a–c depicts the results related to IMB_K and Figure 5d–f presents results corresponding to IBM_O. Each of the subfigures in Figure 5 contains estimator value results related to ${SIM}_{IBMQ}$ in black for each step corresponding to TC₁–TC₅ respectively against state <zzzz>. The results of Trotter circuits running on IBM_K & IBM_O without mitigation techniques are shown in red (Figure 5a–e). Similarly, Trotter circuits run on IBM_K & IBM_O with mitigation techniques (DD, T-REx & ZNE) are shown in light blue, yellow orange, and purple (Figure 5a–c) and in blue, green and purple (Figure 5d–f), respectively. As we progress from TC₁ to TC₅, there is a noticeable increase in the percentage difference of the estimator value results across all cases, indicating a rise in error levels with the complexity of the circuits, as displayed by Figure 6, Figure 7, Figure 8, Figure 9 and Figure 10 and

Table 3. Results Obtained After Ideal Simulator $R_{IS}$, IBM_K and IBM_O.

Parameters	${\mathit{R}}_{\mathit{I}\mathit{S}}$	RKN	RKDD	RKT-REx	RKZNE	RON	RODD	ROT-REx	ROZNE
${\mathit{E}\left(\mathit{X}\right)}_{{\mathit{T}\mathit{C}}_1}$	0.982	0.156	0.318	0.813	0.25	0.628	0.686	0.7945	0.7586
${\mathit{E}\left(\mathit{X}\right)}_{{\mathit{T}\mathit{C}}_2}$	0.936	0.134	0.224	0.363	0.11	0.358	0.508	0.4704	0.4626
${\mathit{E}\left(\mathit{X}\right)}_{{\mathit{T}\mathit{C}}_3}$	0.836	0.13	0.168	0.3	0.137	0.166	0.354	0.168	0.1684
${\mathit{E}\left(\mathit{X}\right)}_{{\mathit{T}\mathit{C}}_4}$	0.762	0.018	0.114	0.292	0.023	0.05	0.21	0.0648	0.079
${\mathit{E}\left(\mathit{X}\right)}_{{\mathit{T}\mathit{C}}_5}$	0.626	0.012	0.04	0.015795	0.03016	0.044	0.136	0.01	0.0132
${\mathit{E}\left(\mathit{X}\right)}_{{\mathit{T}\mathit{C}}_{\mathit{a}\mathit{v}\mathit{g}}}$	0.8284	0.09	0.1728	0.356759	0.110032	0.2492	0.3788	0.30154	0.29636
${{\mathit{\sigma }}^2}_{\mathit{T}\mathit{C}1}$	0.03567	0.982044	0.898876	15.183124	0.949824	0.0591	0.6056	0.5294	0.4567
${{\mathit{\sigma }}^2}_{\mathit{T}\mathit{C}2}$	0.1239	0.9831	0.949824	15.712896	0.96	0.1828	0.8718	0.742	0.8234
${{\mathit{\sigma }}^2}_{\mathit{T}\mathit{C}3}$	0.3011	0.999676	0.971776	15.754814	0.979836	0.2638	0.9724	0.8747	0.9156
${{\mathit{\sigma }}^2}_{\mathit{T}\mathit{C}4}$	0.41935	0.999856	0.987004	15.759492	0.96	0.31358	0.88908	0.8167	0.83874
${{\mathit{\sigma }}^2}_{\mathit{T}\mathit{C}5}$	0.60812	0.999856	0.9984	15.844637	0.96	0.4642	0.9975	0.9559	0.9987
${{\mathit{\sigma }}^2}_{\mathit{T}\mathit{a}\mathit{v}\mathit{g}}$	0.29762	0.9929064	0.961176	15.650993	0.961932	0.25669	0.86727	0.78374	0.80662

.

5.1. Metrics to Evaluate Quantum Trotter Circuit Results

To evaluate QTC results, the percentage difference is calculated for both expected values and variances using formulas mentioned in Equations (6)–(11). For estimator value results, the formula compares result between ${SIM}_{IBMQ}$ and IBM Quantum Computers IBM_O/IBM_K (${IBM}_{QC}$) as well as results with no mitigation and those with error mitigation techniques. Similarly, for variances, the percentage difference is computed using the same comparisons. These formulas enable quantitative assessment of the effectiveness of error mitigation techniques and the accuracy of quantum computations.

$$\%∆=\frac{\mid {E\left(X\right)}_{{Sim}_{IBMQ}}-{E\left(X\right)}_{{IBM}_{QC}}\mid }{{E\left(X\right)}_{{Sim}_{IBMQ}}}\times 100$$

(6)

$$\%∆=\frac{\mid {{\sigma }^2}_{{Sim}_{IBMQ}}-{{\sigma }^2}_{{IBM}_{QC}}\mid }{{{\sigma }^2}_{{Sim}_{IBMQ}}}\times 100$$

(7)

$$\%∆=\frac{\mid {E\left(X\right)}_{no mitigation}-{E\left(X\right)}_{error mitigation}\mid }{{E\left(X\right)}_{no mitigation}}\times 100$$

(8)

$$\%∆=\frac{\mid {{\sigma }^2}_{no mitigation}-{{\sigma }^2}_{error mitigation}\mid }{{{\sigma }^2}_{no mitigation}}\times 100$$

(9)

$$\%∆=\frac{\mid {E\left(X\right)}_{{Sim}_{IBMQ}}-{E\left(X\right)}_{error mitigation}\mid }{{E\left(X\right)}_{{Sim}_{IBMQ}}}\times 100$$

(10)

$$\%∆=\frac{\mid {{\sigma }^2}_{{Sim}_{IBMQ}}-{{\sigma }^2}_{error mitigation}\mid }{{{\sigma }^2}_{{Sim}_{IBMQ}}}\times 100$$

(11)

5.1.1. CASE A—Ideal Simulator vs. Quantum Computers (IBM_O & IBM_K) Results without Error Mitigation Techniques

Figure 6 represents results of estimator value results (a) and variance (b) corresponding to ${SIM}_{IBMQ}$ (green bars) versus both IBM_O (blue bars) and IBM_K (red bars). The percentage difference of estimator value results and variances are shown in teal (${SIM}_{IBMQ}$ vs. IBM_O) and purple (${SIM}_{IBMQ}$ vs. IBM_K) lines utilizing Equations (6) and (7), respectively. These results generally show smaller deviations from the ${SIM}_{IBMQ}$ compared to IBM_O as shown in Figure 6, with a percentage difference ranging from 4.47% to 94.73% for expectations and 12.38% to 65.14% for variances. IBM_K results exhibit larger difference, ranging from 25.84% to 94.73% for expectations and 25.34% to 637.37% for variances. Although IBM_O performs better in expectation values as compared with IBM_k, n general, both quantum computers demonstrate significant discrepancies from the ${SIM}_{IBMQ}$.

5.1.2. CASE B—Ideal Simulator vs. IBM_k Results with Error Mitigation Techniques

Figure 7 depicts results of estimator value results (a) and variance (b) corresponding to ${SIM}_{IBMQ}$ (green bars) versus three mitigation techniques: DD (mint green bars), T-REx (coral pink bars) and ZNE (mustard yellow bars) applied after each TC₁–TC₅ on IBM_K. The percentage difference of estimator value results (Figure 7a,b) are shown in navy blue line (${SIM}_{IBMQ}$ vs. IBM_k with DD technique), dark green line (${SIM}_{IBMQ}$ vs. IBM_k with T-REx technique) and dark red line (${SIM}_{IBMQ}$ vs. IBM_k with ZNE technique) utilizing Equations (10) and (11). In Case B, substantial improvements are evident as shown in Figure 7. In general comparison of IBM_k results with DD, T-REx & ZNE implementation versus ${SIM}_{IBMQ}$, has shown percentage difference ranges [67.59 93.58], [17.20 97.48] & [74.52 96.99] respectively for expectation values and [64.18 2404.42], [57.95 384.84] & [54.46 600.16] respectively. For Trotter Circuits on IBM_k, ZNE technique yielded lowest average expectation value of 0.110032 and T-REx technique has shown lowest % difference of 60.28% among other mitigation techniques. Similarly, the variance comparison shows that, ZNE technique yielded lowest average variance value of 0.1100384 and lowest % difference of 187.37%. Therefore, T-Rex technique improves estimator results more closer to simulator value and ZNE technique enhances variance value approaching simulator value.

5.1.3. CASE C—IBM Kyoto Results without Error Mitigation vs. Error Mitigation Techniques

Figure 8 depicts results of estimator values and variance corresponding to IBM_K with and without error mitigation techniques. The estimator result (Figure 8a) and variance (Figure 8b) values without mitigation techniques are shown in carrot orange bars, and estimator result values are shown after applying mitigation techniques DD (mint green bars), T-REx (coral pink bars) and ZNE (corn yellow bars) implemented after each TC₁-TC₅ on IBM_K. The percentage differences of estimator result (Figure 8a) and variance (Figure 8b) are shown in navy blue line (IBM_k without mitigation technique vs. IBM_k with DD technique), green line (IBM_k without mitigation technique vs. IBM_k with T-REx technique) and dark red line (IBM_k without mitigation technique vs. IBM_k with ZNE technique) utilizing Equations (8) and (9). In general comparison of IBM_k results with and without error mitigation techniques, DD, T-REx & ZNE has shown percentage difference ranges [29.23 533.3], [31.63 1522.22] & [5.38 151.33] respectively for expectation values and [0.14 8.47], [1444.41 1584.02] & [2.01 3.90] respectively for variance values. These results show that implemented mitigation techniques has major difference with results produced without mitigation techniques.

5.1.4. CASE D—Ideal Simulator vs. IBM Osaka Results with Error Mitigation Techniques

Figure 9 depicts results of estimator values (a) and variance (b) corresponding to ${SIM}_{IBMQ}$ (green bars) versus three mitigation techniques: DD (light pink bars), T-REx (purple bars) and ZNE (navy blue bars), applied after each TC₁-TC₅ on IBM_O. The percentage differences of estimator result (Figure 9a) and variance (Figure 9b) are shown in navy blue line (${SIM}_{IBMQ}$ vs. IBM_O with DD technique), green line (${SIM}_{IBMQ}$ vs. IBM_O with T-REx technique) and dark red line (${SIM}_{IBMQ}$ vs. IBM_O with ZNE technique) utilizing Equations (10) and (11). In general comparison of IBM_O results with DD, T-REx & ZNE implementation versus ${SIM}_{IBMQ}$, has shown percentage difference ranges [30.11 78.26], [19.04 115.37] & [22.75 97.89] respectively for expectation values and [64.17 1596.47], [57.28 1388.60] & [64.45 1179.05] respectively for variance values. For Trotter Circuits on IBM_O, ZNE technique yielded lowest average expectation value of 0.29636 and DD technique has shown lowest % difference of 56.82% among other mitigation techniques. Similarly, the variance comparison shows that, T-REx technique yielded lowest average variance value of 0.78374 and ZNE has lowest % difference of 422.68%. Therefore, DD technique improves estimator results more closer to simulator value and T-Rex (compared to others) technique enhances variance value approaching simulator value.

5.1.5. CASE E—IBM Osaka Results without Error Mitigation vs. Error Mitigation Techniques

Figure 10 depicts results of estimator result values and variance corresponding to IBM_O with and without error mitigation techniques. The estimator result (Figure 10a) and variance (Figure 10b) values without mitigation techniques are shown in scarlet red bars while expected values are shown after applying mitigation techniques DD (light pink bars), T-REx (purple bars) and ZNE (blue bars) implemented after each TC₁-TC₅ on IBM_O utilizing Equations (8) and (9). In general comparison of IBM_O results with and without error mitigation techniques, DD, T-REx & ZNE has shown percentage difference ranges [9.24 320], [1.20 318.18] & [1.44 70.91] respectively for expectation values and [115.61 924.05], [106.78 796.94] & [115.76 673.90] respectively for variance values. These results show that implemented mitigation techniques has major difference with results produced without mitigation techniques.

6. Discussion

The following points can be summarized after going through the results collected and analyzed.

Disparity in Performance: The substantial differences observed between the results from the ideal simulator and the real quantum computers without error mitigation techniques may be due to various factors. These could include inherent noise and imperfections in the physical quantum hardware, environmental disturbances during computation, and limitations in qubit connectivity and coherence times [26]. QTC based upon Hamiltonian [27] are potential candidate for error mitigation analysis.

Most Effective Error Mitigation Technique: Among the error mitigation techniques applied to IBM_K and IBM_O, ZNE appears to be the most effective in improving the expected values. Significant improvements are observed in the expectation values after applying ZNE compared to DD and TRE-x, indicating its superior error suppression capability. But in general, the selection of error mitigation technique depends upon several factors for example circuit design, circuit depth, type of gates utilized and quantum hardware nature.

Variance Analysis: Analysis of the variances across different parameters suggests varying degrees of stability and reliability among the error mitigation techniques. T-REx consistently demonstrates lower variances compared to DD and ZNE, indicating better error suppression and improved stability in quantum computations.

Performance Comparison: When comparing the error mitigation techniques applied to the quantum computers IBM_K and IBM_O, the results indicate that IBM_O shows more closer results with ideal simulator both in expected values and variances based upon their average values related to all QTCs.

Effectiveness Across Parameters: While error mitigation techniques generally improve both the expected values and variances, there are instances where certain techniques are less effective. Factors contributing to these variations may include the specific error sources prevalent in each parameter, the complexity of the quantum circuit, and the compatibility of the error mitigation technique with the given quantum computer [28].

Recommended Error Mitigation Technique: For IBM_K, T-REx is better performing due to reason that it improves the results closer to ${SIM}_{IBMQ}$ as compared to other mitigation techniques. Similarly, For IBM_O, DD is better performing due to reason that it improves the results closer to ${SIM}_{IBMQ}$ as compared to other mitigation techniques.

Implications for the NISQ Era: These findings underscore the challenges and opportunities in harnessing the potential of quantum computers in the NISQ era. While error mitigation techniques offer significant improvements in computation accuracy, further research and advancements are needed to address the complexities of quantum hardware and enhance the robustness of quantum computations [29].

In Table 3, expected values and variances are presented by $E \left(X\right)$ and ${\sigma }^2$, respectively, with subscript corresponding to Trotter circuits TC₁, TC₂, TC₃, TC₄ and TC₅. The results obtained on ${SIM}_{IBMQ}$ are represented by $R_{IS}$ in column 1, results obtained on IBM_K with no error mitigation are represented by R_KN and after error mitigation techniques are represented by R_KDD, R_KT-REx and R_KZNE, results obtained on IBM_O with no error mitigation are represented by R_ON and after error mitigation techniques are represented by R_ODD, R_OT-REx and R_OZNE.

7. Conclusions

This study explores the effectiveness of error mitigation techniques in improving the performance of quantum circuits on quantum computers, especially for NISQ devices. Through extensive experimentation and analysis, significant enhancements in the accuracy of quantum computations on IBM_K and IBM_O with implementation of these techniques was observed. Trotter circuits exhibit varying degrees of error, as evidenced by their expectation values and variances. The comparison results with ideal simulator (having expected result value 0.8284) shows that T-Rex has improved results on IBM Kyoto and enhanced average expected result value from 0.09 to 0.35. Similarly, DD has improved average expected result values from 0.2492 to 0.3788. These advancements pave the way for more practical and efficient quantum computing applications in the NISQ era, bringing us closer to realizing the full potential of quantum technologies across various domains. Future work includes focus on the integration of advanced error mitigation techniques with scalable quantum algorithms to further enhance computational accuracy. Additionally, the development of hybrid quantum-classical approaches will offer new avenues for mitigating errors and optimizing quantum computations.