def test_ansatz_circuit_three_layers(self, n_qubits, topology):
# Given
number_of_layers = 3
ansatz = QCBMAnsatz(
number_of_layers=number_of_layers,
number_of_qubits=n_qubits,
topology=topology,
)
params = [
np.random.rand(2 * n_qubits),
np.random.rand(int((n_qubits * (n_qubits - 1)) / 2)),
np.random.rand(2 * n_qubits),
]
expected_circuit = Circuit([
# First layer
*[RX(params[0][i])(i) for i in range(n_qubits)],
*[RZ(params[0][i + n_qubits])(i) for i in range(n_qubits)],
# Second layer
*get_entangling_layer(params[1], n_qubits, XX,
topology).operations,
# Third layer
*[RZ(params[2][i])(i) for i in range(n_qubits)],
*[RX(params[2][i + n_qubits])(i) for i in range(n_qubits)],
])
params = np.concatenate(params)
# When
circuit = ansatz.get_executable_circuit(params)
# Then
assert circuit == expected_circuit
def target_unitary(self, beta, gamma, symbols_map):
target_circuit = Circuit()
target_circuit += H(0)
target_circuit += H(1)
target_circuit += RZ(2 * gamma)(0)
target_circuit += RZ(2 * gamma)(1)
target_circuit += RX(2 * beta)(0)
target_circuit += RX(2 * beta)(1)
return target_circuit.bind(symbols_map).to_unitary()
def create_XZ1_target_unitary(number_of_params, k_body_depth=1):
thetas = create_thetas(number_of_params)
symbols_map = create_symbols_map(number_of_params)
target_circuit = Circuit()
target_circuit += create_x_operator(0, thetas[0])
target_circuit += RZ(2 * thetas[1])(0)
target_circuit += create_x_operator(1, thetas[2])
target_circuit += RZ(2 * thetas[3])(1)
if k_body_depth == 2:
target_circuit += create_2_qubit_x_operator(0, 1, thetas[4])
target_circuit += CNOT(0, 1)
target_circuit += RZ(2 * thetas[5])(1)
target_circuit += CNOT(0, 1)
return target_circuit.bind(symbols_map).to_unitary()
def time_evolution_for_term(
term: QubitOperator, time: Union[float,
sympy.Expr]) -> circuits.Circuit:
"""Evolves a Pauli term for a given time and returns a circuit representing it.
Based on section 4 from https://arxiv.org/abs/1001.3855 .
Args:
term: Pauli term to be evolved
time: time of evolution
Returns:
Circuit: Circuit representing evolved term.
"""
if len(term.terms) != 1:
raise ValueError("This function works only on a single term.")
term_components = list(term.terms.keys())[0]
base_changes = []
base_reversals = []
cnot_gates = []
central_gate = None
term_types = [component[1] for component in term_components]
qubit_indices = [component[0] for component in term_components]
coefficient = list(term.terms.values())[0]
circuit = circuits.Circuit()
# If constant term, return empty circuit.
if not term_components:
return circuit
for i, (term_type, qubit_id) in enumerate(zip(term_types, qubit_indices)):
if term_type == "X":
base_changes.append(H(qubit_id))
base_reversals.append(H(qubit_id))
elif term_type == "Y":
base_changes.append(RX(np.pi / 2)(qubit_id))
base_reversals.append(RX(-np.pi / 2)(qubit_id))
if i == len(term_components) - 1:
central_gate = RZ(2 * time * coefficient)(qubit_id)
else:
cnot_gates.append(CNOT(qubit_id, qubit_indices[i + 1]))
for gate in base_changes:
circuit += gate
for gate in cnot_gates:
circuit += gate
circuit += central_gate
for gate in reversed(cnot_gates):
circuit += gate
for gate in base_reversals:
circuit += gate
return circuit
def create_target_unitary(thetas, number_of_layers):
target_circuit = Circuit()
target_circuit += RY(thetas[0])(0)
target_circuit += RY(thetas[1])(1)
betas = create_betas(number_of_layers)
gammas = create_gammas(number_of_layers)
symbols_map = create_symbols_map(number_of_layers)
for layer_id in range(number_of_layers):
beta = betas[layer_id]
gamma = gammas[layer_id]
target_circuit += RZ(2.0 * gamma)(0)
target_circuit += RZ(2.0 * gamma)(1)
target_circuit += RY(-thetas[0])(0)
target_circuit += RY(-thetas[1])(1)
target_circuit += RZ(-2.0 * beta)(0)
target_circuit += RZ(-2.0 * beta)(1)
target_circuit += RY(thetas[0])(0)
target_circuit += RY(thetas[1])(1)
return target_circuit.bind(symbols_map).to_unitary()
def create_2_qubit_x_operator(qubit1: int, qubit2: int, param):
return Circuit(
[
H(qubit1),
H(qubit2),
CNOT(qubit1, qubit2),
RZ(2 * param)(qubit2),
CNOT(qubit1, qubit2),
H(qubit1),
H(qubit2),
]
)
def _build_rotational_subcircuit(self, circuit: Circuit,
parameters: np.ndarray) -> Circuit:
"""Add the subcircuit which includes several rotation gates acting on each qubit
Args:
circuit: The circuit to append to
parameters: The variational parameters (or symbolic parameters)
Returns:
circuit with added rotational sub-layer
"""
# Add RZ(theta) RX(pi/2) RZ(theta') RX(pi/2) RZ(theta'')
for qubit_index in range(self.number_of_qubits):
qubit_parameters = parameters[qubit_index * 3:(qubit_index + 1) *
3]
circuit += RZ(qubit_parameters[0])(qubit_index)
circuit += RX(np.pi / 2)(qubit_index)
circuit += RZ(qubit_parameters[1])(qubit_index)
circuit += RX(np.pi / 2)(qubit_index)
circuit += RZ(qubit_parameters[2])(qubit_index)
return circuit
class TestCreatingUnitaryFromCircuit:
@pytest.fixture
def cirq_unitaries(self):
"""
Note: We decided to go with file-based approach after extracting cirq
from z-quantum-core and not being able to use `export_to_cirq` anymore.
"""
path_to_array = ("/".join(__file__.split("/")[:-1]) +
"/hardcoded_cirq_unitaries.npy")
return np.load(path_to_array, allow_pickle=True)
@pytest.mark.parametrize(
"circuit, unitary_index",
[
# Identity gates in some test cases below are used so that comparable
# Cirq circuits have the same number of qubits as Zquantum ones.
(Circuit([RX(np.pi / 5)(0)]), 0),
(Circuit([RY(np.pi / 2)(0), RX(np.pi / 5)(0)]), 1),
(
Circuit(
[I(1),
I(2),
I(3),
I(4),
RX(np.pi / 5)(0),
XX(0.1)(5, 0)]),
2,
),
(
Circuit([
XY(np.pi).controlled(1)(3, 1, 4),
RZ(0.1 * np.pi).controlled(2)(0, 2, 1),
]),
3,
),
(
Circuit(
[H(1),
YY(0.1).controlled(1)(0, 1, 2),
X(2),
Y(3),
Z(4)]),
4,
),
],
)
def test_without_free_params_gives_the_same_result_as_cirq(
self, circuit, unitary_index, cirq_unitaries):
zquantum_unitary = circuit.to_unitary()
assert isinstance(
zquantum_unitary, np.ndarray
), "Unitary constructed from non-parameterized circuit is not a numpy array."
np.testing.assert_array_almost_equal(zquantum_unitary,
cirq_unitaries[unitary_index])
def test_commutes_with_parameter_substitution(self):
theta, gamma = sympy.symbols("theta, gamma")
circuit = Circuit([
RX(theta / 2)(0),
X(1),
RY(gamma / 4).controlled(1)(1, 2),
YY(0.1)(0, 4)
])
symbols_map = {theta: 0.1, gamma: 0.5}
parameterized_unitary = circuit.to_unitary()
unitary = circuit.bind(symbols_map).to_unitary()
np.testing.assert_array_almost_equal(
np.array(parameterized_unitary.subs(symbols_map), dtype=complex),
unitary)
_backend = SymbolicSimulator(seed=1997)
_estimation_tasks = [
EstimationTask(IsingOperator("Z0"), Circuit([H(0)]), 10000),
EstimationTask(
IsingOperator("Z0") + IsingOperator("Z1") + IsingOperator("Z2"),
Circuit([H(0), RX(np.pi / 3)(0), H(2)]),
10000,
),
EstimationTask(
IsingOperator("Z0") + IsingOperator("Z1", 4),
Circuit([
RX(np.pi)(0),
RY(0.12)(1),
RZ(np.pi / 3)(1),
RY(1.9213)(0),
]),
10000,
),
]
def _validate_each_task_returns_one_expecation_value(
estimator: EstimateExpectationValues, ):
# When
expectation_values = estimator(
backend=_backend,
estimation_tasks=_estimation_tasks,
)
class TestEstimatorUtils:
def test_get_context_selection_circuit_for_group(self):
group = QubitOperator("X0 Y1") - 0.5 * QubitOperator((1, "Y"))
circuit, ising_operator = get_context_selection_circuit_for_group(
group)
# Need to convert to QubitOperator in order to get matrix representation
qubit_operator = change_operator_type(ising_operator, QubitOperator)
target_unitary = qubit_operator_sparse(group)
transformed_unitary = (
circuit.to_unitary().conj().T
@ qubit_operator_sparse(qubit_operator) @ circuit.to_unitary())
assert np.allclose(target_unitary.todense(), transformed_unitary)
def test_perform_context_selection(self):
target_operators = []
target_operators.append(10.0 * QubitOperator("Z0"))
target_operators.append(-3 * QubitOperator("Y0"))
target_operators.append(1 * QubitOperator("X0"))
target_operators.append(20 * QubitOperator(""))
expected_operators = []
expected_operators.append(10.0 * QubitOperator("Z0"))
expected_operators.append(-3 * QubitOperator("Z0"))
expected_operators.append(1 * QubitOperator("Z0"))
expected_operators.append(20 * QubitOperator(""))
base_circuit = Circuit([X(0)])
x_term_circuit = Circuit([RY(-np.pi / 2)(0)])
y_term_circuit = Circuit([RX(np.pi / 2)(0)])
expected_circuits = [
base_circuit,
base_circuit + y_term_circuit,
base_circuit + x_term_circuit,
base_circuit,
]
estimation_tasks = [
EstimationTask(operator, base_circuit, None)
for operator in target_operators
]
tasks_with_context_selection = perform_context_selection(
estimation_tasks)
for task, expected_circuit, expected_operator in zip(
tasks_with_context_selection, expected_circuits,
expected_operators):
assert task.operator.terms == expected_operator.terms
assert task.circuit == expected_circuit
@pytest.fixture()
def frame_operators(self):
operators = [
2.0 * IsingOperator((1, "Z")) * IsingOperator((2, "Z")),
1.0 * IsingOperator((3, "Z")) * IsingOperator((0, "Z")),
-1.0 * IsingOperator((2, "Z")),
]
return operators
@pytest.fixture()
def circuits(self):
circuits = [Circuit() for _ in range(5)]
circuits[1] += RX(1.2)(0)
circuits[1] += RY(1.5)(1)
circuits[1] += RX(-0.0002)(0)
circuits[1] += RY(0)(1)
for circuit in circuits[2:]:
circuit += RX(sympy.Symbol("theta_0"))(0)
circuit += RY(sympy.Symbol("theta_1"))(1)
circuit += RX(sympy.Symbol("theta_2"))(0)
circuit += RY(sympy.Symbol("theta_3"))(1)
return circuits
@pytest.mark.parametrize(
"n_samples, target_n_samples_list",
[
(100, [100, 100, 100]),
(17, [17, 17, 17]),
],
)
def test_allocate_shots_uniformly(
self,
frame_operators,
n_samples,
target_n_samples_list,
):
allocate_shots = partial(allocate_shots_uniformly,
number_of_shots=n_samples)
circuit = Circuit()
estimation_tasks = [
EstimationTask(operator, circuit, 1)
for operator in frame_operators
]
new_estimation_tasks = allocate_shots(estimation_tasks)
for task, target_n_samples in zip(new_estimation_tasks,
target_n_samples_list):
assert task.number_of_shots == target_n_samples
@pytest.mark.parametrize(
"total_n_shots, prior_expectation_values, target_n_samples_list",
[
(400, None, [200, 100, 100]),
(400, ExpectationValues(np.array([0, 0, 0])), [200, 100, 100]),
(400, ExpectationValues(np.array([1, 0.3, 0.3])), [0, 200, 200]),
],
)
def test_allocate_shots_proportionally(
self,
frame_operators,
total_n_shots,
prior_expectation_values,
target_n_samples_list,
):
allocate_shots = partial(
allocate_shots_proportionally,
total_n_shots=total_n_shots,
prior_expectation_values=prior_expectation_values,
)
circuit = Circuit()
estimation_tasks = [
EstimationTask(operator, circuit, 1)
for operator in frame_operators
]
new_estimation_tasks = allocate_shots(estimation_tasks)
for task, target_n_samples in zip(new_estimation_tasks,
target_n_samples_list):
assert task.number_of_shots == target_n_samples
@pytest.mark.parametrize(
"n_samples",
[-1],
)
def test_allocate_shots_uniformly_invalid_inputs(
self,
n_samples,
):
estimation_tasks = []
with pytest.raises(ValueError):
allocate_shots_uniformly(estimation_tasks,
number_of_shots=n_samples)
@pytest.mark.parametrize(
"total_n_shots, prior_expectation_values",
[
(-1, ExpectationValues(np.array([0, 0, 0]))),
],
)
def test_allocate_shots_proportionally_invalid_inputs(
self,
total_n_shots,
prior_expectation_values,
):
estimation_tasks = []
with pytest.raises(ValueError):
_ = allocate_shots_proportionally(estimation_tasks, total_n_shots,
prior_expectation_values)
def test_evaluate_estimation_circuits_no_symbols(
self,
circuits,
):
evaluate_circuits = partial(evaluate_estimation_circuits,
symbols_maps=[[] for _ in circuits])
operator = QubitOperator()
estimation_tasks = [
EstimationTask(operator, circuit, 1) for circuit in circuits
]
new_estimation_tasks = evaluate_circuits(estimation_tasks)
for old_task, new_task in zip(estimation_tasks, new_estimation_tasks):
assert old_task.circuit == new_task.circuit
def test_evaluate_estimation_circuits_all_symbols(
self,
circuits,
):
symbols_maps = [[
(sympy.Symbol("theta_0"), 0),
(sympy.Symbol("theta_1"), 0),
(sympy.Symbol("theta_2"), 0),
(sympy.Symbol("theta_3"), 0),
] for _ in circuits]
evaluate_circuits = partial(
evaluate_estimation_circuits,
symbols_maps=symbols_maps,
)
operator = QubitOperator()
estimation_tasks = [
EstimationTask(operator, circuit, 1) for circuit in circuits
]
new_estimation_tasks = evaluate_circuits(estimation_tasks)
for new_task in new_estimation_tasks:
assert len(new_task.circuit.free_symbols) == 0
def test_group_greedily_all_different_groups(self):
target_operator = 10.0 * QubitOperator("Z0")
target_operator -= 3.0 * QubitOperator("Y0")
target_operator += 1.0 * QubitOperator("X0")
target_operator += 20.0 * QubitOperator("")
expected_operators = [
10.0 * QubitOperator("Z0"),
-3.0 * QubitOperator("Y0"),
1.0 * QubitOperator("X0"),
20.0 * QubitOperator(""),
]
circuit = Circuit([X(0)])
estimation_tasks = [EstimationTask(target_operator, circuit, None)]
grouped_tasks = group_greedily(estimation_tasks)
for task, operator in zip(grouped_tasks, expected_operators):
assert task.operator == operator
for initial_task, modified_task in zip(estimation_tasks,
grouped_tasks):
assert modified_task.circuit == initial_task.circuit
assert modified_task.number_of_shots == initial_task.number_of_shots
def test_group_greedily_all_comeasureable(self):
target_operator = 10.0 * QubitOperator("Y0")
target_operator -= 3.0 * QubitOperator("Y0 Y1")
target_operator += 1.0 * QubitOperator("Y1")
target_operator += 20.0 * QubitOperator("Y0 Y1 Y2")
circuit = Circuit([X(0), X(1), X(2)])
estimation_tasks = [EstimationTask(target_operator, circuit, None)]
grouped_tasks = group_greedily(estimation_tasks)
assert len(grouped_tasks) == 1
assert grouped_tasks[0].operator == target_operator
for initial_task, modified_task in zip(estimation_tasks,
grouped_tasks):
assert modified_task.circuit == initial_task.circuit
assert modified_task.number_of_shots == initial_task.number_of_shots
def test_group_individually(self):
target_operator = 10.0 * QubitOperator("Z0")
target_operator += 5.0 * QubitOperator("Z1")
target_operator -= 3.0 * QubitOperator("Y0")
target_operator += 1.0 * QubitOperator("X0")
target_operator += 20.0 * QubitOperator("")
expected_operator_terms_per_frame = [
(10.0 * QubitOperator("Z0")).terms,
(5.0 * QubitOperator("Z1")).terms,
(-3.0 * QubitOperator("Y0")).terms,
(1.0 * QubitOperator("X0")).terms,
(20.0 * QubitOperator("")).terms,
]
circuit = Circuit([X(0)])
estimation_tasks = [EstimationTask(target_operator, circuit, None)]
grouped_tasks = group_individually(estimation_tasks)
assert len(grouped_tasks) == 5
for task in grouped_tasks:
assert task.operator.terms in expected_operator_terms_per_frame
@pytest.mark.parametrize(
",".join([
"estimation_tasks",
"ref_estimation_tasks_to_measure",
"ref_non_measured_estimation_tasks",
"ref_indices_to_measure",
"ref_non_measured_indices",
]),
[
(
[
EstimationTask(IsingOperator("2[Z0] + 3 [Z1 Z2]"),
Circuit([X(0)]), 10),
EstimationTask(
IsingOperator("2[Z0] + 3 [Z1 Z2] + 4[]"),
Circuit([RZ(np.pi / 2)(0)]),
1000,
),
EstimationTask(
IsingOperator("4[Z3]"),
Circuit([RY(np.pi / 2)(0)]),
17,
),
],
[
EstimationTask(IsingOperator("2[Z0] + 3 [Z1 Z2]"),
Circuit([X(0)]), 10),
EstimationTask(
IsingOperator("2[Z0] + 3 [Z1 Z2] + 4 []"),
Circuit([RZ(np.pi / 2)(0)]),
1000,
),
EstimationTask(
IsingOperator("4[Z3]"),
Circuit([RY(np.pi / 2)(0)]),
17,
),
],
[],
[0, 1, 2],
[],
),
(
[
EstimationTask(IsingOperator("2[Z0] + 3 [Z1 Z2]"),
Circuit([X(0)]), 10),
EstimationTask(
IsingOperator("4[] "),
Circuit([RZ(np.pi / 2)(0)]),
1000,
),
EstimationTask(
IsingOperator("4[Z3]"),
Circuit([RY(np.pi / 2)(0)]),
17,
),
],
[
EstimationTask(IsingOperator("2[Z0] + 3 [Z1 Z2]"),
Circuit([X(0)]), 10),
EstimationTask(
IsingOperator("4[Z3]"),
Circuit([RY(np.pi / 2)(0)]),
17,
),
],
[
EstimationTask(IsingOperator("4[]"),
Circuit([RZ(np.pi / 2)(0)]), 1000)
],
[0, 2],
[1],
),
(
[
EstimationTask(IsingOperator("- 3 []"), Circuit([X(0)]),
0),
EstimationTask(
IsingOperator("2[Z0] + 3 [Z1 Z2] + 4[]"),
Circuit([RZ(np.pi / 2)(0)]),
1000,
),
EstimationTask(
IsingOperator("4[Z3]"),
Circuit([RY(np.pi / 2)(0)]),
17,
),
],
[
EstimationTask(
IsingOperator("2[Z0] + 3 [Z1 Z2] + 4 []"),
Circuit([RZ(np.pi / 2)(0)]),
1000,
),
EstimationTask(
IsingOperator("4[Z3]"),
Circuit([RY(np.pi / 2)(0)]),
17,
),
],
[
EstimationTask(IsingOperator("- 3 []"), Circuit([X(0)]),
0),
],
[1, 2],
[0],
),
(
[
EstimationTask(IsingOperator("- 3 []"), Circuit([X(0)]),
0),
EstimationTask(
IsingOperator("2[Z0] + 3 [Z1 Z2] + 4[]"),
Circuit([RZ(np.pi / 2)(0)]),
1000,
),
EstimationTask(
IsingOperator("4[Z3]"),
Circuit([RY(np.pi / 2)(0)]),
0,
),
],
[
EstimationTask(
IsingOperator("2[Z0] + 3 [Z1 Z2] + 4 []"),
Circuit([RZ(np.pi / 2)(0)]),
1000,
),
],
[
EstimationTask(IsingOperator("- 3 []"), Circuit([X(0)]),
0),
EstimationTask(
IsingOperator("4[Z3]"),
Circuit([RY(np.pi / 2)(0)]),
0,
),
],
[1],
[0, 2],
),
],
)
def test_split_estimation_tasks_to_measure(
self,
estimation_tasks,
ref_estimation_tasks_to_measure,
ref_non_measured_estimation_tasks,
ref_indices_to_measure,
ref_non_measured_indices,
):
(
estimation_task_to_measure,
non_measured_estimation_tasks,
indices_to_measure,
indices_for_non_measureds,
) = split_estimation_tasks_to_measure(estimation_tasks)
assert estimation_task_to_measure == ref_estimation_tasks_to_measure
assert non_measured_estimation_tasks == ref_non_measured_estimation_tasks
assert indices_to_measure == ref_indices_to_measure
assert ref_non_measured_indices == indices_for_non_measureds
@pytest.mark.parametrize(
"estimation_tasks,ref_expectation_values",
[
(
[
EstimationTask(
IsingOperator("4[] "),
Circuit([RZ(np.pi / 2)(0)]),
1000,
),
],
[
ExpectationValues(
np.asarray([4.0]),
correlations=[np.asarray([[0.0]])],
estimator_covariances=[np.asarray([[0.0]])],
),
],
),
(
[
EstimationTask(IsingOperator("- 2.5 [] - 0.5 []"),
Circuit([X(0)]), 0),
EstimationTask(IsingOperator("0.001[] "),
Circuit([RZ(np.pi / 2)(0)]), 2),
EstimationTask(
IsingOperator("2.5 [Z1] + 1.0 [Z2 Z3]"),
Circuit([RY(np.pi / 2)(0)]),
0,
),
],
[
ExpectationValues(
np.asarray([-3.0]),
correlations=[np.asarray([[0.0]])],
estimator_covariances=[np.asarray([[0.0]])],
),
ExpectationValues(
np.asarray([0.001]),
correlations=[np.asarray([[0.0]])],
estimator_covariances=[np.asarray([[0.0]])],
),
ExpectationValues(
np.asarray([0.0]),
correlations=[np.asarray([[0.0]])],
estimator_covariances=[np.asarray([[0.0]])],
),
],
),
],
)
def test_evaluate_non_measured_estimation_tasks(self, estimation_tasks,
ref_expectation_values):
expectation_values = evaluate_non_measured_estimation_tasks(
estimation_tasks)
for ex_val, ref_ex_val in zip(expectation_values,
ref_expectation_values):
assert np.allclose(ex_val.values, ref_ex_val.values)
assert np.allclose(ex_val.correlations, ref_ex_val.correlations)
assert np.allclose(ex_val.estimator_covariances,
ref_ex_val.estimator_covariances)
@pytest.mark.parametrize(
"estimation_tasks",
[
([
EstimationTask(IsingOperator("- 2.5 [] - 0.5 [Z1]"),
Circuit([X(0)]), 1),
]),
([
EstimationTask(
IsingOperator("0.001 [Z0]"),
Circuit([RZ(np.pi / 2)(0)]),
0,
),
EstimationTask(IsingOperator("2.0[] "),
Circuit([RZ(np.pi / 2)(0)]), 2),
EstimationTask(
IsingOperator("1.5 [Z0 Z1]"),
Circuit([RY(np.pi / 2)(0)]),
10,
),
]),
],
)
def test_evaluate_non_measured_estimation_tasks_fails_with_non_zero_shots(
self, estimation_tasks):
with pytest.raises(RuntimeError):
_ = evaluate_non_measured_estimation_tasks(estimation_tasks)
def create_x_operator(qubit: int, param):
return Circuit([H(qubit), RZ(2 * param)(qubit), H(qubit)])