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)