def test_qubitop_to_paulisum_more_terms(self):
# Given
qubit_operator = (
QubitOperator("Z0 Z1 Z2", -1.5)
+ QubitOperator("X0", 2.5)
+ QubitOperator("Y1", 3.5)
)
expected_qubits = (LineQubit(0), LineQubit(5), LineQubit(8))
expected_paulisum = (
PauliSum()
+ (
PauliString(Z.on(expected_qubits[0]))
* PauliString(Z.on(expected_qubits[1]))
* PauliString(Z.on(expected_qubits[2]))
* -1.5
)
+ (PauliString(X.on(expected_qubits[0]) * 2.5))
+ (PauliString(Y.on(expected_qubits[1]) * 3.5))
)
# When
paulisum = qubitop_to_paulisum(qubit_operator, qubits=expected_qubits)
# Then
self.assertEqual(paulisum.qubits, expected_qubits)
self.assertEqual(paulisum, expected_paulisum)
def test_simple_pauli_deco_dict_CNOT():
"""Tests that the _simple_pauli_deco_dict function returns a decomposition
dicitonary which is consistent with a local depolarizing noise model.
The channel acting on the state each qubit is assumed to be:
D(rho) = = (1 - epsilon) rho + epsilon I/2
= (1 - p) rho + p/3 (X rho X + Y rho Y^dag + Z rho Z)
"""
# Deduce epsilon from BASE_NOISE
epsilon = BASE_NOISE * 4.0 / 3.0
c_neg = -(1 / 4) * epsilon / (1 - epsilon)
c_pos = 1 - 3 * c_neg
qreg = LineQubit.range(2)
# Get the decomposition of a CNOT gate
deco = DECO_DICT[CNOT.on(*qreg)]
# The first term of 'deco' corresponds to no error occurring
first_coefficient, first_imp_seq = deco[0]
assert np.isclose(c_pos * c_pos, first_coefficient)
assert first_imp_seq == [CNOT.on(*qreg)]
# The second term corresponds to a Pauli X error on one qubit
second_coefficient, second_imp_seq = deco[1]
assert np.isclose(c_pos * c_neg, second_coefficient)
assert second_imp_seq == [CNOT.on(*qreg), X.on(qreg[0])]
# The last term corresponds to two Pauli Z errors on both qubits
last_coefficient, last_imp_seq = deco[-1]
assert np.isclose(c_neg * c_neg, last_coefficient)
assert last_imp_seq == [CNOT.on(*qreg), Z.on(qreg[0]), Z.on(qreg[1])]
def test_simplify_circuit_exponents():
qreg = LineQubit.range(2)
circuit = Circuit([H.on(qreg[0]), CNOT.on(*qreg), Z.on(qreg[1])])
# Invert circuit
inverse_circuit = cirq.inverse(circuit)
inverse_repr = inverse_circuit.__repr__()
inverse_qasm = inverse_circuit._to_qasm_output().__str__()
# Expected circuit after simplification
expected_inv = Circuit([Z.on(qreg[1]), CNOT.on(*qreg), H.on(qreg[0])])
expected_repr = expected_inv.__repr__()
expected_qasm = expected_inv._to_qasm_output().__str__()
# Check inverse_circuit is logically equivalent to expected_inverse
# but they have a different representation
assert inverse_circuit == expected_inv
assert inverse_repr != expected_repr
assert inverse_qasm != expected_qasm
# Simplify the circuit
_simplify_circuit_exponents(inverse_circuit)
# Check inverse_circuit has the expected simplified representation
simplified_repr = inverse_circuit.__repr__()
simplified_qasm = inverse_circuit._to_qasm_output().__str__()
assert inverse_circuit == expected_inv
assert simplified_repr == expected_repr
assert simplified_qasm == expected_qasm
def test_qubitop_to_paulisum_z0z1_operator(self):
# Given
qubit_operator = QubitOperator("Z0 Z1", -1.5)
expected_qubits = (GridQubit(0, 0), GridQubit(1, 0))
expected_paulisum = (PauliSum() +
PauliString(Z.on(expected_qubits[0])) *
PauliString(Z.on(expected_qubits[1])) * -1.5)
# When
paulisum = qubitop_to_paulisum(qubit_operator)
# Then
self.assertEqual(paulisum.qubits, expected_qubits)
self.assertEqual(paulisum, expected_paulisum)
def test_qubitop_to_paulisum_setting_qubits(self):
# Given
qubit_operator = QubitOperator("Z0 Z1", -1.5)
expected_qubits = (LineQubit(0), LineQubit(5))
expected_paulisum = (PauliSum() +
PauliString(Z.on(expected_qubits[0])) *
PauliString(Z.on(expected_qubits[1])) * -1.5)
# When
paulisum = qubitop_to_paulisum(qubit_operator, qubits=expected_qubits)
# Then
self.assertEqual(paulisum.qubits, expected_qubits)
self.assertEqual(paulisum, expected_paulisum)
def test_joined_generator(self):
generator1 = TwoRotsGenerator()
generator2 = OneRotGenerator()
grad = op_tree_generator_grad(
OpTreeGenerator.join(generator1, generator2),
rad
)
grad_lco = LinearCombinationOfOperations({
_generator((q0, q1)): _coeff for _generator, _coeff in grad.items()
})
for _generator, _coeff in grad.items():
print(_generator.diagram(), _coeff)
exact_grad_lco = LinearCombinationOfOperations({
(X(q0), rx(rad).on(q0), rz(rad).on(q1), ry(c * rad).on(q0)): -0.5j,
(rx(rad).on(q0), Z(q1), rz(rad).on(q1), ry(c * rad).on(q0)): -0.5j,
(rx(rad).on(q0), rz(rad).on(q1), Y(q0), ry(c * rad).on(q0)): -0.5j * c,
})
param_resolver = {
rad: np.random.rand() * 4 * np.pi,
c: np.random.rand()
}
grad_lco = cirq.resolve_parameters(grad_lco, param_resolver)
exact_grad_lco = cirq.resolve_parameters(exact_grad_lco, param_resolver)
test_lco_identical_with_simulator(
grad_lco,
exact_grad_lco,
self
)
def _represent_operation_with_amplitude_damping_noise(
ideal_operation: Circuit,
noise_level: float,
) -> OperationRepresentation:
r"""Returns the quasi-probability representation of the input
single-qubit ``ideal_operation`` with respect to a basis of noisy
operations.
Any ideal single-qubit unitary followed by local amplitude-damping noise
of equal ``noise_level`` is assumed to be in the basis of implementable
operations.
The representation is based on the analytical result presented
in :cite:`Takagi2020`.
Args:
ideal_operation: The ideal operation (as a QPROGRAM) to represent.
noise_level: The noise level of each amplitude damping channel.
Returns:
The quasi-probability representation of the ``ideal_operation``.
.. note::
The input ``ideal_operation`` is typically a QPROGRAM with a single
gate but could also correspond to a sequence of more gates.
This is possible as long as the unitary associated to the input
QPROGRAM, followed by a single final amplitude damping channel, is
physically implementable.
.. note::
The input ``ideal_operation`` must be a ``cirq.Circuit``.
"""
if not isinstance(ideal_operation, Circuit):
raise NotImplementedError(
"The input ideal_operation must be a cirq.Circuit.", )
qubits = ideal_operation.all_qubits()
if len(qubits) == 1:
q = tuple(qubits)[0]
eta_0 = (1 + np.sqrt(1 - noise_level)) / (2 * (1 - noise_level))
eta_1 = (1 - np.sqrt(1 - noise_level)) / (2 * (1 - noise_level))
eta_2 = -noise_level / (1 - noise_level)
etas = [eta_0, eta_1, eta_2]
post_ops = [[], Z(q), reset(q)]
else:
raise ValueError( # pragma: no cover
"Only single-qubit operations are supported." # pragma: no cover
) # pragma: no cover
# Basis of implementable operations as circuits
imp_op_circuits = [ideal_operation + Circuit(op) for op in post_ops]
# Build basis_expantion
expansion = {NoisyOperation(c): a for c, a in zip(imp_op_circuits, etas)}
return OperationRepresentation(ideal_operation, expansion)
def test_get_imp_sequences_no_simplify(gate: Gate):
q = LineQubit(0)
expected_imp_sequences = [
[gate.on(q)],
[gate.on(q), X.on(q)],
[gate.on(q), Y.on(q)],
[gate.on(q), Z.on(q)],
]
assert get_imp_sequences(gate.on(q), DECO_DICT) == expected_imp_sequences
def test_aqt_sampler_wrong_gate():
repetitions = 100
num_qubits = 4
device, qubits = get_aqt_device(num_qubits)
sampler = AQTRemoteSimulator()
circuit = Circuit(device=device)
circuit.append(Y(qubits[0])**0.5)
circuit.append(Z(qubits[0])**0.5)
with pytest.raises(ValueError):
_results = sampler.run(circuit, repetitions=repetitions)
def test_aqt_sampler_ms():
repetitions = 1000
num_qubits = 4
device, qubits = get_aqt_device(num_qubits)
sampler = AQTSamplerLocalSimulator()
circuit = Circuit(device=device)
for _dummy in range(9):
circuit.append(XX(qubits[0], qubits[1])**0.5)
circuit.append(Z(qubits[0])**0.5)
results = sampler.run(circuit, repetitions=repetitions)
hist = (results.histogram(key='m'))
assert hist[12] > repetitions / 3
assert hist[0] > repetitions / 3
def test_x_crosstalk_n_noise():
num_qubits = 4
noise_mod = AQTNoiseModel()
device, qubits = get_aqt_device(num_qubits)
circuit = Circuit(device=device)
circuit.append(Y(qubits[1])**0.5)
circuit.append(Z(qubits[1])**0.5)
circuit.append(X(qubits[1])**0.5)
for moment in circuit.moments:
noisy_moment = noise_mod.noisy_moment(moment, qubits)
assert noisy_moment == [(cirq.X**0.5).on(cirq.LineQubit(1)),
cirq.depolarize(p=0.001).on(cirq.LineQubit(1)),
(cirq.X**0.015).on(cirq.LineQubit(0)),
(cirq.X**0.015).on(cirq.LineQubit(2))]
def qubit_op_to_gate(operation: 'QubitOperator',
qubit) -> 'SingleQubitPauliStringGateOperation':
"""Convert a qubit operation into a gate operations that can be digested
by a Cirq simulator.
Args:
operation (QubitOperator)
qubit (Qid) - a qubit on which the Pauli matrices will act.
Returns:
(gate) - a gate that can be executed on the qubit passed
"""
if operation == 'X':
return X.on(qubit)
if operation == 'Y':
return Y.on(qubit)
if operation == 'Z':
return Z.on(qubit)
raise ValueError('No gate identified in qubit_op_to_gate')
def test_simple_generator(self):
generator = TwoRotsGenerator()
grad_lcg = op_tree_generator_grad(generator, rad)
grad_lco = LinearCombinationOfOperations({
_generator((q0, q1)): _coeff for _generator, _coeff in grad_lcg.items()
})
exact_grad_lco = LinearCombinationOfOperations({
(X(q0), rx(rad).on(q0), rz(rad).on(q1)): -0.5j,
(rx(rad).on(q0), Z(q1), rz(rad).on(q1)): -0.5j
})
param_resolver = {rad: np.random.rand() * 4 * np.pi}
grad_lco = cirq.resolve_parameters(grad_lco, param_resolver)
exact_grad_lco = cirq.resolve_parameters(exact_grad_lco, param_resolver)
test_lco_identical_with_simulator(
grad_lco,
exact_grad_lco,
self
)
elif len(circuit.all_qubits()) == 2:
obs = np.array([[1, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0,
0]])
else:
raise ValueError("The input must be a circuit with 1 or 2 qubits.")
return noisy_simulation(
circuit,
BASE_NOISE,
obs,
)
# Simple identity 1-qubit circuit for testing
q = LineQubit(1)
oneq_circ = Circuit(Z.on(q), Z.on(q))
# Simple identity 2-qubit circuit for testing
qreg = LineQubit.range(2)
twoq_circ = Circuit(
Y.on(qreg[1]),
CNOT.on(*qreg),
Y.on(qreg[1]),
)
@mark.parametrize("circuit", [oneq_circ, twoq_circ])
@mark.parametrize("decomposition_dict",
[NOISELESS_DECO_DICT, DECO_DICT_SIMP, DECO_DICT])
def test_execute_with_pec_one_qubit(circuit: Circuit,
decomposition_dict: DecompositionDict):
@pytest.mark.parametrize("gate", [X, Y, Z, CNOT])
def test_sample_sequence_types(gate: Gate):
num_qubits = gate.num_qubits()
qreg = LineQubit.range(num_qubits)
for _ in range(1000):
imp_seq, sign, norm = sample_sequence(gate.on(*qreg), DECO_DICT)
assert all([isinstance(op, Operation) for op in imp_seq])
assert sign in {1, -1}
assert norm > 1
@pytest.mark.parametrize("seed", (1, 2, 3, 5))
@pytest.mark.parametrize("seed_type", (int, np.random.RandomState))
@pytest.mark.parametrize(
"op", [X(qreg[0]), Y(qreg[0]),
Z(qreg[0]), CNOT(*qreg)])
def test_sample_sequence_random_state(seed, seed_type, op):
decomposition = _simple_pauli_deco_dict(0.5)
if isinstance(seed_type, np.random.RandomState):
seed = np.random.RandomState(seed)
sequence, sign, norm = sample_sequence(op,
decomposition,
random_state=seed)
for _ in range(20):
if isinstance(seed_type, np.random.RandomState):
seed = np.random.RandomState(seed)
new_sequence, new_sign, new_norm = sample_sequence(op,
decomposition,
random_state=seed)
def test_get_imp_sequences_with_simplify():
q = LineQubit(0)
expected_imp_sequences = [[X.on(q)], [I.on(q)], [Z.on(q)], [Y.on(q)]]
assert get_imp_sequences(X.on(q), DECO_DICT_SIMP) == expected_imp_sequences
def _simple_pauli_deco_dict(base_noise: float,
simplify_paulis: bool = False
) -> DecompositionDict:
"""Returns a simple hard-coded decomposition
dictionary to be used for testing and protoptyping.
The decomposition is compatible with one-qubit or
two-qubit circuits involving only Pauli and CNOT gates.
The keys of the output dictionary are Pauli and CNOT operations.
The decomposition assumes that Pauli and CNOT operations,
followed by local depolarizing noise, are implementable.
Args:
base_noise: The depolarizing noise level.
simplify_paulis: If True, products of Paulis are simplified to a
single Pauli. If False, Pauli sequences are not simplified.
Returns:
decomposition_dict: The decomposition dictionary.
"""
# Initialize two qubits
qreg = LineQubit.range(2)
# Single-qubit Pauli operations
i0 = I.on(qreg[0])
x0 = X.on(qreg[0])
y0 = Y.on(qreg[0])
z0 = Z.on(qreg[0])
i1 = I.on(qreg[1])
x1 = X.on(qreg[1])
y1 = Y.on(qreg[1])
z1 = Z.on(qreg[1])
single_paulis = [x0, y0, z0, x1, y1, z1]
# Single-qubit decomposition coefficients
epsilon = base_noise * 4 / 3
c_neg = -(1 / 4) * epsilon / (1 - epsilon)
c_pos = 1 - 3 * c_neg
assert np.isclose(c_pos + 3 * c_neg, 1.0)
# Single-qubit decomposition dictionary
decomposition_dict = {}
if simplify_paulis:
# Hard-coded simplified gates
decomposition_dict = {
x0: [(c_pos, [x0]), (c_neg, [i0]), (c_neg, [z0]), (c_neg, [y0])],
y0: [(c_pos, [y0]), (c_neg, [z0]), (c_neg, [i0]), (c_neg, [x0])],
z0: [(c_pos, [z0]), (c_neg, [y0]), (c_neg, [x0]), (c_neg, [i0])],
x1: [(c_pos, [x1]), (c_neg, [i1]), (c_neg, [z1]), (c_neg, [y1])],
y1: [(c_pos, [y1]), (c_neg, [z1]), (c_neg, [i1]), (c_neg, [x1])],
z1: [(c_pos, [z1]), (c_neg, [y1]), (c_neg, [x1]), (c_neg, [i1])],
}
else:
for local_paulis in [[x0, y0, z0], [x1, y1, z1]]:
for key in local_paulis:
key_deco_pos = [(c_pos, [key])]
key_deco_neg = [(c_neg, [key, op]) for op in local_paulis]
decomposition_dict[key] = (
key_deco_pos + key_deco_neg # type: ignore
)
# Two-qubit Paulis
xx = [x0, x1]
xy = [x0, y1]
xz = [x0, z1]
yx = [y0, x1]
yy = [y0, y1]
yz = [y0, z1]
zx = [z0, x1]
zy = [z0, y1]
zz = [z0, z1]
double_paulis = [xx, xy, xz, yx, yy, yz, zx, zy, zz]
# Two-qubit decomposition coefficients (assuming local noise)
c_pos_pos = c_pos * c_pos
c_pos_neg = c_neg * c_pos
c_neg_neg = c_neg * c_neg
assert np.isclose(c_pos_pos + 6 * c_pos_neg + 9 * c_neg_neg, 1.0)
cnot = CNOT.on(qreg[0], qreg[1])
cnot_decomposition = [(c_pos_pos, [cnot])]
for p in single_paulis:
cnot_decomposition.append((c_pos_neg, [cnot] + [p]))
for pp in double_paulis:
cnot_decomposition.append((c_neg_neg, [cnot] + pp)) # type: ignore
decomposition_dict[cnot] = cnot_decomposition # type: ignore
return decomposition_dict # type: ignore
class OperationGradTest(unittest.TestCase):
@ddt.unpack
@ddt.data(
# d[rx(rad)] / d[rad] = d[e^{-i X rad / 2}] / d[rad]
# = -i/2 X e^{-i X rads / 2}
# = -i/2 X rx(rad)
[rx(rad).on(q0), rad,
LCO({
(rx(rad).on(q0), X(q0)): -0.5j
})],
# d[XPow(e, s)] / d[e] = i pi {s + 1/2 (I - X)} XPow(e, s)
[XPowGate(exponent=rad, global_shift=0.3).on(q0), rad,
LCO({
(XPowGate(exponent=rad, global_shift=0.3).on(q0),):
1.0j * np.pi * (0.3 + 0.5),
(X(q0), XPowGate(exponent=rad, global_shift=0.3).on(q0)):
-0.5j * np.pi
})],
# d[e^{-i A0 A1 rad}] / d[rad] = -i A0 A1 e^{-i A0 A1 rad}
[TwoPauliExpGate("X", "Z", rad).on(q0, q1), rad,
LCO({
(TwoPauliExpGate("X", "Z", rad).on(q0, q1), X(q0), Z(q1)): -1.0j
})],
# d[exp(i pi rad)] / d[rad] = i pi exp(i pi rad)
[GlobalPhaseGate(rad ** 2).on(q0), rad,
LCO({
(GlobalPhaseGate(rad ** 2).on(q0),): 2.0j * sympy.pi * rad
})],
# d[e^{−i t P}] / d[t] = -i P e^{−i t P}
[PauliWordExpGate(rad ** 2, PauliWord("ZYX")).on(q0, q1, q2), rad,
LCO({
(PauliWordExpGate(rad ** 2, PauliWord("ZYX")).on(q0, q1, q2),
Z(q0), Y(q1), X(q2)): -2.0j * rad
})],
# d[rx(rad) ⊗ rz(rad)] / d[rad] = -i/2 { X rx(rad) ⊗ rz(rad)
# + rx(rad) ⊗ Z rz(rad) }
[GateBlock(
TwoRotsGenerator()
).on(q0, q1), rad,
-0.5j * LCO({
(rz(rad).on(q1), rx(rad).on(q0), X(q0)): 1,
(rz(rad).on(q1), rx(rad).on(q0), Z(q1)): 1
})],
# d[CRx(rad)] / d[rad] = |1><1| ⊗ d[Rx(rad)]/d[rad]
# = -i/2 |1><1| ⊗ X Rx(rad)
# = -i/4 { C[X Rx(rad)] - C[-X Rx(rad)] }
[cirq.ControlledGate(rx(rad), num_controls=1).on(q0, q1), rad,
-1.0j / 4 * LCO({
(ControlledGate(X).on(q0, q1), ControlledGate(rx(rad)).on(q0, q1)): 1,
(ControlledGate(X).on(q0, q1), ControlledGate(rx(rad)).on(q0, q1),
ControlledGate(GlobalPhaseGate(1)).on(q0, q1)): -1
})],
# d[CCRz(rad)] / d[rad] = |1><1| ⊗ |1><1| ⊗ d[Rz(rad)]/d[rad]
# = -i/4 { CC[Z Rz(rad)] - CC[-Z Rz(rad)] }
[ControlledGate(
ControlledGate(
cirq.rz(rad)
)
).on(q0, q1, q2), rad,
-1.0j / 4 * LCO({
(ControlledGate(ControlledGate(Z)).on(q0, q1, q2),
ControlledGate(ControlledGate(rz(rad))).on(q0, q1, q2)): 1,
(ControlledGate(ControlledGate(Z)).on(q0, q1, q2),
ControlledGate(ControlledGate(rz(rad))).on(q0, q1, q2),
ControlledGate(ControlledGate(GlobalPhaseGate(1))).on(q0, q1, q2)): -1
})],
# d[U(rad)] = -i/2 U(rad) X.on(q0) - i/4 { U+(rad) - U-(rad) }
[u.on(q0, q1, q2, q3, q4), rad,
LCO({
(X(q0), u.on(q0, q1, q2, q3, q4),): -0.5j, # order matters!
(u_positive.on(q0, q1, q2, q3, q4),): -0.25j,
(u_negative.on(q0, q1, q2, q3, q4),): +0.25j
})]
)
def test_grad(self, op, param, grad_lco):
print("[Grad of {}]".format(op))
grad = op_grad(op, param)
if isinstance(grad, GradNotImplemented):
print("The grad of {} is not implemented.".format(grad.operation))
return
for _op_series, coeff in grad.items():
_circuit = cirq.Circuit()
_circuit.append(_op_series)
print("Coefficient: {}".format(coeff))
print(_circuit, "\n")
random_rad = typing.cast(float, np.random.rand())
param_resolver = {"rad": random_rad}
# param_resolver = {"rad": 0}
test_lco_identical_with_simulator(
cirq.resolve_parameters(grad, param_resolver),
cirq.resolve_parameters(grad_lco, param_resolver),
self
)
import unittest
import ddt
from cirq import rx, Z, CNOT
from paulicirq.linear_combinations import *
q0, q1, q2 = cirq.LineQubit.range(3)
op_tuple_1 = (rx(sympy.Symbol("θ"))(q0), CNOT(q2, q1))
op_tuple_2 = (CNOT(q0, q2), Z(q1))
m1 = cirq.Moment(op_tuple_1)
m2 = cirq.Moment(op_tuple_2)
@ddt.ddt
class LinearSymbolicDictTest(unittest.TestCase):
"""
A test class for `LinearSymbolicDict`, `LinearCombinationOfMoments`, and
`LinearCombinationOfOperations` in `paulicirq.gates.linear_combinations`.
"""
@ddt.unpack
@ddt.data([LinearCombinationOfOperations, op_tuple_1, op_tuple_2],
[LinearCombinationOfMoments, m1, m2])
def test_numerical(self, _type, term1, term2):
c1 = 0.123
c2 = 0.589
lc1 = _type({term1: c1, term2: c2})
