def build_two_qubit_matrix(operation) -> np.ndarray:
"""Return full process tomography on two qubit operation with PyQuEST interface"""
matrix = np.zeros((4, 4), dtype=complex)
for co, state in enumerate([np.array([1, 0, 0, 0]),
np.array([0, 1, 0, 0]),
np.array([0, 0, 1, 0]),
np.array([0, 0, 0, 1]), ]):
env = utils.createQuestEnv()()
qubits = utils.createQureg()(2, env)
cheat.initStateFromAmps()(qubits, np.real(state), np.imag(state))
circuit = Circuit()
circuit += operation
pyquest_call_circuit(circuit=circuit,
qureg=qubits,
classical_bit_registers=dict(),
classical_float_registers=dict(),
classical_complex_registers=dict(),
output_bit_register_dict=dict(),)
for i in range(0, 4):
out = cheat.getAmp()(qureg=qubits, index=i)
matrix[i, co] = out
utils.destroyQureg()(qubits, env=env)
utils.destroyQuestEnv()(env)
return matrix
def test_acceptance_with_qiskit():
"""Test gate operations with QASM interface"""
circuit = Circuit()
circuit += ops.RotateX(0, -np.pi)
circuit += ops.RotateY(0, -np.pi)
circuit += ops.RotateZ(0, -np.pi)
circuit += ops.CNOT(0, 1)
circuit += ops.Hadamard(0)
circuit += ops.PauliX(0)
circuit += ops.PauliY(0)
circuit += ops.PauliZ(0)
circuit += ops.SGate(0)
circuit += ops.TGate(0)
circuit += ops.SqrtPauliX(0)
circuit += ops.MolmerSorensenXX(0, 1)
circuit += ops.ControlledPauliY(0, 1)
circuit += ops.ControlledPauliZ(0, 1)
circuit += ops.SingleQubitGate(0, 1, 0, 1, 0, 1.0)
circuit += ops.PragmaRepeatedMeasurement('ro', 1, None)
circuit += ops.MeasureQubit(0, 'ro', 0)
circuit += ops.DefinitionFloat(name='rof', length=1, is_output=True)
circuit += ops.DefinitionBit(name='ro', length=2, is_output=True)
circuit += ops.DefinitionComplex(name='roc', length=1, is_output=True)
circuit += ops.InputSymbolic('other', 0)
circuit += ops.PragmaSetNumberOfMeasurements(20, 'ro')
backend = QasmBackend(number_qubits=2)
backend.run_circuit(circuit=circuit, overwrite=True)
q_circuit = QuantumCircuit.from_qasm_file(
"default_qasm_backend_output.qasm")
def test_active_reset():
"""Test ActiveReset PRAGMA with PyQuEST interface"""
definition = ops.DefinitionBit(name='ro', length=2, is_output=True)
circuit = Circuit()
circuit += definition
circuit += ops.PauliX(qubit=0)
circuit_with = circuit + ops.PragmaActiveReset(qubit=0) + ops.PragmaActiveReset(qubit=1)
circuit_without = circuit + ops.PauliX(qubit=0)
circuit_list = [circuit, circuit_with, circuit_without]
for circuit in circuit_list:
circuit += ops.MeasureQubit(qubit=0, readout='ro', readout_index=0)
circuit += ops.MeasureQubit(qubit=1, readout='ro', readout_index=1)
test_dict = {'ro': [False, False]}
env = utils.createQuestEnv()()
qureg = utils.createQureg()(2, env)
results_list_0 = []
results_list_1 = []
for circuit in circuit_list:
pyquest_call_circuit(circuit=circuit, qureg=qureg, classical_bit_registers=test_dict,
classical_float_registers=dict(),
classical_complex_registers=dict(),
output_bit_register_dict=dict(),)
results_list_0.append(test_dict['ro'][0])
results_list_1.append(test_dict['ro'][1])
assert results_list_0 == [True, False, False]
assert results_list_1 == [False, False, False]
def test_circuit(measurement):
"""Test building a circuit"""
circuit = Circuit()
circuit += ops.DefinitionFloat(name='ro', length=1, is_output=True)
circuit += ops.DefinitionComplex(name='ro', length=1, is_output=True)
circuit += ops.DefinitionBit(name='ro', length=1, is_output=True)
circuit += ops.PauliX(qubit=0)
circuit += measurement[0]
assert len(circuit) > 0
def test_pyquest_global_phase():
"""Test with PyQuEST"""
circuit = Circuit()
circuit += ops.DefinitionBit(name='out', length=2, is_output=True)
circuit += ops.DefinitionFloat(name='global_phase',
length=1,
is_output=True)
circuit += ops.PauliX(qubit=0)
circuit += ops.PragmaGlobalPhase(phase=1)
circuit += ops.PragmaGlobalPhase(phase='test')
circuit += ops.MeasureQubit(qubit=0, readout='out', readout_index=0)
circuit += ops.MeasureQubit(qubit=1, readout='out', readout_index=1)
circuit += ops.InputSymbolic(name="test", input=-2)
circuit = circuit.substitute_parameters({})
pyquest = PyQuestBackend(number_qubits=2)
(output_bit_register_dict, output_float_register_dict,
output_complex_register_dict) = pyquest.run_circuit(circuit)
assert output_bit_register_dict['out'] == [[True, False]]
assert len(output_bit_register_dict['out']) == 1
assert output_float_register_dict['global_phase'][0][0] == -1
def test_qasm_xx():
"""Testing the MolmerSorensenXX gate with the QASM backend"""
circuit = Circuit()
circuit += ops.DefinitionBit(name='ro', length=2, is_output=True)
circuit += ops.MolmerSorensenXX(control=0, target=1)
circuit += ops.MeasureQubit(qubit=0, readout='ro', readout_index=0)
circuit += ops.MeasureQubit(qubit=1, readout='ro', readout_index=1)
backend = QasmBackend(number_qubits=2)
backend.run_circuit(circuit=circuit, overwrite=True)
circuit = [
'creg ro[2];', 'rxx(pi/2) q[0],q[1];', 'measure q[0] -> ro[0];',
'measure q[1] -> ro[1];'
]
npt.assert_equal(backend.circuit, circuit)
def test_all_operations(op: Any):
"""Test all operations with mocked interface"""
circuit = Circuit()
circuit += ops.DefinitionFloat(name='ro', length=1, is_output=False)
circuit += ops.DefinitionBit(name='ro', length=1, is_output=False)
circuit += ops.DefinitionComplex(name='ro', length=1, is_output=False)
circuit += ops.DefinitionUsize(name='ro', length=1, is_output=False)
circuit += op
mocked_call_circuit(circuit=circuit,
classical_bit_registers={},
classical_float_registers={},
classical_complex_registers={},
output_bit_register_dict={},
output_complex_register_dict={},
number_qubits=1)
def test_mocked_backend(measurement):
"""Test mocked backend"""
circuit = Circuit()
circuit += ops.DefinitionFloat(name='ro', length=1, is_output=True)
circuit += ops.DefinitionComplex(name='ro', length=1, is_output=True)
circuit += ops.DefinitionBit(name='ro', length=1, is_output=True)
circuit += ops.PauliX(qubit=0)
circuit += measurement[0]
mocked = MockedBackend(number_qubits=2)
results = mocked.run_circuit(circuit=circuit)[measurement[2]]['ro'][0]
if isinstance(results[0], List):
assert isinstance(results[0][0], measurement[1])
else:
assert isinstance(results[0], measurement[1])
def test_pyquest_interactive_density_matrix():
"""Test with PyQuEST density matrix"""
circuit = Circuit()
circuit += ops.DefinitionBit(name='out', length=2, is_output=True)
circuit += ops.DefinitionBit(name='out2', length=2, is_output=True)
circuit += ops.DefinitionBit(name='notout', length=2, is_output=False)
circuit += ops.PauliX(qubit=0)
circuit += ops.MeasureQubit(qubit=0, readout='out', readout_index=0)
circuit += ops.MeasureQubit(qubit=1, readout='out', readout_index=1)
pyquest = PyQuestBackend(number_qubits=2)
(output_bit_register_dict, output_float_register_dict,
output_complex_register_dict) = pyquest.run_circuit(circuit)
assert output_bit_register_dict['out'] == [[True, False]]
assert len(output_bit_register_dict['out2']) == 1
assert 'notout' not in output_bit_register_dict.keys()
def test_qasm_backend():
"""Testing the QASM functionality with the QASM backend"""
circuit = Circuit()
circuit += ops.DefinitionBit(name='ro', length=2, is_output=True)
circuit += ops.RotateZ(qubit=0, theta=0)
circuit += ops.PauliX(qubit=1)
circuit += ops.MeasureQubit(qubit=0, readout='ro', readout_index=0)
circuit += ops.MeasureQubit(qubit=1, readout='ro', readout_index=1)
backend = QasmBackend(number_qubits=2)
backend.run_circuit(circuit=circuit, overwrite=True)
circuit = [
'creg ro[2];', 'rz(0.0) q[0];', 'x q[1];', 'measure q[0] -> ro[0];',
'measure q[1] -> ro[1];'
]
npt.assert_equal(backend.circuit, circuit)
def test_pragma_get_occupation_probability_pyquest(init) -> None:
"""Test get occupation probability with PyQuEST interface"""
op = ops.PragmaGetOccupationProbability
test_dict: Dict[str, List[float]] = {'ro': [0, 0]}
operation = op(readout='ro',
circuit=Circuit()
)
env = utils.createQuestEnv()()
qubits = utils.createQureg()(2, env)
state = np.array([0, 1, 0, 0])
cheat.initStateFromAmps()(qubits, np.real(state), np.imag(state))
pyquest_call_operation(operation=operation, qureg=qubits, classical_bit_registers=dict(),
classical_float_registers=test_dict,
classical_complex_registers=dict(),
output_bit_register_dict=dict(),)
utils.destroyQureg()(qubits=qubits, env=env)
utils.destroyQuestEnv()(env)
npt.assert_array_almost_equal(test_dict['ro'], init[1])
def test_pragma_get_statevec_pyquest(init) -> None:
"""Test get state vector with PyQuEST interface"""
op = ops.PragmaGetStateVector
test_dict: Dict[str, List[complex]] = {'ro': [0, 0, 0, 0]}
operation = op(readout='ro',
circuit=Circuit(),
)
env = utils.createQuestEnv()()
qubits = utils.createQureg()(2, env)
state = 1 / np.sqrt(2) * np.array([1, 1, 0, 0])
cheat.initStateFromAmps()(qubits, np.real(state), np.imag(state))
pyquest_call_operation(operation=operation, qureg=qubits, classical_bit_registers=dict(),
classical_float_registers=dict(),
classical_complex_registers=test_dict,
output_bit_register_dict=dict(),)
utils.destroyQureg()(qubits=qubits, env=env)
utils.destroyQuestEnv()(env)
npt.assert_array_almost_equal(test_dict['ro'], init[1], decimal=4)
def test_pragma_get_densitymatrix_pyquest() -> None:
"""Test get density matrix with PyQuEST interface"""
op = ops.PragmaGetDensityMatrix
test_dict: Dict[str, List[complex]] = {'ro': [0, 0, 0, 0]}
operation = op(readout='ro',
circuit=Circuit()
)
env = utils.createQuestEnv()()
qubits = utils.createQureg()(1, env)
state = 1 / np.sqrt(2) * np.array([1, 1])
density_matrix = 1 / 2 * np.array([[1, 1], [1, 1]]).flatten()
cheat.initStateFromAmps()(qubits, np.real(state), np.imag(state))
pyquest_call_operation(operation=operation, qureg=qubits, classical_bit_registers=dict(),
classical_float_registers=dict(),
classical_complex_registers=test_dict,
output_bit_register_dict=dict(),)
utils.destroyQureg()(qubits=qubits, env=env)
utils.destroyQuestEnv()(env)
npt.assert_array_almost_equal(test_dict['ro'], density_matrix)
def test_pragma_get_pauli_prod_measurement_pyquest(init) -> None:
"""Test measuring product of pauli operators with PyQuEST interface"""
test_dict: Dict[str, List[float]] = {'ro': [0, 0, 0, 0]}
op = ops.PragmaGetPauliProduct
env = utils.createQuestEnv()()
qubits = utils.createQureg()(2, env)
state = init[0]
cheat.initStateFromAmps()(qubits, np.real(state), np.imag(state))
operation = op(readout='ro',
qubit_paulis=init[2],
circuit=Circuit())
pyquest_call_operation(operation=operation, qureg=qubits, classical_bit_registers=dict(),
classical_float_registers=test_dict,
classical_complex_registers=dict(),
output_bit_register_dict=dict(),)
npt.assert_array_almost_equal(test_dict['ro'], init[1])
utils.destroyQureg()(qubits, env=env)
utils.destroyQuestEnv()(env)
def test_pragma_get_pauli_product_pyquest() -> None:
"""Test repeated measurement with PyQuEST interface"""
operation = ops.PragmaGetPauliProduct(readout='ro',
qubit_paulis={0: 3},
circuit=Circuit()
)
test_dict: Dict[str, List[float]] = {'ro': [0.0]}
env = utils.createQuestEnv()()
qubits = utils.createQureg()(2, env)
state = np.array([1, 0, 0, 0])
cheat.initStateFromAmps()(qubits, np.real(state), np.imag(state))
pyquest_call_operation(operation=operation, qureg=qubits, classical_bit_registers=dict(),
classical_float_registers=test_dict,
classical_complex_registers=dict(),
output_bit_register_dict=dict(),)
assert test_dict['ro'][0] == 1
test_dict = {'ro': list()}
state = np.array([0, 1, 0, 0])
cheat.initStateFromAmps()(qubits, np.real(state), np.imag(state))
pyquest_call_operation(operation=operation, qureg=qubits, classical_bit_registers=dict(),
classical_float_registers=test_dict,
classical_complex_registers=dict(),
output_bit_register_dict=dict(),)
assert test_dict['ro'][0] == -1
test_dict = {'ro': list()}
state = 1 / np.sqrt(2) * np.array([1, 1, 0, 0])
cheat.initStateFromAmps()(qubits, np.real(state), np.imag(state))
pyquest_call_operation(operation=operation, qureg=qubits, classical_bit_registers=dict(),
classical_float_registers=test_dict,
classical_complex_registers=dict(),
output_bit_register_dict=dict(),)
assert test_dict['ro'][0] == 0
operation = ops.PragmaGetPauliProduct(readout='ro',
qubit_paulis={0: 3, 1: 3},
circuit=Circuit()
)
test_dict = {'ro': list()}
state = 1 / np.sqrt(2) * np.array([0, 1, 1, 0])
cheat.initStateFromAmps()(qubits, np.real(state), np.imag(state))
pyquest_call_operation(operation=operation, qureg=qubits, classical_bit_registers=dict(),
classical_float_registers=test_dict,
classical_complex_registers=dict(),
output_bit_register_dict=dict(),)
assert np.isclose(test_dict['ro'][0], -1)
test_dict = {'ro': list()}
state = 1 / np.sqrt(2) * np.array([0, 1, -1, 0])
cheat.initStateFromAmps()(qubits, np.real(state), np.imag(state))
pyquest_call_operation(operation=operation, qureg=qubits, classical_bit_registers=dict(),
classical_float_registers=test_dict,
classical_complex_registers=dict(),
output_bit_register_dict=dict(),)
assert np.isclose(test_dict['ro'][0], -1)
utils.destroyQureg()(qubits=qubits, env=env)
utils.destroyQuestEnv()(env)
import numpy as np
import numpy.testing as npt
from qoqo import operations as ops
from qoqo import Circuit
from typing import List
@pytest.mark.parametrize('measurement', [
(ops.MeasureQubit(qubit=0, readout='ro', readout_index=0), int, 0),
(ops.PragmaRepeatedMeasurement(readout='ro',
number_measurements=10), int, 0),
(ops.PragmaGetPauliProduct(
qubit_paulis={
0: 1,
1: 2
}, readout='ro', circuit=Circuit()), float, 1),
(ops.PragmaGetOccupationProbability(readout='ro',
circuit=Circuit()), float, 1),
(ops.PragmaGetStateVector(readout='ro', circuit=Circuit()), complex, 2),
(ops.PragmaGetDensityMatrix(readout='ro', circuit=Circuit()), complex, 2),
])
def test_circuit(measurement):
"""Test building a circuit"""
circuit = Circuit()
circuit += ops.DefinitionFloat(name='ro', length=1, is_output=True)
circuit += ops.DefinitionComplex(name='ro', length=1, is_output=True)
circuit += ops.DefinitionBit(name='ro', length=1, is_output=True)
circuit += ops.PauliX(qubit=0)
circuit += measurement[0]
assert len(circuit) > 0
ops.SqrtPauliX(0),
ops.InvSqrtPauliX(0),
ops.RotateX(0, 0.01),
ops.RotateY(0, 0.01),
ops.RotateZ(0, 0.01),
ops.RotateAroundSphericalAxis(0, 0.01, 0.02, 0.03),
ops.PragmaSetNumberOfMeasurements(20, 'ro'),
ops.PragmaSetStateVector(np.array([0, 1], dtype=complex)),
ops.PragmaSetDensityMatrix(np.array([[0, 0], [0, 1]], dtype=complex)),
ops.PragmaDamping(0, 0.005, 0.02),
ops.PragmaDephasing(0, 0.005, 0.02),
ops.PragmaDepolarising(0, 0.005, 0.02),
ops.PragmaRandomNoise(0, 0.005, 0.02, 0.01),
ops.PragmaGeneralNoise(
0, 0.005, np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]], dtype=float)),
ops.PragmaConditional('ro', 0, Circuit()),
ops.PragmaRepeatGate(3),
ops.PragmaBoostNoise(0.004),
ops.PragmaStopParallelBlock([0, 1], 0.002),
ops.PragmaSleep([0, 1], 0.002),
ops.PragmaActiveReset(0),
ops.PragmaGlobalPhase(0.03),
ops.MeasureQubit(0, 'ro', 0),
ops.PragmaRepeatedMeasurement('ro', 20, {}),
ops.PragmaGetStateVector('ro', Circuit()),
ops.PragmaGetDensityMatrix('ro', Circuit()),
ops.PragmaGetOccupationProbability('ro', Circuit()),
ops.PragmaGetPauliProduct({}, 'ro', Circuit()),
ops.PragmaStartDecompositionBlock([0, 1], {}),
ops.PragmaStopDecompositionBlock([0, 1]),
ops.InputSymbolic('other', 0),
def run_circuit(
self, circuit: Circuit
) -> Tuple[Dict[str, List[List[bool]]], Dict[str, List[List[float]]], Dict[
str, List[List[complex]]]]:
"""Run a circuit with the PyQuEST backend
Args:
circuit: The circuit that is run
Returns:
Tuple[Dict[str, List[List[bool]]],
Dict[str, List[List[float]]],
Dict[str, List[List[complex]]]]
"""
# Initializing the classical registers for calculation and output
internal_bit_register_dict: Dict[str, List[bool]] = dict()
internal_float_register_dict: Dict[str, List[float]] = dict()
internal_complex_register_dict: Dict[str, List[complex]] = dict()
output_bit_register_dict: Dict[str, List[List[bool]]] = dict()
output_float_register_dict: Dict[str, List[List[float]]] = dict()
output_complex_register_dict: Dict[str, List[List[complex]]] = dict()
for bit_def in circuit.filter_by_tag("DefinitionBit"):
internal_bit_register_dict[bit_def.name()] = [
False for _ in range(bit_def.length())
]
if bit_def.is_output():
output_bit_register_dict[bit_def.name()] = list()
for float_def in circuit.filter_by_tag("DefinitionFloat"):
internal_float_register_dict[float_def.name()] = [
0.0 for _ in range(float_def.length())
]
if float_def.is_output():
output_float_register_dict[float_def.name()] = cast(
List[List[float]], list())
for complex_def in circuit.filter_by_tag("DefinitionComplex"):
internal_complex_register_dict[complex_def.name()] = [
complex(0.0) for _ in range(complex_def.length())
]
if complex_def.is_output():
output_complex_register_dict[complex_def.name()] = cast(
List[List[complex]], list())
global_phase = 0
for op in circuit.filter_by_tag('PragmaGlobalPhase'):
global_phase += op.phase().float()
env = pyquest_cffi.utils.createQuestEnv()()
number_gates_requiring_repetitions = circuit.count_occurences(
["PragmaRandomNoise", "PragmaOverrotation"])
if number_gates_requiring_repetitions > 0:
repetitions = self.repetitions
else:
repetitions = 1
number_qubits = self.number_qubits
for _ in range(repetitions):
# Resetting internat classical registers
for bit_def in circuit.filter_by_tag("DefinitionBit"):
internal_bit_register_dict[bit_def.name()] = [
False for _ in range(bit_def.length())
]
for float_def in circuit.filter_by_tag("DefinitionFloat"):
internal_float_register_dict[float_def.name()] = [
0.0 for _ in range(float_def.length())
]
for complex_def in circuit.filter_by_tag("DefinitionComplex"):
internal_complex_register_dict[complex_def.name()] = [
complex(0.0) for _ in range(complex_def.length())
]
# Count gates that require density matrix mode
# Note: Random noise does not, because it is a stochastic unravelling
number_gate_requiring_density_matrix_mode = circuit.count_occurences(
["PragmaDamping", "PragmaDephasing", "PragmaDepolarising"])
if number_gate_requiring_density_matrix_mode > 0:
self.qureg = pyquest_cffi.utils.createDensityQureg()(
num_qubits=number_qubits, env=env)
else:
self.qureg = pyquest_cffi.utils.createQureg()(
num_qubits=number_qubits, env=env)
if number_gates_requiring_repetitions > 0:
circuit = circuit.overrotate()
pyquest_call_circuit(
circuit=circuit,
qureg=self.qureg,
classical_bit_registers=internal_bit_register_dict,
classical_float_registers=internal_float_register_dict,
classical_complex_registers=internal_complex_register_dict,
output_bit_register_dict=output_bit_register_dict,
)
for name, reg in output_bit_register_dict.items():
if name in internal_bit_register_dict.keys():
reg.append(internal_bit_register_dict[name])
for name, reg in output_float_register_dict.items(
): # type: ignore
if name in internal_float_register_dict.keys():
reg.append(
internal_float_register_dict[name]) # type: ignore
for name, reg in output_complex_register_dict.items(
): # type: ignore
if name in internal_complex_register_dict.keys():
reg.append(
internal_complex_register_dict[name]) # type: ignore
# Overwriting global phase
if 'global_phase' in output_float_register_dict.keys(
) and global_phase != 0:
output_float_register_dict['global_phase'] = [[global_phase]]
pyquest_cffi.utils.destroyQuestEnv()(env)
return (output_bit_register_dict, output_float_register_dict,
output_complex_register_dict)
def test_conditional_pragma():
"""Test PRAGMA conditional operation"""
test_dict = {'ro': [False, False],
'cond': [True, False]}
circuit0 = Circuit()
circuit0 += ops.PauliX(qubit=0)
circuit0 += ops.MeasureQubit(readout='ro', qubit=0, readout_index=0)
circuit1 = Circuit()
circuit1 += ops.PauliX(qubit=1)
circuit1 += ops.MeasureQubit(readout='ro', qubit=1, readout_index=1)
operation = ops.PragmaConditional(
condition_register='cond',
condition_index=0,
circuit=circuit0)
env = utils.createQuestEnv()()
qureg = utils.createQureg()(2, env)
test_dict = {'ro': [False, False],
'cond': [True, False]}
pyquest_call_operation(operation=operation,
qureg=qureg,
classical_bit_registers=test_dict,
classical_float_registers=dict(),
classical_complex_registers=dict(),
output_bit_register_dict=dict(),
)
utils.destroyQureg().call_interactive(qureg, env)
utils.destroyQuestEnv().call_interactive(env)
assert test_dict['ro'] == [True, False]
operation = ops.PragmaConditional(
condition_register='cond',
condition_index=0,
circuit=circuit1)
env = utils.createQuestEnv()()
qureg = utils.createQureg()(2, env)
test_dict = {'ro': [False, False],
'cond': [True, False]}
pyquest_call_operation(operation=operation,
qureg=qureg,
classical_bit_registers=test_dict,
classical_float_registers=dict(),
classical_complex_registers=dict(),
output_bit_register_dict=dict(),
)
utils.destroyQureg().call_interactive(qureg, env)
utils.destroyQuestEnv().call_interactive(env)
assert test_dict['ro'] == [False, True]
operation = ops.PragmaConditional(
condition_register='not_in',
condition_index=0,
circuit=circuit1)
env = utils.createQuestEnv()()
qureg = utils.createQureg()(2, env)
with pytest.raises(RuntimeError):
pyquest_call_operation(operation=operation,
qureg=qureg,
classical_bit_registers=dict(),
classical_float_registers=dict(),
classical_complex_registers=test_dict,
output_bit_register_dict=dict(),
)
utils.destroyQureg().call_interactive(qureg, env)
utils.destroyQuestEnv().call_interactive(env)
def run_circuit(
self, circuit: Circuit
) -> Tuple[Dict[str, List[List[bool]]], Dict[str, List[List[float]]], Dict[
str, List[List[complex]]]]:
"""Run a circuit with the Mocked backend
Args:
circuit: The circuit that is run
Returns:
Union[None, Dict[str, 'RegisterOutput']]
"""
# Initializing the classical registers for calculation and output
internal_bit_register_dict: Dict[str, List[bool]] = dict()
internal_float_register_dict: Dict[str, List[float]] = dict()
internal_complex_register_dict: Dict[str, List[complex]] = dict()
output_bit_register_dict: Dict[str, List[List[bool]]] = dict()
output_float_register_dict: Dict[str, List[List[float]]] = dict()
output_complex_register_dict: Dict[str, List[List[complex]]] = dict()
for bit_def in circuit.filter_by_tag("DefinitionBit"):
internal_bit_register_dict[bit_def.name()] = [
False for _ in range(bit_def.length())
]
if bit_def.is_output():
output_bit_register_dict[bit_def.name()] = list()
for float_def in circuit.filter_by_tag("DefinitionFloat"):
internal_float_register_dict[float_def.name()] = [
0.0 for _ in range(float_def.length())
]
if float_def.is_output():
output_float_register_dict[float_def.name()] = cast(
List[List[float]], list())
for complex_def in circuit.filter_by_tag("DefinitionComplex"):
internal_complex_register_dict[complex_def.name()] = [
complex(0.0) for _ in range(complex_def.length())
]
if complex_def.is_output():
output_complex_register_dict[complex_def.name()] = cast(
List[List[complex]], list())
(internal_bit_register_dict, internal_float_register_dict,
internal_complex_register_dict, output_bit_register_dict,
output_complex_register_dict) = mocked_call_circuit(
circuit=circuit,
classical_bit_registers=internal_bit_register_dict,
classical_float_registers=internal_float_register_dict,
classical_complex_registers=internal_complex_register_dict,
output_bit_register_dict=output_bit_register_dict,
output_complex_register_dict=output_complex_register_dict,
number_qubits=self.number_qubits)
for name, reg in output_bit_register_dict.items():
if name in internal_bit_register_dict.keys():
reg.append(internal_bit_register_dict[name])
for name, reg in output_float_register_dict.items(): # type: ignore
if name in internal_float_register_dict.keys():
reg.append(internal_float_register_dict[name]) # type: ignore
for name, reg in output_complex_register_dict.items(): # type: ignore
if name in internal_complex_register_dict.keys():
reg.append(
internal_complex_register_dict[name]) # type: ignore
return (output_bit_register_dict, output_float_register_dict,
output_complex_register_dict)
