Unleashing quantum algorithms with Qinterpreter: bridging the gap between theory and practice across leading quantum computing platforms

Using qinterpreter

Installation and backends

Python was selected as the development platform for the Qinterpreter library due to its straightforward installation process and recognition as a common language supported by leading companies in the quantum industry. This decision is reinforced because the five quantum libraries and their full-stack simulation packages are in Python. Besides, the simplicity of installation is apparent, requiring just a straightforward PIP install command, making it accessible to a diverse user base. All five libraries seamlessly integrate into their respective locations, allowing users to utilize them effortlessly by following the provided instructions in this section.

Depending on the user’s requirements, we offer three installation options to successfully run the Qinterpreter on your local computer. The first method involves cloning the library folder directly from the GitHub repository (Contreras Sepulveda & Contributors, 2023). Once you’ve downloaded the Qinterpreter, you can use the library locally by calling the classes and functions from the same directory.

The second alternative lets users install the Qinterpreter using the “pip install” command directly in the Jupyter console. This can be done by executing the following command in the Python console at the operating system’s shell prompt.

!pip install git+https://github.com/Qubithub/Qinterpreter.git

After the installation process is over, the next step involves importing the requisite libraries. To accomplish this, the users should utilize the following command code.

import math
from quantumgateway.quantum_circuit import QuantumCircuit, QuantumGate
from quantumgateway.quantum_translator.braket_translator import BraketTranslator
from quantumgateway.quantum_translator.cirq_translator import CirqTranslator
from quantumgateway.quantum_translator.qiskit_translator import QiskitTranslator
from quantumgateway.quantum_translator.pennylane_translator import PennyLaneTranslator
from quantumgateway.quantum_translator.pyquil_translator import PyQuilTranslator
from quantumgateway.main import translate_to_framework, simulate_circuit

To ensure the proper functionality of the Qinterpreter, the user must consider appropriate versions of the multiple libraries. Table 1 provides a list of these libraries and their corresponding versions.

Table 1:

Quantum libraries and their respective versions.

Library	Version
Qiskit	Qiskit Terra: 0.23.2
	Qiskit Aer: 0.12.0
	Qiskit IBMQ Provider: 0.20.2
	Qiskit: 0.42.0
	Qiskit Nature: 0.6.0
Pennylane	0.29.1
Cirq	0.9.1
Pyquil	3.3.4
Amazon-Braket	1.36.4

DOI: 10.7717/peerj-cs.2318/table-1

To cover these requirements, please follow the installation instructions provided below:

1. Qiskit: Install by running the command “pip install qiskit”.

2. Pennylane: Install by running the command “pip install pennylane”.

3. Cirq: Install by running the command “pip install cirq”.

4. Pyquil: Install by running the command “pip install pyquil”.

5. Amazon-Braket: Install by running the command “pip install amazon-braket-sdk”.

Additionally, ensure that your Python and pip versions are up to date. Some packages may require Python 3.6 or later.

