def test_three_qubit_local_depolarizing_representation_error():
q0, q1, q2 = LineQubit.range(3)
with pytest.raises(ValueError):
represent_operation_with_local_depolarizing_noise(
Circuit(CCNOT(q0, q1, q2)),
0.05,
)
def test_sample_sequence_choi(gate: cirq.Gate):
"""Tests the sample_sequence by comparing the exact Choi matrices."""
qreg = cirq.LineQubit.range(gate.num_qubits())
ideal_op = gate.on(*qreg)
ideal_circ = cirq.Circuit(ideal_op)
noisy_op_tree = [ideal_op] + [cirq.depolarize(BASE_NOISE)(q) for q in qreg]
ideal_choi = _operation_to_choi(ideal_op)
noisy_choi = _operation_to_choi(noisy_op_tree)
representation = represent_operation_with_local_depolarizing_noise(
ideal_circ,
BASE_NOISE,
)
choi_unbiased_estimates = []
rng = np.random.RandomState(1)
for _ in range(500):
imp_seqs, signs, norm = sample_sequence(ideal_circ, [representation],
random_state=rng)
noisy_sequence = imp_seqs[0].with_noise(cirq.depolarize(BASE_NOISE))
sequence_choi = _circuit_to_choi(noisy_sequence)
choi_unbiased_estimates.append(norm * signs[0] * sequence_choi)
choi_pec_estimate = np.average(choi_unbiased_estimates, axis=0)
noise_error = np.linalg.norm(ideal_choi - noisy_choi)
pec_error = np.linalg.norm(ideal_choi - choi_pec_estimate)
assert pec_error < noise_error
assert np.allclose(ideal_choi, choi_pec_estimate, atol=0.05)
def test_find_optimal_representation_depolarizing_two_qubit_gates(circ_type):
"""Test optimal representation agrees with a known analytic result."""
for ideal_gate, noise_level in product([CNOT, CZ], [0.1, 0.5]):
q = LineQubit.range(2)
ideal_op = Circuit(ideal_gate(*q))
implementable_circuits = [Circuit(ideal_op)]
# Append two-qubit-gate with Paulis on one qubit
for gate in [X, Y, Z]:
implementable_circuits.append(Circuit([ideal_op, gate(q[0])]))
implementable_circuits.append(Circuit([ideal_op, gate(q[1])]))
# Append two-qubit gate with Paulis on both qubits
for gate_a, gate_b in product([X, Y, Z], repeat=2):
implementable_circuits.append(
Circuit([ideal_op, gate_a(q[0]), gate_b(q[1])])
)
noisy_circuits = [
circ + Circuit(DepolarizingChannel(noise_level).on_each(*q))
for circ in implementable_circuits
]
super_operators = [
choi_to_super(_circuit_to_choi(circ)) for circ in noisy_circuits
]
# Define circuits with native types
implementable_native = [
convert_from_mitiq(c, circ_type) for c in implementable_circuits
]
ideal_op_native = convert_from_mitiq(ideal_op, circ_type)
noisy_operations = [
NoisyOperation(ideal, real)
for ideal, real in zip(implementable_native, super_operators)
]
# Find optimal representation
noisy_basis = NoisyBasis(*noisy_operations)
rep = find_optimal_representation(
ideal_op_native, noisy_basis, tol=1.0e-8
)
# Expected analytical result
expected_rep = represent_operation_with_local_depolarizing_noise(
ideal_op_native,
noise_level,
)
assert np.allclose(np.sort(rep.coeffs), np.sort(expected_rep.coeffs))
assert rep == expected_rep
def test_local_depolarizing_representation_with_choi(gate: Gate, noise: float):
"""Tests the representation by comparing exact Choi matrices."""
qreg = LineQubit.range(gate.num_qubits())
ideal_choi = _operation_to_choi(gate.on(*qreg))
op_rep = represent_operation_with_local_depolarizing_noise(
Circuit(gate.on(*qreg)), noise,
)
choi_components = []
for noisy_op, coeff in op_rep.basis_expansion.items():
implementable_circ = noisy_op.circuit()
# The representation assume local noise on each qubit.
depolarizing_op = DepolarizingChannel(noise).on_each(*qreg)
# Apply noise after each sequence.
# NOTE: noise is not applied after each operation.
implementable_circ.append(depolarizing_op)
sequence_choi = _circuit_to_choi(implementable_circ)
choi_components.append(coeff * sequence_choi)
combination_choi = np.sum(choi_components, axis=0)
assert np.allclose(ideal_choi, combination_choi, atol=10 ** -6)
def test_find_optimal_representation_single_qubit_depolarizing(circ_type):
"""Test optimal representation agrees with a known analytic result."""
for ideal_gate, noise_level in product([X, Y, H], [0.1, 0.3]):
q = LineQubit(0)
ideal_op = Circuit(ideal_gate(q))
implementable_circuits = [Circuit(ideal_op)]
# Add ideal gate followed by Paulis
for gate in [X, Y, Z]:
implementable_circuits.append(Circuit([ideal_op, gate(q)]))
noisy_circuits = [
circ + Circuit(DepolarizingChannel(noise_level).on_each(q))
for circ in implementable_circuits
]
super_operators = [
choi_to_super(_circuit_to_choi(circ)) for circ in noisy_circuits
]
# Define circuits with native types
implementable_native = [
convert_from_mitiq(c, circ_type) for c in implementable_circuits
]
ideal_op_native = convert_from_mitiq(ideal_op, circ_type)
noisy_operations = [
NoisyOperation(ideal, real)
for ideal, real in zip(implementable_native, super_operators)
]
# Find optimal representation
noisy_basis = NoisyBasis(*noisy_operations)
rep = find_optimal_representation(
ideal_op_native, noisy_basis, tol=1.0e-8
)
# Expected analytical result
expected_rep = represent_operation_with_local_depolarizing_noise(
ideal_op_native,
noise_level,
)
assert np.allclose(np.sort(rep.coeffs), np.sort(expected_rep.coeffs))
assert rep == expected_rep
def test_sample_circuit_choi():
"""Tests the sample_circuit by comparing the exact Choi matrices."""
# A simple 2-qubit circuit
qreg = cirq.LineQubit.range(2)
ideal_circ = cirq.Circuit(
cirq.X.on(qreg[0]),
cirq.I.on(qreg[1]),
cirq.CNOT.on(*qreg),
)
noisy_circuit = ideal_circ.with_noise(cirq.depolarize(BASE_NOISE))
ideal_choi = _circuit_to_choi(ideal_circ)
noisy_choi = _operation_to_choi(noisy_circuit)
rep_list = []
for op in ideal_circ.all_operations():
rep_list.append(
represent_operation_with_local_depolarizing_noise(
cirq.Circuit(op),
BASE_NOISE,
))
choi_unbiased_estimates = []
rng = np.random.RandomState(1)
for _ in range(500):
imp_circ, sign, norm = sample_circuit(ideal_circ,
rep_list,
random_state=rng)
noisy_imp_circ = imp_circ.with_noise(cirq.depolarize(BASE_NOISE))
sequence_choi = _circuit_to_choi(noisy_imp_circ)
choi_unbiased_estimates.append(norm * sign * sequence_choi)
choi_pec_estimate = np.average(choi_unbiased_estimates, axis=0)
noise_error = np.linalg.norm(ideal_choi - noisy_choi)
pec_error = np.linalg.norm(ideal_choi - choi_pec_estimate)
assert pec_error < noise_error
assert np.allclose(ideal_choi, choi_pec_estimate, atol=0.05)
def get_pauli_representations(
base_noise: float,
qubits: Optional[List[cirq.Qid]] = None,
) -> List[OperationRepresentation]:
if qubits is None:
qreg = cirq.LineQubit.range(2)
else:
qreg = qubits
# Generate all ideal single-qubit Pauli operations for both qubits
pauli_gates = [cirq.X, cirq.Y, cirq.Z]
ideal_operations = []
for gate in pauli_gates:
for qubit in qreg:
ideal_operations.append(cirq.Circuit(gate(qubit)))
# Generate all ideal 2-qubit Pauli operations
for gate_a, gate_b in product(pauli_gates, repeat=2):
ideal_operations.append(
cirq.Circuit([gate_a(qreg[0]), gate_b(qreg[1])]))
# Add CNOT too
ideal_operations.append(cirq.Circuit(cirq.CNOT(*qreg)))
# Generate all representations
reps = []
for op in ideal_operations:
reps.append(
represent_operation_with_local_depolarizing_noise(
op,
base_noise,
))
return reps
