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 build_one_qubit_matrix(gate, gate_args) -> np.ndarray:
"""Build one qubit matrix for tests"""
matrix = np.zeros((2, 2), dtype=complex)
for co, state in enumerate([np.array([1, 0]), np.array([0, 1])]):
env = utils.createQuestEnv()()
qubits = utils.createQureg()(1, env)
cheat.initStateFromAmps()(qubits, np.real(state), np.imag(state))
gate()(qureg=qubits, qubit=0, **gate_args)
for i in range(0, 2):
cComplex = cheat.getAmp()(qureg=qubits, index=i)
matrix[i, co] = cComplex.real + 1j * cComplex.imag
return matrix
def test_two_qubit_errors(prob, gate_def) -> None:
"""Testing two qubit errors"""
op = gate_def[0]
prob = prob * gate_def[1]
env = utils.createQuestEnv()()
dm = utils.createDensityQureg()(2, env)
state = np.random.random((4, 1)) + 1j * np.random.random((4, 1))
state = state / np.linalg.norm(state)
state_dm = state @ state.conjugate().T
state_dm = state_dm.reshape((16, 1))
cheat.initStateFromAmps()(dm,
reals=np.real(state_dm),
imags=np.imag(state_dm))
op()(qureg=dm, qubit1=0, qubit2=1, probability=prob)
def test_measurement():
"""Test gate operations without free parameters with PyQuEST interface"""
op = ops.MeasureQubit(qubit=0, readout='test', readout_index=0)
test_dict = {'test': np.array([0, 0, 0, 0])}
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(op, qubits,
classical_bit_registers=test_dict,
classical_float_registers=dict(),
classical_complex_registers=dict(),
output_bit_register_dict=dict(),)
utils.destroyQureg()(qubits, env=env)
utils.destroyQuestEnv()(env)
assert test_dict['test'][0]
def test_pragma_repeated_measurement_pyquest() -> None:
"""Test repeated measurement with PyQuEST interface"""
op = ops.PragmaRepeatedMeasurement
operation = op(readout='ro',
qubit_mapping={0: 0},
number_measurements=100)
test_dict: Dict[str, List[List[bool]]] = {'ro': list(list())}
test_dict2: Dict[str, List[bool]] = {'ro': list()}
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=test_dict2,
classical_float_registers=dict(),
classical_complex_registers=dict(),
output_bit_register_dict=test_dict,)
utils.destroyQureg()(qubits, env=env)
utils.destroyQuestEnv()(env)
assert len(test_dict['ro']) == 100
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 build_two_qubit_matrix_target(gate, gate_args, control=None) -> np.ndarray:
"""Build two qubit matrix with target for tests"""
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()()
if control is None:
qubits = utils.createQureg()(2, env)
cheat.initStateFromAmps()(qubits, np.real(state), np.imag(state))
gate()(qureg=qubits,
target_qubit_1=0,
target_qubit_2=1,
**gate_args)
elif control is True:
qubits = utils.createQureg()(3, env)
control_array = np.array([0, 1])
cheat.initStateFromAmps()(qubits,
np.real(np.kron(control_array, state)),
np.imag(np.kron(control_array, state)))
gate()(qureg=qubits,
target_qubit_1=0,
target_qubit_2=1,
control=2,
**gate_args)
else:
qubits = utils.createQureg()(3, env)
control_array = np.array([1, 0])
cheat.initStateFromAmps()(qubits,
np.real(np.kron(control_array, state)),
np.imag(np.kron(control_array, state)))
gate()(qureg=qubits,
target_qubit_1=0,
target_qubit_2=1,
control=2,
**gate_args)
for i in range(0, 4):
if control is None:
cComplex = cheat.getAmp()(qureg=qubits, index=i)
matrix[i, co] = cComplex.real + 1j * cComplex.imag
elif control is True:
cComplex = cheat.getAmp()(qureg=qubits, index=i + 4)
matrix[i, co] = cComplex.real + 1j * cComplex.imag
else:
cComplex = cheat.getAmp()(qureg=qubits, index=i)
matrix[i, co] = cComplex.real + 1j * cComplex.imag
return matrix
def pyquest_call_operation(
operation: Any,
qureg: tqureg,
classical_bit_registers: Dict[str, List[bool]],
classical_float_registers: Dict[str, List[float]],
classical_complex_registers: Dict[str, List[complex]],
output_bit_register_dict: Dict[str, List[List[bool]]],
) -> None:
"""Execute the qoqo operation with PyQuEST
Args:
operation: The qoqo operation that is executed
qureg: The quantum register pyquest_cffi operates on
classical_bit_registers: Dictionary or registers (lists) containing bit readout values
classical_float_registers: Dictionary or registers (lists) containing float readout values
classical_complex_registers: Dictionary or registers (lists)
containing complex readout values
output_bit_register_dict: Dictionary or lists of registers (lists)
containing a register for each repetition of the circuit
Raises:
RuntimeError: Operation not in PyQuEST backend
"""
tags = operation.tags()
if 'RotateZ' in tags:
operation = cast(ops.RotateZ, operation)
qops.rotateZ()(qureg=qureg, qubit=operation.qubit(), theta=operation.theta().float())
elif 'RotateX' in tags:
operation = cast(ops.RotateX, operation)
qops.rotateX()(qureg=qureg, qubit=operation.qubit(), theta=operation.theta().float())
elif 'RotateY' in tags:
operation = cast(ops.RotateY, operation)
qops.rotateY()(qureg=qureg, qubit=operation.qubit(), theta=operation.theta().float())
elif 'SqrtISwap' in tags:
operation = cast(ops.SqrtISwap, operation)
qops.sqrtISwap()(qureg=qureg, control=operation.control(), qubit=operation.target())
elif 'CNOT' in tags:
operation = cast(ops.CNOT, operation)
qops.controlledNot()(qureg=qureg, control=operation.control(), qubit=operation.target())
elif 'InvSqrtISwap' in tags:
operation = cast(ops.InvSqrtISwap, operation)
qops.invSqrtISwap()(qureg=qureg, control=operation.control(), qubit=operation.target())
elif 'Hadamard' in tags:
operation = cast(ops.Hadamard, operation)
qops.hadamard()(qureg=qureg, qubit=operation.qubit())
elif 'PauliX' in tags:
operation = cast(ops.PauliX, operation)
qops.pauliX()(qureg=qureg, qubit=operation.qubit())
elif 'PauliY' in tags:
operation = cast(ops.PauliY, operation)
qops.pauliY()(qureg=qureg, qubit=operation.qubit())
elif 'PauliZ' in tags:
operation = cast(ops.PauliZ, operation)
qops.pauliZ()(qureg=qureg, qubit=operation.qubit())
elif 'SGate' in tags:
operation = cast(ops.SGate, operation)
qops.sGate()(qureg=qureg, qubit=operation.qubit())
elif 'TGate' in tags:
operation = cast(ops.TGate, operation)
qops.tGate()(qureg=qureg, qubit=operation.qubit())
elif 'SqrtPauliX' in tags:
qops.rotateX()(qureg=qureg, qubit=operation.qubit(), theta=np.pi / 2)
elif 'InvSqrtPauliX' in tags:
qops.rotateX()(qureg=qureg, qubit=operation.qubit(), theta=-np.pi / 2)
elif 'ControlledPhaseShift' in tags:
qops.controlledPhaseShift()(qureg=qureg, control=operation.control(),
qubit=operation.target(), theta=operation.theta().float())
elif 'ControlledPauliY' in tags:
qops.controlledPauliY()(qureg=qureg, control=operation.control(),
qubit=operation.target())
elif 'ControlledPauliZ' in tags:
qops.controlledPhaseFlip()(qureg=qureg, control=operation.control(),
qubit=operation.target())
elif 'RotateAroundSphericalAxis' in tags:
qops.rotateAroundSphericalAxis()(
qureg=qureg, qubit=operation.qubit(), theta=operation.theta().float(),
spherical_theta=operation.spherical_theta().float(),
spherical_phi=operation.spherical_phi().float())
elif 'SingleQubitGateOperation' in tags:
qops.compactUnitary()(qubit=operation.qubit(),
qureg=qureg,
alpha=operation.alpha_r().float() + 1j * operation.alpha_i().float(),
beta=operation.beta_r().float() + 1j * operation.beta_i().float())
elif 'TwoQubitGateOperation' in tags:
qops.twoQubitUnitary()(qureg=qureg, target_qubit_2=operation.control(),
target_qubit_1=operation.target(), matrix=operation.unitary_matrix())
elif 'PragmaRepeatedMeasurement' in tags:
_execute_PragmaRepeatedMeasurement(
operation, qureg,
classical_bit_registers,
output_bit_register_dict,
)
elif 'PragmaDamping' in tags:
qops.mixDamping()(
qureg=qureg, qubit=operation.qubit(), probability=operation.probability().float())
elif 'PragmaDepolarising' in tags:
qops.mixDepolarising()(
qureg=qureg, qubit=operation.qubit(), probability=operation.probability().float())
elif 'PragmaDephasing' in tags:
qops.mixDephasing()(
qureg=qureg, qubit=operation.qubit(), probability=operation.probability().float())
elif 'PragmaSetStateVector' in tags:
vector = operation.statevector()
qcheat.initStateFromAmps()(qureg=qureg, reals=np.real(vector), imags=np.imag(vector))
elif 'PragmaSetDensityMatrix' in tags:
density_matrix = operation.density_matrix()
# dim = int(np.round(np.sqrt(density_matrix.shape[0])))
# density_matrix = density_matrix.reshape((dim, dim))
qcheat.initStateFromAmps()(
qureg=qureg, reals=np.real(density_matrix), imags=np.imag(density_matrix))
elif 'PragmaRandomNoise' in tags:
_execute_PragmaRandomNoise(
operation, qureg,
)
elif 'PragmaActiveReset' in tags:
_execute_PragmaActiveReset(
operation, qureg,
)
elif 'MeasureQubit' in tags:
_execute_MeasureQubit(
operation, qureg, classical_bit_registers,
)
elif 'InputDefinition' in tags:
if operation.name() in classical_float_registers.keys():
classical_float_registers = operation.input()
elif 'Definition' in tags:
pass
elif 'PragmaGetPauliProduct' in tags:
_execute_GetPauliProduct(
operation, qureg,
classical_float_registers,
)
elif 'PragmaGetStateVector' in tags:
_execute_GetStateVector(
operation, qureg,
classical_complex_registers,
)
elif 'PragmaGetDensityMatrix' in tags:
_execute_GetStateVector(
operation, qureg,
classical_complex_registers,
)
elif 'PragmaGetOccupationProbability' in tags:
_execute_GetOccupationProbability(
operation, qureg,
classical_float_registers,
)
elif 'PragmaGetRotatedOccupationProbability' in tags:
_execute_GetOccupationProbability(
operation, qureg,
classical_float_registers,
)
elif 'PragmaConditional' in tags:
cast(ops.PragmaConditional, operation)
if operation.condition_register() not in classical_bit_registers.keys():
raise RuntimeError(
"Conditional register {} not found in classical bit registers".format(
operation.condition_register()))
if classical_bit_registers[operation.condition_register()][operation.condition_index()]:
pyquest_call_circuit(
circuit=operation.circuit(),
qureg=qureg,
classical_bit_registers=classical_bit_registers,
classical_float_registers=classical_float_registers,
classical_complex_registers=classical_complex_registers,
output_bit_register_dict=output_bit_register_dict,
)
elif any(pragma in tags for pragma in _ALLOWED_PRAGMAS):
pass
else:
raise RuntimeError('Operation not in PyQuEST backend')
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)