The third option involves using our website platform Qubithub.org (https://qubithub.org/), which offers a user-friendly environment for executing Qinterpreter online by visiting the Login page, as shown in Fig. 1.

Users are introduced to a pre-configured application environment with the necessary libraries already installed, removing the need for manual installation. The user credentials can be obtained by contacting the team. After logging in, the next step involves importing the libraries, as was previously mentioned. This streamlined process allows users to focus more on running their quantum circuits and less on the setup.

Qinterpreter functions

This section presents a detailed overview of the functions employed within the Qinterpreter library. Our primary objective is to provide users with a comprehensive guide and extensive knowledge of the library’s functionalities and capabilities.

circuit = QuantumCircuit(nq,nc)

selected_framework = ′qiskit′
translated_circuit = translate_to_framework(circuit, 
selected_framework)

translated_circuit.print_circuit()

print(simulate_circuit(circuit, selected_framework))

circuit.add_gate(QuantumGate("MEASURE", [i,j]))

Bell’s states

In this first example, we simulate a basic quantum circuit that aims to generate one of the four Bell’s states. The Bell states are those maximally entangled, and arise from a superposition of the quantum bits’ basis states $|0⟩$ and $|1⟩$, defined by

(1) $$|{\psi }^{+}⟩={\displaystyle \frac{1}{\sqrt{2}}\left(|00⟩+|11⟩\right),}$$

(2) $$|{\psi }^{-}⟩={\displaystyle \frac{1}{\sqrt{2}}\left(|00⟩-|11⟩\right),}$$

(3) $$|{\phi }^{+}⟩={\displaystyle \frac{1}{\sqrt{2}}\left(|01⟩+|10⟩\right),}$$

(4) $$|{\phi }^{-}⟩={\displaystyle \frac{1}{\sqrt{2}}\left(|01⟩-|10⟩\right).}$$

These states can be emulated using quantum computers (Audretsch, 2007; Ou, 2007; Scully & Zubairy, 1997). In this case, we reproduce the most common one, “Bell state 00”, defined by the Eq. (1). To achieve this, we will use two specific gates: the Hadamard gate (H), used to put a qubit in a superposition state, and the Controlled-NOT (CNOT), a two-qubit gate that flips the state of a qubit based on the value of a control qubit. It is important to note that initially, it is necessary to follow the instructions in “Bell’s States”, which involve cloning the Qinterpreter repository and importing the required libraries. Once this is done, we will create a circuit with two qubits and two classical bits, as shown below:

n = 2
circuit = QuantumCircuit(n,n)

In this case, we import two quantum registers and two classical registers, as the creation of the first Bell state requires two quantum bits and two classical registers for the simulation. We can then add the gates described earlier to our circuit.

circuit.add_gate(QuantumGate("h", [0]))
circuit.add_gate(QuantumGate("cnot", [0, 1]))

where the two specific gates: the H gate to the first qubit (0), creates a superposition, making the state $\frac{1}{\sqrt{2}}\left(|00⟩+|01⟩\right)$, whereas the CNOT gate, with the first qubit, 0, as the control and the second qubit, 1, as the target. This entangles the qubits and creates the Bell state $|{\psi }^{+}⟩$.

To perform the simulation of our circuit, we implemented the measurement operation as follows:

   circuit.add_gate(QuantumGate("MEASURE", [0, 0]))
   circuit.add_gate(QuantumGate("MEASURE", [1, 1]))

Here, the measurement gates are added to the circuit for both qubits, indicating that the quantum state will be measured. Next, we choose the framework for displaying our simulation, and in our case, for the sake of simplicity, we initially opt for IBM’s Qiskit.

selected_framework = ′qiskit′ # Change this to the desired framework
translated_circuit = translate_to_framework(circuit, selected_framework)

To visualize the circuit and ensure it works correctly, we use the “print_circuit()” to print the circuit

translated_circuit.print_circuit()

Finally, we simulate the circuit using the following command:

print("The results of our simulated circuit are: ")
counts=simulate_circuit(circuit, selected_framework)
from qiskit.visualization import plot_histogram
plot_histogram(counts, title ="Histogram of Quantum States")

Results of the bell state circuit

We are going now analyze the results from our previous circuit, as presented in Table 4. In each column of the table, we find the framework name used, the circuit obtained through printing on each framework, and the outcomes of the simulations conducted within each framework.

Table 4:

Presents the results of "Bell state 00" within each of the five different frameworks.

Framework	Framework graph	Simulation
Qiskit		The results of our simulated circuit are: {‘00’: 504, ‘11’: 520}
Cirq		The results of our simulated circuit are: {‘11’: 523, ‘00’: 477}
Pennylane		The results of our simulated circuit are: {‘00’: 521, ‘11’: 479}
Amazon-Braket		The results of our simulated circuit are: {‘00’: 490, ‘11’: 510}
Pyquil		The results of our simulated circuit are: Counter ({‘00’: 51, ‘11’: 49})

DOI: 10.7717/peerj-cs.2318/table-4

The first part: ‘00’: 504 means: $|00⟩\to$Indicates that $|\mathrm{q}\mathrm{u}\mathrm{b}\mathrm{i}\mathrm{t}0⟩$ is in the state $|0⟩$, and the $|\mathrm{q}\mathrm{u}\mathrm{b}\mathrm{i}\mathrm{t}1⟩$ is in the state $|0⟩$ and the simulation process yielded this result 504 times. In the second segment, labeled ‘11’:520 means: $|11⟩\to$Indicates that $|\mathrm{q}\mathrm{u}\mathrm{b}\mathrm{i}\mathrm{t}0⟩$ is in the state $|1⟩$ and $|\mathrm{q}\mathrm{u}\mathrm{b}\mathrm{i}\mathrm{t}1⟩$ is in the state $|1⟩$, and the simulation process found that result 520 times. The results are visualized through the following histogram graph in Fig. 2.

A noteworthy observation concerning the preceding code is that it can be easily adapted to generate the “Bell State 01”, denoted as $|{\psi }^{-}⟩$, rather than the 00-state represented by $|{\psi }^{+}⟩$. This adjustment involves a minor modification in the gate sequence. Specifically, after applying the Hadamard gate to the first qubit, an X gate needs to be used to flip the state of the first qubit, resulting in the desired Bell State 01. The modified part of the code is provided below:

circuit.add_gate(QuantumGate("h", [0]))
circuit.add_gate(QuantumGate("x", [0]))
circuit.add_gate(QuantumGate("cnot", [0, 1]))

with these adjustments, and while keeping the remainder of the code unchanged, including the measurement and simulation steps, the code effectively gives the simulation of the desired entangled state. Additionally, to generate the “Bell State 10”, represented by $|{\phi }^{+}⟩$, an X gate must be applied to the second qubit after the Hadamard gate is applied to the first qubit. Finally, for the “Bell State 11”, denoted by $|{\phi }^{-}⟩$, an X gate must be applied to both qubits after the Hadamard gate is applied to the first qubit.

On the other hand, it is crucial to ensure the proper library for visualization is imported when examining the histogram section that illustrates the outcomes of each framework. These commands are explained in detail within the preloaded file “Bell States.ipynb,” available on the GitHub Qinterpreter page upon download (Contreras Sepulveda & Contributors, 2023). For a visual understanding of each qubit’s quantum state and operations, we have developed an automated function within Qinterpreter. In this instance, we employ the Bloch Sphere Visualization Function (bloch_sphere(circuit)). This function sequentially translates the circuit, conducts simulation, calculates the reduced density matrix, and visualizes qubit states on Bloch spheres (Ömer, 2009; IBM Quantum, 2023; Lu, Mia & Metcalf, 2005). This function emulates and extends similar functionalities offered by the Qiskit library. Consequently, it generates a Plotly interactive figure showcasing individual Bloch spheres for each qubit and their corresponding state vectors and markers. An illustrative example is provided below:

from quantumgateway.main import translate_to_framework, 
simulate_circuit, bloch_sphere
import math
circuit = QuantumCircuit(2,2) 
circuit.add_gate(QuantumGate("x", [0]))
circuit.add_gate(QuantumGate("x", [1]))
circuit.add_gate(QuantumGate("h", [1]))
circuit.add_gate(QuantumGate("cphase", [0, 1], [math.pi/4]))
bloch_sphere(circuit)

such an example involves a two-qubit circuit, where two consecutive X gates are applied to the first and second qubits. Following this, an H gate is applied to the second qubit, and a controlled-phase (CPhase) gate is applied between the first and second qubits, featuring a rotation angle of π/4. The resulting interactive Bloch sphere visualization is displayed upon executing the bloch_sphere function with the given circuit. The visualization depicts two spheres, each corresponding to one of the qubits in the circuit, as observed in Fig. 3. It effectively showcases the final state of the qubits in their respective spheres. It is essential to mention that one must install Plotly to use this function, which can be easily done with the command !pip install plotly.

Grover’s algorithm

In the second example, we explore a quantum search algorithm to locate an element within an unorganized list of elements. Grover’s algorithm (Grover, 1996; Perkowski, 2022) is renowned in quantum computing for its efficiency, surpassing classical search algorithms like the binary search algorithm (Knuth, 1998). Grover’s algorithm consists of three crucial steps:

• 1. First step: The initialization:

In this initial stage, our system is prepared to implement Grover’s algorithm. This involves bringing all the qubits into a superposition state by applying a Hadamard gate to each qubit. Consequently, the state of our system becomes:

(5) $$|s⟩=\frac{1}{\sqrt{N}}\sum _{x=0}^{N-1}|x⟩,$$where N is the total number of states.

• 2. Second step: Oracle application

Following the initialization, we apply an oracle to the element we intend to search. This is accomplished using a reflection operator $U_{\omega }$ on the target element. For example, if $|w⟩$ represents the element we are looking for, the oracle function reflects the state in a manner that designates it as the target:

(6) $${\mathrm{U}}_{\omega }|\mathrm{x}⟩=\{\begin{array}{c}|x⟩\mathrm{i}\mathrm{f}\mathrm{x}\ne \omega \\ -|x⟩\mathrm{i}\mathrm{f}\mathrm{x}=\omega \end{array}$$

Hence, if the searched element is $|w⟩$, its phase will be inverted.

• 3. Third step: Amplitude amplification

In the final step, we modify our quantum space by reflecting around the average amplitude $|w⟩$. This is achieved by applying the operator $U_s=2\left|s⟩⟨s\right|-\mathrm{I}$. Consequently, the amplitudes of all qubits are adjusted, except the state $|w⟩$, which undergoes amplification.

Now, let’s explore an example for a two-qubit system in our Qinterpreter library. We begin by importing the necessary libraries and modules and after then we start from the initial state $|\psi ⟩=|00⟩$, and apply H gates to each qubit to create a superposition state

(7) $$\left|\psi ⟩=H\right|00⟩={\displaystyle \frac{1}{2}\left(\left|00⟩+\right|01⟩+\left|10⟩+\right|11⟩\right),}$$in code, this initialization is implemented as:

circuit = QuantumCircuit(2, 2) 
for i in range(2):
      circuit.add_gate(QuantumGate("h", [i]))

Once our Hadamard gates are ready, we can apply an Oracle targeting the state $|11⟩$. The apply_oracle function adds gates to the circuit to create an Oracle focusing on the state $|11⟩$.

def apply_oracle(circuit):
      circuit.add_gate(QuantumGate("x", [0])) # Change qubit 0 to |1⟩
      circuit.add_gate(QuantumGate("x", [1])) # Change qubit 1 to |0⟩
      circuit.add_gate(QuantumGate("cphase", [0, 1], [-math.pi])) # 
Apply cphase with negative phase
      circuit.add_gate(QuantumGate("x", [0])) # Restore qubit 0 to |0⟩
      circuit.add_gate(QuantumGate("x", [1])) # Restore qubit 1 to |0⟩

In this case, we use an oracle for the state $|11⟩$ by using the cphase gate with an angle $-\pi$ as our oracle matrix $U_w$:

(8) $$U_w=\left(\begin{array}{cccc}1& 0& 0& 0\\ 0& 1& 0& 0\\ 0& 0& 1& 0\\ 0& 0& 0& -1\end{array}\right),$$

When applied to our system, we obtain

(9) $$\left|\psi ⟩=U_w\right|\psi ⟩={\displaystyle \frac{1}{2}\left(\left|00⟩+\right|01⟩+\left|10⟩-\right|11⟩\right),}$$

Subsequently, we apply the diffusion operator $U_d=2|s⟩⟨s|-I$, to increase the probability of our target state. The operation sequence is as follows:

• After Oracle application:

(10) $$|\psi ⟩={\displaystyle \frac{1}{2}\left[\begin{array}{c}1\\ 1\\ 1\\ -1\end{array}\right],}$$

• Applying the diffusion operator:

(11) $$|\psi ⟩\prime =D|\psi ⟩=\left[\begin{array}{cccc}0& 0.5& 0.5& 0.5\\ 0.5& 0& 0.5& 0.5\\ 0.5& 0.5& 0& 0.5\\ 0.5& 0.5& 0.5& 0\end{array}\right]\left[\begin{array}{c}1/2\\ 1/2\\ 1/2\\ -1/2\end{array}\right]=\left[\begin{array}{c}0.25\\ 0.25\\ 0.25\\ 0.75\end{array}\right],$$

As we observe, the $|11⟩$ state has the highest probability.

In code, the diffusion operator is implemented as follows:

# Function to add the Amplification Operator
def apply_amplification(circuit):
      # Apply Hadamard and X gates
      for i in range(2):
          circuit.add_gate(QuantumGate("x", [i])) # Apply X gates 
before Hadamard
           circuit.add_gate(QuantumGate("h", [i]))
# Sequence of gates for the Amplification Operator
      pi = math.pi
     circuit.add_gate(QuantumGate("cphase", [0, 1], [-pi])) # Adjustss
the phase of the cphase
# Apply Hadamard and X gates again
      for i in range(2):
           circuit.add_gate(QuantumGate("h", [i]))
           circuit.add_gate(QuantumGate("x", [i]))
# The previously defined functions apply_oracle and apply_amplification are called to apply 
# the Oracle and the Amplification Operator to the circuit 
apply_oracle(circuit)
apply_amplification(circuit)

We incorporate measurement gates and select the desired framework for executing our Grover algorithm. In Qinterpreter, this is accomplished through

#-----------------------------------------------------------------
# Measurement of Qubits
#-----------------------------------------------------------------
for i in range(2):
 circuit.add_gate(QuantumGate("measure", [i, i]))
# Measurement gates are added to measure the state of each qubit.
#-----------------------------------------------------------------
# Step 8) Simulating the Circuit and Printing the Result
#-----------------------------------------------------------------
# we can proceed to see what the quantum circuit looks like in Xanadu's PennyLane
selected_framework = ′pennylane′ # Change this to the desired framework
translated_circuit = translate_to_framework(circuit, selected_framework)
translated_circuit.print_circuit()
# and the visualization of the results are 
print("The results of our simulated circuit are: ")
print(counts)
import matplotlib.pyplot as plt
states = [′00′, ′01′, ′10′, ′11′] 
counts_keys = list(counts.keys()) 
result_counts = {state: counts[state] if state in counts_keys else 0 for state in states}
total_counts = sum(result_counts.values())
percentages = {state: (count / total_counts) * 100 for state, count in result_counts.items()}
plt.bar(percentages.keys(), percentages.values())
plt.xlabel(′State′)
plt.ylabel(′Measurement Probability (%)′)
plt.title(′Grover Algorithm Simulation Results (Pennylane)′)
plt.ylim(0, 110) 
plt.show()

Finally, we integrate measurement gates and choose the desired framework for executing our Grover algorithm in Qinterpreter. In our case, we have opted for the Pennylane framework. Figure 4 depicts the quantum circuit diagram for a 2-qubit system in this framework, and the measurement probability for the 2-qubit state is illustrated in Fig. 5, respectively. Our 2-qubit system circuit exhibits no errors; thus, it is free from random noise in the system.

Furthermore, with minor modifications to the code, one can easily adapt the algorithm to find other respective states. For instance, adjusting the Oracle part of the circuit to match the state $|10⟩$ instead of $|11⟩$ involves a simple modification, specifically:

def apply_oracle(circuit):
      circuit.add_gate(QuantumGate("x", [1])) # Change qubit 1 to |0⟩
      circuit.add_gate(QuantumGate("cphase", [0, 1], [-math.pi])) 
      circuit.add_gate(QuantumGate("x", [1])) # Restore qubit 1 to |0⟩

Similarly, if the goal is to modify the Grover algorithm to find the state $|01⟩$ instead of $|10⟩$, starting from the code designed to find $|11⟩$, a minor correction in the Oracle part of the circuit is necessary, as follows:

def apply_oracle(circuit):
      circuit.add_gate(QuantumGate("x", [0])) 
      circuit.add_gate(QuantumGate("cphase", [0, 1], [-math.pi])) 
      circuit.add_gate(QuantumGate("x", [0]))

and to find the state $|00⟩$, starting from the code designed to find $|11⟩$, we need to make changes to both the Oracle and Amplification Operator. In the Oracle part, it is necessary to remove all x gates and leave only the cphase gate, whereas in the amplificatory operator part, we must change the angle of the cphase gate. Instead of -pi, it will be pi. We have also developed Grover’s quantum search algorithm for 4-qubit systems, showcasing an absence of noise and errors in the system design (Jingle et al., 2022). Comprehensive algorithm explanations are available in the Qinterpreter files (Contreras Sepulveda & Contributors, 2023).

Shor’s factorization algorithm

In this subsection, we implement the Shor Algorithm by using the Qinterpreter. The Shor Algorithm is a quantum computing algorithm that enables the identification of prime factors for any given integer (see Shor, 1999, 1994; LaPierre, 2021; Yimsiriwattana & Lomonaco, 2004; Ekert & Jozsa, 1996). To employ the Qinterpreter in developing the Shor Algorithm and simulate it across various frameworks such as Qiskit, Cirq, Pyquil, Pennylane, and Amazon-Braket, we proceed by creating our circuit and incorporating the measurement gates. To use the Qinterpreter and implement the Shor Algorithm, we import the necessary modules and create our circuit, incorporating the required measurement gates

from math import pi 
from fractions import Fraction
import math 
import numpy as np 
#-----------------------------------------------------------------
#Assigning Constants:
#-----------------------------------------------------------------
pi = math.pi # П is assigned to the variable ′pi′
n_count = 4 
#-----------------------------------------------------------------
#Quantum Circuit Initialization:
#-----------------------------------------------------------------
circ = QuantumCircuit(8, 8) 
#-----------------------------------------------------------------
#Applying initial Quantum Gates:
#-----------------------------------------------------------------
for i in range[4]:
circ.add_gate(QuantumGate("H", [i]))
# An Pauli-X gate is applied to the 5th qubit
circ.add_gate(QuantumGate("X", [4]))
# CNOT gates are applied to different pairs of qubits
circ.add_gate(QuantumGate("CNOT", [0, 5]))
circ.add_gate(QuantumGate("CNOT", [0, 6]))
circ.add_gate(QuantumGate("CNOT", [1, 4]))
circ.add_gate(QuantumGate("CNOT", [1, 6]
))
# Toffoli gates are applied to control qubits 0 and 1, targeting qubits
 4, 5, 6, and 7.
for i in range(4, 8):
      circ.add_gate(QuantumGate("Toffoli", [0, 1, i]))
#-----------------------------------------------------------------
#Measure the auxiliary qubits:
#-----------------------------------------------------------------
# MEASURE gates are applied to the auxiliary qubits (qubits 4, 5, 6, and 
7).
for i in range(4, 8):
      circ.add_gate(QuantumGate("MEASURE", [i, i]))
#-----------------------------------------------------------------
#Quantum Fourier Transform (QFT):
#-----------------------------------------------------------------
n=4
for i in range(n-1, -1, -1):
      circ.add_gate(QuantumGate("H", [i])) 
      for j in range(i - 1, -1, -1): 
           circ.add_gate(QuantumGate("CPHASE", [j, i], [pi/(2 ** (i -
 j))])) 
#Controlled-phase gates (CPHASE) are then applied to implement the 
Quantum Fourier Transform
for i in range(n // 2):
      circ.add_gate(QuantumGate("SWAP", [i, n - i - 1]))
#SWAP gates are used to reorder qubits in the QFT, and MEASURE gates are applied to the control qubits
#-----------------------------------------------------------------
#Measure the control qubits:
#-----------------------------------------------------------------
for i in range(4):
      circ.add_gate(QuantumGate("MEASURE", [i, i+4]))

Selecting the desired framework:

selected_framework = ′qiskit′ # Change this to the desired framework
translated_circuit = translate_to_framework(circ, selected_framework)

Printing the circuit to visualize the results:

translated_circuit.print_circuit()

As the circuit is rather extensive, for the sake of simplicity, we present only the results from the Qiskit framework in Fig. 6. However, users have the option to simulate the circuit using the alternative frameworks.

To print our results, we use the following command code

print("The results of our simulated circuit are: ")
counts = simulate_circuit(circ, selected_framework)
print(counts)
#-----------------------------------------------------------------
#Analyze Measurement Results:
#-----------------------------------------------------------------
# Convert binary to decimal and remove zeros
measured_values = {int(k[:n_count], 2) for k in counts.keys() if int(k[:n_count], 2) != 0}
print("Measured values:", measured_values)

The results of our simulated circuit are:

{′11000000′: 224, ′10000000′: 255, ′01000000′: 252, ′00000000′: 269}

These results correspond to the binary numbers: 12, 8, 4, and 0, where the number 12 was obtained 224 times, the number 8 was obtained 255 times, the number 4 was 252 times and the 0 number was 269.

Interpreting these results according to the Shor algorithm procedure:

• Try to find the period ‘r’ and the factors of ‘N’ for each ‘a’ where a is an aleatory number between 2 and 15 different from a factor of 15. This is done through the following steps:

• Initializes an empty list to store estimates for period ‘r’ (estimates = []).

• Iterates over the values measured by the quantum circuit (form m in measured_values:). Each measured value is an estimate of period ‘r’.

• Calculates an estimate of ‘r’ as the denominator of the fraction m/2^n (estimate = Fraction (m, 2**n_count) and r = estimate.denominator). Python’s Fraction class reduces the fraction to its simplest form, and the denominator of this simplified fraction is an estimate of the period ‘r’.

• Checks if a^r mod 15 is equal to 1 (if pow(a, r, 15) == 1:). If so, this ‘r’ is a good estimate of the period and can be used to find the factors of ‘N’.

• Computes two candidate factors of ‘N’ as a^(r/2) ± 1 and finds their common factors with ‘N’ (factor1 = math.gcd (a**(r//2) + 1, 15) and factor2 = math.gcd (a**(r//2) − 1, 15)). If any of these common factors is greater than 1 and has not been found before, it is added to the set of factors.

• If a period is not found for a value of ‘a’, a message is displayed to the console (print ("Did not find a period.")).

The Shor algorithm generates the factors of the number 15: {3, 5}. The corresponding code for obtaining these results is provided below:

#-----------------------------------------------------------------
#Factor Finding with Shor's Algorithm:
#-----------------------------------------------------------------
factors = set()
prime_factors = set()
# Initializes two sets, factors and prime_factors, to store the factors and prime factors obtained during the algorithm
for a in range(2, 15): 
      if math.gcd(a, 15) != 1:
           continue 
      found_period = False
      for m in measured_values:
           r = Fraction(m, 2 ** n_count).denominator
           if pow(a, r, 15) == 1 and r % 2 == 0: 
# For each valid a, it searches for a period r such that a^r(mod15)≡1 
and r is even.
                factor1 = math.gcd(a ** (r // 2) + 1, 15)
                factor2 = math.gcd(a ** (r // 2) - 1, 15)
                factors.update([factor1, factor2])
# If a valid period is found, it calculates potential factors using
 the period and updates the factors set.
                    found_period = True
          if not found_period:
                print(f"Did not find a period for a = {a}.")
# Check if the factors are prime
for factor in factors:
      if factor > 1 and all(factor % i != 0 for i in range(2, int(math.sqrt(factor)) + 1)):
#     Checks if the factors in the factors set are prime.
           prime_factors.add(factor)
#     Adds prime factors to the prime_factors set.
line = "*" * 70
# Prints a line of asterisks for visual separation.
print(line)
if prime_factors:
      print("The prime factors of the number 15, using the Shor Algorithm are:", prime_factors)
# If there are prime factors, it prints them.
else:
      print("No prime factors found.")
print(line)

Similar to the Grover algorithm’s code, we can make minor adjustments to the preceding code to find the prime factors of the numbers 21 and 35. For 21, the prime factors are 3 and 7, and for 35, they are 7 and 5. Of course, these adjustments involve modifying the number of qubits. Specifically, the factorization of 21 requires a total of five qubits: three for the control register and two for the work register. In contrast, the factorization of 35 requires a total of eight qubits. Moreover, some adjustments in the loop ranges and changes in the iteration range for ‘a’ must also be made. For the sake of simplicity, we have only included the corresponding quantum circuit diagrams for the factorization of 21 and 35 in Figs. 7 and 8, respectively, using the Amazon Braket framework.

We have thoroughly outlined the strengths and advantages of Qinterpreter. Currently, Qinterpreter has not yet been tested for executing circuits and objectives on real quantum devices through their respective interfaces due to a lack of access to cloud quantum computing services, as offered by quantum computing environments like Qiskit. For example, if we get access to real quantum devices, the Qinterpreter needs to be extended to capture the full spectrum of noise and error characteristics inherent in such devices. This disparity between simulated and actual quantum behavior can impact the accuracy of predictions.

Moreover, executing complex quantum algorithms and simulations may demand significant computational power and memory. This poses limitations on the size and scope of simulations that can be effectively performed on current quantum computers, making it less than ideal for individual researchers needing a dedicated and faster simulator for their experiments. Simulating systems with a large number of qubits becomes computationally demanding, with resources growing exponentially as the number of qubits increases.

Thus, there are restrictions on the number of qubits in each quantum backend of the Qinterpreter simulator. For instance, IBM’s simulator has a maximum size of 32 qubits, and expansion is not an option. AWS Braket, on the other hand, can accommodate up to 34 qubits. The base simulator in Cirq can calculate circuit results for up to 20 qubits using cirq.Simulator(). The Pennylane simulator can handle circuits with up to 28 qubits. Finally, the PyQuil simulator, known as the QVM (Quantum Virtual Machine), has a limitation of up to 26 qubits.

Despite lacking access to real quantum devices, the Qinterpreter simulator provides students and newcomers with exposure to various quantum computing environments. This knowledge proves essential for researchers and practitioners, aiding them in choosing the most suitable simulator aligned with their unique quantum computing needs. As a result, navigating these interfaces enhances the learning experience by introducing students to various environments, elucidating simulator limitations, emphasizing considerations in resource management, and shedding light on scalability challenges. These advantages collectively contribute to a well-rounded and practical education for newcomers in the field of quantum computing.