def test_set_amps_qureg() -> None:
"""Testing set functions
setAmps, setDensityAmps, setWeightedQureg
"""
env = utils.createQuestEnv()()
qureg_statevec = utils.createQureg()(2, env)
qureg_dens = utils.createDensityQureg()(2, env)
cheat.initZeroState()(qureg_statevec)
cheat.initZeroState()(qureg_dens)
cheat.setAmps()(qureg=qureg_statevec,
startind=0,
reals=[1, 2, 0, 1],
imags=[0, 3, 4, 3],
numamps=4)
state_vec = cheat.getStateVector()(qureg=qureg_statevec)
state_array = np.array([1 + 0j, 2 + 3j, 0 + 4j, 1 + 3j])
assert np.all(state_vec == state_array)
cheat.setDensityAmps()(
qureg=qureg_dens,
reals=[[1, 2, 1, 2], [0, 1, 0, 1], [1, 0, 1, 0], [2, 1, 2, 1]],
imags=[[4, 3, 4, 3], [3, 2, 3, 2], [2, 3, 2, 3], [3, 4, 3, 4]],
)
dens_mat = cheat.getDensityMatrix()(qureg=qureg_dens)
dens_array = np.array([[1 + 4j, 2 + 3j, 1 + 4j, 2 + 3j],
[3j, 1 + 2j, 3j, 1 + 2j], [1 + 2j, 3j, 1 + 2j, 3j],
[2 + 3j, 1 + 4j, 2 + 3j, 1 + 4j]])
assert np.all(dens_mat == dens_array)
# for a wavefunction qureg:
quregout = utils.createQureg()(2, env)
cheat.setWeightedQureg()(fac1=2.5,
qureg1=qureg_statevec,
fac2=3.5j,
qureg2=qureg_statevec,
facout=1,
quregout=quregout)
state_vec_combined = cheat.getStateVector()(qureg=quregout)
comparison_array = 2.5 * state_array + 3.5j * state_array + 1 * np.array(
[1, 0, 0, 0])
assert np.all(state_vec_combined == comparison_array)
# for a density matrix qureg:
quregout = utils.createDensityQureg()(2, env)
cheat.setWeightedQureg()(fac1=2.5,
qureg1=qureg_dens,
fac2=3.5j,
qureg2=qureg_dens,
facout=0.5,
quregout=quregout)
dens_mat_combined = cheat.getDensityMatrix()(qureg=quregout)
comparison_array = 2.5 * dens_array + 3.5j * dens_array + 0.5 * np.array(
[[1, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]])
assert np.all(dens_mat_combined == comparison_array)
def test_apply_Pauli_sum():
"""Test applyPauliSum"""
env = utils.createQuestEnv()()
qubits = utils.createQureg()(4, env)
qubits_out = utils.createQureg()(4, env)
ops.applyPauliSum()(
qureg=qubits,
paulis=[[0, 1, 2, 3], [3, 2, 1, 0]],
coefficients=[0.4, 0.3],
qureg_out=qubits_out,
)
def test_calc_Expec_Pauli_Sum() -> None:
"""Test calculating the expectation value of a PauliSum"""
env = utils.createQuestEnv()()
qubits = utils.createQureg()(4, env)
workspace = utils.createQureg()(4, env)
a = cheat.calcExpecPauliSum()(
qureg=qubits,
paulis=[[0, 1, 2, 3], [3, 2, 1, 0]],
coefficients=[0.4, 0.3],
workspace=workspace,
)
assert a == 0.0
def test_calc_Expec_Pauli_Prod() -> None:
"""Test calculating the expectation value of a PauliProduct"""
env = utils.createQuestEnv()()
qubits = utils.createQureg()(4, env)
workspace = utils.createQureg()(4, env)
a = cheat.calcExpecPauliProd()(
qureg=qubits,
qubits=[0, 1, 2, 3],
paulis=[0, 1, 3, 2],
workspace=workspace,
)
assert a == 0.0
def test_calc_Expec_Pauli_Hamil() -> None:
"""Test calculating the expectation value of a PauliHamil"""
env = utils.createQuestEnv()()
qubits = utils.createQureg()(4, env)
pauli_hamil = utils.createPauliHamil()(number_qubits=4,
number_pauliprods=1)
workspace = utils.createQureg()(4, env)
a = cheat.calcExpecPauliHamil()(
qureg=qubits,
pauli_hamil=pauli_hamil,
workspace=workspace,
)
npt.assert_almost_equal(a, 0.0)
def test_calc_simple() -> None:
"""Testing simple calc functions.
calcPurity, calcFidelity, calcInnerProduct, calcProbofOutcome,
calcTotalProb, calcDensityInnerProduct
"""
env = utils.createQuestEnv()()
qureg = utils.createQureg()(2, env)
qureg_main = utils.createQureg()(2, env)
cheat.initZeroState()(qureg)
with npt.assert_raises(RuntimeError):
purity = cheat.calcPurity()(qureg)
density_inner_product = cheat.calcDensityInnerProduct()(
qureg1=qureg, qureg2=qureg_main)
fidelity = cheat.calcFidelity()(qureg=qureg_main, qureg_reference=qureg)
inner_product = cheat.calcInnerProduct()(qureg1=qureg, qureg2=qureg_main)
prob_of_outcome = cheat.calcProbOfOutcome()(qureg, 1, 0)
total_prob = cheat.calcTotalProb()(qureg)
assert fidelity == 1
assert (inner_product.real == 1 and inner_product.imag == 0)
assert prob_of_outcome == 1.0
assert total_prob == 1
qureg = utils.createDensityQureg()(2, env)
cheat.initZeroState()(qureg)
with npt.assert_raises(RuntimeError):
fidelity = cheat.calcFidelity()(qureg=qureg_main,
qureg_reference=qureg)
inner_product_1 = cheat.calcInnerProduct()(qureg1=qureg,
qureg2=qureg_main)
inner_product_2 = cheat.calcInnerProduct()(qureg1=qureg_main,
qureg2=qureg)
inner_product_3 = cheat.calcInnerProduct()(qureg1=qureg, qureg2=qureg)
density_inner_product_1 = cheat.calcDensityInnerProduct()(
qureg1=qureg, qureg2=qureg_main)
density_inner_product_2 = cheat.calcDensityInnerProduct()(
qureg1=qureg_main, qureg2=qureg)
density_inner_product_3 = cheat.calcDensityInnerProduct()(qureg1=qureg,
qureg2=qureg)
purity = cheat.calcPurity()(qureg)
prob_of_outcome = cheat.calcProbOfOutcome()(qureg, 1, 0)
total_prob = cheat.calcTotalProb()(qureg)
assert purity == 1
assert prob_of_outcome == 1.0
assert total_prob == 1
assert density_inner_product_3 == 1
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 test_random_noise_operator(gate_time, depolarisation_rate, dephasing_rate):
"""Test PRAGMA operators applying random noise (stochastic unravelling) with PyQuEST interface"""
op = ops.PragmaRandomNoise
test_dict = {'ro': list()}
(Gate_time, depol_Rate, dephasing_Rate) = ('gate_time',
'depolarisation_rate',
'dephasing_rate',
)
operation = op(qubit=0, gate_time=Gate_time,
depolarising_rate=depol_Rate, dephasing_rate=dephasing_Rate)
substitution_dict = {'gate_time': gate_time,
'depolarisation_rate': depolarisation_rate,
'dephasing_rate': dephasing_rate}
env = utils.createQuestEnv()()
qureg = utils.createQureg()(1, env)
state_vec_ref = cheat.getStateVector()(qureg)
pyquest_call_operation(operation=operation.substitute_parameters(substitution_dict),
qureg=qureg,
classical_bit_registers=dict(),
classical_float_registers=dict(),
classical_complex_registers=test_dict,
output_bit_register_dict=dict(),
)
if gate_time == 0 or (dephasing_rate == 0 and depolarisation_rate == 0):
state_vec = cheat.getStateVector()(qureg)
npt.assert_array_almost_equal(state_vec_ref, state_vec)
utils.destroyQureg().call_interactive(qureg, env)
utils.destroyQuestEnv().call_interactive(env)
operation.substitute_parameters(substitution_dict)
env = utils.createQuestEnv()()
qureg = utils.createQureg()(1, env)
state_vec_ref = cheat.getStateVector()(qureg)
pyquest_call_operation(operation=operation.substitute_parameters(substitution_dict),
qureg=qureg, classical_bit_registers=dict(),
classical_float_registers=dict(),
classical_complex_registers=test_dict,
output_bit_register_dict=dict(),)
if gate_time == 0 or (dephasing_rate == 0 and depolarisation_rate == 0):
state_vec = cheat.getStateVector()(qureg)
npt.assert_array_almost_equal(state_vec_ref, state_vec)
utils.destroyQureg().call_interactive(qureg, env)
utils.destroyQuestEnv().call_interactive(env)
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 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_apply_functions(applied: Tuple[Any, List]) -> None:
"""Test all non-deprecated apply functions"""
env = utils.createQuestEnv()()
qubits = utils.createQureg()(5, env)
cheat.initZeroState()(qureg=qubits)
op = applied[0]()
positional_args = applied[1]
matrix = np.array([[1, 0, 0, 1], [0, 2, 0, 2], [2, 0, 2, 0], [1, 0, 0, 1]])
last_element: str = positional_args.pop()
if last_element == 'matrix':
args = [qubits]
args.extend(positional_args)
args.append(matrix)
elif last_element == 'pauli':
pauli_hamil = positional_args.pop(0)
cheat.initPauliHamil()(pauli_hamil=pauli_hamil,
coeffs=[0.0, 0.0, 0.0, 0.0, 0.0],
codes=[[0, 0], [0, 0], [0, 0], [0, 0], [0, 0]])
args = [qubits, pauli_hamil]
args.extend(positional_args)
else:
args = [qubits]
args.extend(positional_args)
op(*args)
if last_element == 'matrix':
npt.assert_array_equal(matrix, op.matrix(matrix=matrix))
def _execute_GetOccupationProbability(
operation: Union[
ops.PragmaGetOccupationProbability],
qureg: tqureg,
classical_float_registers: Dict[str, List[float]],
) -> None:
tags = operation.tags()
quest_obj = qcheat.getOccupationProbability()
if 'PragmaGetRotatedOccupationProbability' in tags:
N = qureg.numQubitsRepresented
env = qutils.createQuestEnv()()
if qureg.isDensityMatrix:
workspace = qutils.createDensityQureg()(N, env)
else:
workspace = qutils.createQureg()(N, env)
qutils.cloneQureg()(workspace, qureg)
if operation.circuit() is not None:
pyquest_call_circuit(
circuit=operation.circuit(),
qureg=workspace,
classical_bit_registers=dict(),
classical_float_registers=dict(),
classical_complex_registers=dict(),
output_bit_register_dict=dict(),)
occ_probabilities = np.real(quest_obj(qureg=workspace))
qutils.destroyQureg()(qubits=workspace, env=env)
del workspace
qutils.destroyQuestEnv()(env)
del env
else:
occ_probabilities = np.real(quest_obj(qureg=qureg, ))
classical_float_registers[operation.readout()] = occ_probabilities
def test_multi_controlled_PhaseShift() -> None:
"""Test multiControlledPhaseShift"""
env = utils.createQuestEnv()()
qubits = utils.createQureg()(3, env)
ops.multiControlledPhaseShift()(qureg=qubits,
controls=[0, 1],
theta=0.3 * np.pi)
def test_multi_controlled_PhaseFlip() -> None:
"""Test multiControlledPhaseFlip"""
env = utils.createQuestEnv()()
qubits = utils.createQureg()(3, env)
ops.multiControlledPhaseFlip()(
qureg=qubits,
controls=[0, 1],
)
def _execute_GetPauliProduct(
operation: ops.PragmaGetPauliProduct,
qureg: tqureg,
classical_float_registers: Dict[str, List[float]],
) -> None:
if operation.qubit_paulis == {}:
classical_float_registers[operation.readout()] = [
1.0,
]
return None
N = qureg.numQubitsRepresented
env = qutils.createQuestEnv()()
if qureg.isDensityMatrix:
workspace = qutils.createDensityQureg()(N, env)
workspace_pp = qutils.createDensityQureg()(N, env)
else:
workspace = qutils.createQureg()(N, env)
workspace_pp = qutils.createQureg()(N, env)
qutils.cloneQureg()(workspace, qureg)
if operation.circuit() is not None:
pyquest_call_circuit(
circuit=operation.circuit(),
qureg=workspace,
classical_bit_registers=dict(),
classical_float_registers=dict(),
classical_complex_registers=dict(),
output_bit_register_dict=dict(),
)
qubits = list()
paulis = list()
for qubit, pauli in operation.qubit_paulis().items():
qubits.append(qubit)
paulis.append(pauli)
pp = qcheat.calcExpecPauliProd().call_interactive(qureg=workspace,
qubits=qubits,
paulis=paulis,
workspace=workspace_pp)
qutils.destroyQureg()(qubits=workspace_pp, env=env)
qutils.destroyQureg()(qubits=workspace, env=env)
del workspace
qutils.destroyQuestEnv()(env)
del env
classical_float_registers[operation.readout()] = [
pp,
]
def test_multiRotateZ() -> None:
"""Testing multiRotateZ"""
env = utils.createQuestEnv()()
qureg = utils.createQureg()(3, env=env)
ops.multiRotateZ()(
qureg=qureg,
qubits=[0, 1, 2],
angle=0.35)
def test_calc_Expec_Diagonal_Op() -> None:
"""Test calculating the expectation value of a DiagonalOp"""
env = utils.createQuestEnv()()
qubits = utils.createQureg()(4, env)
a = cheat.calcExpecDiagonalOp()(
qureg=qubits,
operator=(4, env),
)
assert a == 0
def test_multi_controlled_unitary(gate, theta) -> None:
"""Test multiControlledUnitary"""
matrix_gate = gate().matrix(theta=theta)
env = utils.createQuestEnv()()
qubits = utils.createQureg()(3, env)
ops.multiControlledUnitary()(qureg=qubits,
controls=[0, 1],
qubit=2,
matrix=matrix_gate)
def test_multi_controlled_multi_qubit_unitary(gate, theta) -> None:
"""Test multiControlledMultiQubitUnitary"""
matrix_gate = gate().matrix(theta=theta)
env = utils.createQuestEnv()()
qubits = utils.createQureg()(4, env)
ops.multiControlledMultiQubitUnitary()(qureg=qubits,
controls=[0, 1],
targets=[2, 3],
matrix=matrix_gate)
def test_multi_controlled_two_qubit_unitary(gate, theta):
"""Test multiControlledTwoQubitUnitary"""
matrix_gate = gate().matrix(theta=theta)
env = utils.createQuestEnv()()
qubits = utils.createQureg()(4, env)
ops.multiControlledTwoQubitUnitary()(
qureg=qubits,
controls=[0, 1],
target_qubit_1=2,
target_qubit_2=3,
matrix=matrix_gate)
def test_calcPurity():
"""Testing calcPurity"""
env = utils.createQuestEnv()()
qureg = utils.createQureg()(2, env)
cheat.initZeroState()(qureg)
with npt.assert_warns(RuntimeWarning):
purity = cheat.measurement.calcPurity()(qureg)
assert(purity is None)
qureg = utils.createDensityQureg()(2, env)
cheat.initZeroState()(qureg)
purity = cheat.measurement.calcPurity()(qureg)
npt.assert_equal(purity, 1)
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_measure() -> None:
"""Test measuring functions: measure, measureWithStats and collapseToOutcome"""
env = utils.createQuestEnv()()
qureg = utils.createQureg()(3, env)
cheat.initZeroState()(qureg=qureg)
qubit_0 = ops.measure()(qureg=qureg, qubit=0)
qubit_1 = ops.measureWithStats()(qureg=qureg, qubit=1, outcome_proba=0.5)
proba_qubit_2 = ops.collapseToOutcome()(qureg=qureg, qubit=2, outcome=0)
assert qubit_0 == 0
assert qubit_1 == 0
assert proba_qubit_2 == 1
def test_get_simple() -> None:
"""Testing simple get functions.
getStateVectoratIndex/getAmp, getDensityMatrixatRowColumn/getDensityAmp,
getAbsoluteValSquaredatIndex/getProbAmp, getRealAmp, getImagAmp
"""
env = utils.createQuestEnv()()
qureg = utils.createQureg()(2, env)
cheat.initZeroState()(qureg)
index = 1
operator_matrix = np.array([[1, 0, 2, 0], [0, 1, 0, 2], [0, 2, 0, 1],
[2, 0, 1, 0]])
with npt.assert_raises(RuntimeError):
density_matrix = cheat.getDensityAmp()(qureg=qureg, row=1, column=1)
state_vec = cheat.getAmp()(qureg=qureg, index=index)
abs_val_state_vec = cheat.getProbAmp()(qureg=qureg, index=1)
real_val_sate_vec = cheat.getRealAmp()(qureg=qureg, index=1)
imag_val_sate_vec = cheat.getImagAmp()(qureg=qureg, index=1)
num_amps = cheat.getNumAmps()(qureg=qureg)
num_qubits = cheat.getNumQubits()(qureg=qureg)
expec_val = cheat.getExpectationValue()(qureg=qureg,
operator_matrix=operator_matrix)
assert state_vec == 0
assert abs_val_state_vec == 0
assert real_val_sate_vec == 0
assert imag_val_sate_vec == 0
assert num_amps == 4
assert num_qubits == 2
assert expec_val == 1
qureg = utils.createDensityQureg()(2, env)
cheat.initZeroState()(qureg)
with npt.assert_raises(RuntimeError):
state_vec = cheat.getAmp()(qureg=qureg, index=index)
abs_val_state_vec = cheat.getProbAmp()(qureg=qureg, index=1)
real_val_sate_vec = cheat.getRealAmp()(qureg=qureg, index=1)
imag_val_sate_vec = cheat.getImagAmp()(qureg=qureg, index=1)
density_matrix = cheat.getDensityAmp()(qureg=qureg, row=1, column=1)
num_amps = cheat.getNumAmps()(qureg=qureg)
num_qubits = cheat.getNumQubits()(qureg=qureg)
expec_val = cheat.getExpectationValue()(qureg=qureg,
operator_matrix=operator_matrix)
assert density_matrix == 0
assert num_amps == 4
assert num_qubits == 2
assert expec_val == 1
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_init_functions(init) -> None:
"""Test init functions
initZeroState, initPlusState, initDebugState, initBlankState, initClassicalState,
initPureState, initStateFromAmps, initPauliHamil
"""
env = utils.createQuestEnv()()
qubits = utils.createQureg()(3, env)
initialisation = init[0]()
args = init[1]
if args[0] == 'qureg':
args[0] = qubits
elif args[0] == 'pauli':
args[0] = utils.createPauliHamil()(number_qubits=3,
number_pauliprods=3)
initialisation(*args)
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_apply_functions(applied) -> None:
"""Test all non-deprecated apply functions"""
env = utils.createQuestEnv()()
qubits = utils.createQureg()(5, env)
cheat.initZeroState()(qureg=qubits)
op = applied[0]()
positional_args = applied[1]
matrix = np.array([[1, 0, 0, 1], [0, 2, 0, 2], [2, 0, 2, 0], [1, 0, 0, 1]])
if positional_args[-1] == 'matrix':
args = [qubits]
args.extend(positional_args)
args[-1] = matrix
else:
args = [qubits]
args.extend(positional_args)
op(*args)
if positional_args[-1] == 'matrix':
npt.assert_array_equal(matrix, op.matrix(matrix=matrix))
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_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
