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_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 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)