def test_dont_allow_partial_czs():
before = cirq.Circuit(
[cirq.Moment([cirq.CZ(cirq.GridQubit(5, 5), cirq.GridQubit(5, 6)) ** 0.5])]
)
with cirq.testing.assert_deprecated(
'Use cirq.optimize_for_target_gateset', deadline='v0.16', count=2
):
after = cg.optimized_for_xmon(before, allow_partial_czs=False)
cz_gates = [
op.gate
for op in after.all_operations()
if isinstance(op, cirq.GateOperation) and isinstance(op.gate, cirq.CZPowGate)
]
num_full_cz = sum(1 for cz in cz_gates if cz.exponent % 2 == 1)
num_part_cz = sum(1 for cz in cz_gates if cz.exponent % 2 != 1)
assert num_full_cz == 2
assert num_part_cz == 0
def test_commutes():
a = cirq.NamedQubit('a')
b = cirq.NamedQubit('b')
c = cirq.NamedQubit('c')
d = cirq.NamedQubit('d')
moment = cirq.Moment([cirq.X(a), cirq.Y(b), cirq.H(c)])
assert NotImplemented == cirq.commutes(moment, a, default=NotImplemented)
assert cirq.commutes(moment, cirq.X(a))
assert cirq.commutes(moment, cirq.Y(b))
assert cirq.commutes(moment, cirq.H(c))
assert cirq.commutes(moment, cirq.H(d))
# X and H do not commute
assert not cirq.commutes(moment, cirq.H(a))
assert not cirq.commutes(moment, cirq.H(b))
assert not cirq.commutes(moment, cirq.X(c))
def test_complex_circuit_deep():
q = cirq.LineQubit.range(5)
c_nested = cirq.FrozenCircuit(
cirq.Moment(
cirq.X(q[0]).with_tags("ignore"),
cirq.ISWAP(q[1], q[2]).with_tags("ignore"),
cirq.Z(q[4]),
),
cirq.Moment(cirq.Z(q[1]), cirq.ISWAP(q[3], q[4])),
cirq.Moment(cirq.ISWAP(q[0], q[1]), cirq.X(q[3])),
cirq.Moment(cirq.X.on_each(q[0])),
)
c_nested_stratified = cirq.FrozenCircuit(
cirq.Moment(
cirq.X(q[0]).with_tags("ignore"),
cirq.ISWAP(q[1], q[2]).with_tags("ignore")),
cirq.Moment(cirq.Z.on_each(q[1], q[4])),
cirq.Moment(cirq.ISWAP(*q[:2]), cirq.ISWAP(*q[3:])),
cirq.Moment(cirq.X.on_each(q[0], q[3])),
)
c_orig = cirq.Circuit(
c_nested,
cirq.CircuitOperation(c_nested).repeat(5).with_tags("ignore"),
c_nested,
cirq.CircuitOperation(c_nested).repeat(6).with_tags("preserve_tag"),
c_nested,
)
c_expected = cirq.Circuit(
c_nested_stratified,
cirq.CircuitOperation(c_nested).repeat(5).with_tags("ignore"),
c_nested_stratified,
cirq.CircuitOperation(c_nested_stratified).repeat(6).with_tags(
"preserve_tag"),
c_nested_stratified,
)
context = cirq.TransformerContext(tags_to_ignore=["ignore"], deep=True)
c_stratified = cirq.stratified_circuit(c_orig,
context=context,
categories=[cirq.X, cirq.Z])
cirq.testing.assert_same_circuits(c_stratified, c_expected)
def test_early_z():
q = cirq.NamedQubit('q')
assert_optimizes(before=cirq.Circuit([
cirq.Moment([cirq.Z(q)**0.5]),
cirq.Moment(),
cirq.Moment(),
]),
expected=cirq.Circuit([
cirq.Moment([cirq.Z(q)**0.5]),
cirq.Moment(),
cirq.Moment(),
]),
pre_opts=[cg.ConvertToXmonGates(ignore_failures=True)],
post_opts=[cg.ConvertToXmonGates(ignore_failures=True)])
def test_ignores_czs_separated_by_outer_cz():
q00 = cirq.GridQubit(0, 0)
q01 = cirq.GridQubit(0, 1)
q10 = cirq.GridQubit(1, 0)
assert_optimizes(before=cirq.Circuit([
cirq.Moment([cirq.CZ(q00, q01)]),
cirq.Moment([cirq.CZ(q00, q10)]),
cirq.Moment([cirq.CZ(q00, q01)]),
]),
expected=cirq.Circuit([
cirq.Moment([cirq.CZ(q00, q01)]),
cirq.Moment([cirq.CZ(q00, q10)]),
cirq.Moment([cirq.CZ(q00, q01)]),
]))
def test_merge_single_qubit_moments_to_phxz_deep():
q = cirq.LineQubit.range(3)
x_t_y = cirq.FrozenCircuit(
cirq.Moment(cirq.X.on_each(*q[:2])),
cirq.Moment(cirq.T.on_each(*q[1:])),
cirq.Moment(cirq.Y.on_each(*q[:2])),
)
c_nested = cirq.FrozenCircuit(
x_t_y,
cirq.Moment(cirq.CZ(*q[:2]), cirq.Y(q[2])),
x_t_y,
cirq.Moment(cirq.Y(q[0]).with_tags("ignore"), cirq.Z.on_each(*q[1:])),
)
c_nested_merged = cirq.FrozenCircuit(
[
_phxz(-0.25, 0.0, 0.75)(q[1]),
_phxz(0.25, 0.0, 0.25)(q[2]),
_phxz(-0.5, 0.0, -1.0)(q[0])
],
[cirq.CZ(q[0], q[1]), cirq.Y(q[2])],
[
_phxz(-0.25, 0.0, 0.75)(q[1]),
_phxz(0.25, 0.0, 0.25)(q[2]),
_phxz(-0.5, 0.0, -1.0)(q[0])
],
cirq.Moment(cirq.Y(q[0]).with_tags("ignore"), cirq.Z.on_each(*q[1:])),
)
c_orig = cirq.Circuit(
c_nested,
cirq.CircuitOperation(c_nested).repeat(4).with_tags("ignore"),
c_nested,
cirq.CircuitOperation(c_nested).repeat(5).with_tags("preserve_tags"),
c_nested,
cirq.CircuitOperation(c_nested).repeat(6),
)
c_expected = cirq.Circuit(
c_nested_merged,
cirq.CircuitOperation(c_nested).repeat(4).with_tags("ignore"),
c_nested_merged,
cirq.CircuitOperation(c_nested_merged).repeat(5).with_tags(
"preserve_tags"),
c_nested_merged,
cirq.CircuitOperation(c_nested_merged).repeat(6),
)
context = cirq.TransformerContext(tags_to_ignore=["ignore"], deep=True)
c_new = cirq.merge_single_qubit_moments_to_phxz(c_orig, context=context)
cirq.testing.assert_allclose_up_to_global_phase(c_new.unitary(),
c_expected.unitary(),
atol=1e-7)
def test_simple_align():
q1 = cirq.NamedQubit('q1')
q2 = cirq.NamedQubit('q2')
before = cirq.Circuit([
cirq.Moment([cirq.H(q1), cirq.H(q2)]),
cirq.Moment([cirq.measure(q1), cirq.Z(q2)]),
cirq.Moment([cirq.measure(q2)])
])
after = cirq.Circuit([
cirq.Moment([cirq.H(q1), cirq.H(q2)]),
cirq.Moment([cirq.Z(q2)]),
cirq.Moment([cirq.measure(q1), cirq.measure(q2)])
])
assert_optimizes(before=before, after=after)
def test_ignores_czs_separated_by_parameterized():
a, b = cirq.LineQubit.range(2)
assert_optimizes(
before=cirq.Circuit([
cirq.Moment(cirq.CZ(a, b)),
cirq.Moment(cirq.Z(a)**sympy.Symbol('boo')),
cirq.Moment(cirq.CZ(a, b)),
]),
expected=cirq.Circuit([
cirq.Moment(cirq.CZ(a, b)),
cirq.Moment(cirq.Z(a)**sympy.Symbol('boo')),
cirq.Moment(cirq.CZ(a, b)),
]),
)
def test_symbols_block(sym):
q = cirq.NamedQubit('q')
assert_optimizes(
before=cirq.Circuit([
cirq.Moment([cirq.Z(q)]),
cirq.Moment([cirq.Z(q)**sym]),
cirq.Moment([cirq.Z(q)**0.25]),
]),
expected=cirq.Circuit([
cirq.Moment(),
cirq.Moment([cirq.Z(q)**sym]),
cirq.Moment([cirq.Z(q)**1.25]),
]),
)
def test_measurement_consumes_zs():
q = cirq.NamedQubit('q')
assert_optimizes(
before=cirq.Circuit([
cirq.Moment([cirq.Z(q)**0.5]),
cirq.Moment([cirq.Z(q)**0.25]),
cirq.Moment([cirq.measure(q)]),
]),
expected=cirq.Circuit([
cirq.Moment(),
cirq.Moment(),
cirq.Moment([cirq.measure(q)]),
]),
)
def test_early_z():
q = cirq.NamedQubit('q')
assert_optimizes(
before=cirq.Circuit([
cirq.Moment([cirq.Z(q)**0.5]),
cirq.Moment(),
cirq.Moment(),
]),
expected=cirq.Circuit([
cirq.Moment([cirq.Z(q)**0.5]),
cirq.Moment(),
cirq.Moment(),
]),
)
def test_noisy_moment_one_qubit_prepend():
q0, q1 = cirq.LineQubit.range(2)
model = ThermalNoiseModel(
qubits={q0, q1},
gate_durations_ns={
cirq.PhasedXZGate: 25.0,
cirq.CZPowGate: 25.0
},
heat_rate_GHz={
q0: 1e-5,
q1: 2e-5
},
cool_rate_GHz={
q0: 1e-4,
q1: 2e-4
},
dephase_rate_GHz={
q0: 3e-4,
q1: 4e-4
},
require_physical_tag=False,
prepend=True,
)
gate = cirq.PhasedXZGate(x_exponent=1,
z_exponent=0.5,
axis_phase_exponent=0.25)
moment = cirq.Moment(gate.on(q0))
noisy_moment = model.noisy_moment(moment, system_qubits=[q0, q1])
# Noise applies to both qubits, even if only one is acted upon.
assert len(noisy_moment[0]) == 2
noisy_choi = cirq.kraus_to_choi(cirq.kraus(noisy_moment[0].operations[0]))
assert np.allclose(
noisy_choi,
[
[9.99750343e-01, 0, 0, 9.91164267e-01],
[0, 2.49656565e-03, 0, 0],
[0, 0, 2.49656565e-04, 0],
[9.91164267e-01, 0, 0, 9.97503434e-01],
],
)
# Prepend puts noise before the original moment.
assert noisy_moment[1] == moment
def layer(n, qubits, first=False, last=False):
def Rx(theta, k):
return cirq.XPowGate(exponent=theta)(qubits[k])
def Rz(theta, k):
return cirq.ZPowGate(exponent=theta)(qubits[k])
def Rx_list(theta):
return [Rx(0.0, k) for k in range(n)]
def Rz_list(theta):
return [Rz(0.0, k) for k in range(n)]
if first:
return cirq.Moment(Rx_list(0.0)), cirq.Moment(Rz_list(0.0))
elif last:
return cirq.Moment(Rz_list(0.0)), cirq.Moment(Rx_list(0.0))
else:
return cirq.Moment(Rz_list(0.0)), cirq.Moment(Rx_list(0.0)), cirq.Moment(Rz_list(0.0))
def test_measuring_qubits():
a, b = cirq.LineQubit.range(2)
with pytest.raises(AssertionError):
cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent(
cirq.Circuit([cirq.Moment([cirq.measure(a)])]),
cirq.Circuit([cirq.Moment([cirq.measure(b)])]),
)
cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent(
cirq.Circuit([cirq.Moment([cirq.measure(a, b, invert_mask=(True,))])]),
cirq.Circuit([cirq.Moment([cirq.measure(b, a, invert_mask=(False, True))])]),
)
cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent(
cirq.Circuit([cirq.Moment([cirq.measure(a)]), cirq.Moment([cirq.measure(b)])]),
cirq.Circuit([cirq.Moment([cirq.measure(a, b)])]),
)
def test_greedy_merging():
"""Tests a tricky situation where the algorithm of "Merge single-qubit
gates, greedily align single-qubit then 2-qubit operations" doesn't work.
Our algorithm succeeds because we also run it in reverse order."""
q1, q2, q3, q4 = cirq.LineQubit.range(4)
input_circuit = cirq.Circuit(
cirq.Moment([cirq.X(q1)]),
cirq.Moment([cirq.SWAP(q1, q2), cirq.SWAP(q3, q4)]),
cirq.Moment([cirq.X(q3)]),
cirq.Moment([cirq.SWAP(q3, q4)]),
)
expected = cirq.Circuit(
cirq.Moment([cirq.SWAP(q3, q4)]),
cirq.Moment([cirq.X(q1), cirq.X(q3)]),
cirq.Moment([cirq.SWAP(q1, q2), cirq.SWAP(q3, q4)]),
)
cirq.testing.assert_same_circuits(
cirq.stratified_circuit(input_circuit, categories=[cirq.X]), expected)
def _sq_layer(qubits: List[cirq.Qid], parameterized: bool,
symbol_start: int) -> (cirq.Moment, int):
"""Creates a layer of single-qubit gates.
If parameteried is true, this will add symbols to the qubits
in order to test parameter resolution.
"""
m = cirq.Moment()
current_sym = symbol_start
for q in qubits:
if parameterized:
symbol = f's_{current_sym}'
current_sym += 1
m = m.with_operation(cirq.X(q)**sympy.Symbol(symbol))
else:
m = m.with_operation(
cirq.PhasedXZGate(x_exponent=random.random(),
z_exponent=random.random(),
axis_phase_exponent=random.random())(q))
return (m, current_sym)
def test_pauli():
q0, q1 = cirq.LineQubit.range(2)
circuit = cirq.Circuit(
cirq.PauliMeasurementGate(cirq.DensePauliString('Y'), key='a').on(q0),
cirq.X(q1).with_classical_controls('a'),
cirq.measure(q1, key='b'),
)
deferred = cirq.defer_measurements(circuit)
q_ma = _MeasurementQid('a', q0)
cirq.testing.assert_same_circuits(
cirq.unroll_circuit_op(deferred),
cirq.Circuit(
cirq.SingleQubitCliffordGate.X_sqrt(q0),
cirq.CX(q0, q_ma),
(cirq.SingleQubitCliffordGate.X_sqrt(q0)**-1),
cirq.Moment(cirq.CX(q_ma, q1)),
cirq.measure(q_ma, key='a'),
cirq.measure(q1, key='b'),
),
)
def circuit_for_expectation_value(
circuit: cirq.Circuit, pauli_string: cirq.PauliString
) -> cirq.Circuit:
"""Sandwich a PauliString operator between a forwards and backwards
copy of a circuit.
This is a circuit representation of the expectation value of an operator
<A> = <psi|A|psi> = <0|U^dag A U|0>. You can either extract the 0..0
amplitude of the final state vector (assuming starting from the |0..0>
state or extract the [0, 0] entry of the unitary matrix of this combined
circuit.
"""
assert pauli_string.coefficient == 1
return cirq.Circuit(
[
circuit,
cirq.Moment(gate.on(q) for q, gate in pauli_string.items()),
cirq.inverse(circuit),
]
)
def test_compile_circuit():
"""Tests that we are able to compile a model circuit."""
compiler_mock = MagicMock(side_effect=lambda circuit: circuit)
a, b, c = cirq.LineQubit.range(3)
model_circuit = cirq.Circuit([
cirq.Moment([cirq.X(a), cirq.Y(b), cirq.Z(c)]),
])
compilation_result = cirq.contrib.quantum_volume.compile_circuit(
model_circuit,
device_graph=ccr.gridqubits_to_graph_device(TestDevice().qubits),
compiler=compiler_mock,
routing_attempts=1,
)
assert len(compilation_result.mapping) == 3
assert cirq.contrib.routing.ops_are_consistent_with_device_graph(
compilation_result.circuit.all_operations(),
cirq.contrib.routing.gridqubits_to_graph_device(TestDevice().qubits),
)
compiler_mock.assert_called_with(compilation_result.circuit)
def test_symbols_eject(sym):
q = cirq.NamedQubit('q')
assert_optimizes(
before=cirq.Circuit([
cirq.Moment([cirq.Z(q)]),
cirq.Moment([cirq.Z(q)**sym]),
cirq.Moment([cirq.Z(q)**0.25]),
]),
expected=cirq.Circuit([
cirq.Moment(),
cirq.Moment(),
cirq.Moment([cirq.Z(q)**(sym + 1.25)]),
]),
eject_parameterized=True,
)
def test_ignores_czs_separated_by_parameterized():
a, b = cirq.LineQubit.range(2)
assert_optimizes(
before=cirq.Circuit([
cirq.Moment([cirq.CZ(a, b)]),
cirq.Moment([cg.ExpZGate(
half_turns=cirq.Symbol('boo'))(a)]),
cirq.Moment([cirq.CZ(a, b)]),
]),
expected=cirq.Circuit([
cirq.Moment([cirq.CZ(a, b)]),
cirq.Moment([cg.ExpZGate(
half_turns=cirq.Symbol('boo'))(a)]),
cirq.Moment([cirq.CZ(a, b)]),
]))
def _deserialize_circuit(
self,
circuit_proto,
*,
arg_function_language,
):
moments = []
for i, moment_proto in enumerate(circuit_proto.moments):
moment_ops = []
for op in moment_proto.operations:
try:
moment_ops.append(
self.deserialize_op(
op, arg_function_language=arg_function_language))
except ValueError as ex:
raise ValueError(f'Failed to deserialize circuit. '
f'There was a problem in moment {i} '
f'handling an operation with the '
f'following proto:\n{op}') from ex
moments.append(cirq.Moment(moment_ops))
return cirq.Circuit(moments)
def n_adder():
n = 4
ctrl = cirq.GridQubit(0, 0)
a = [cirq.GridQubit(0, i + 1) for i in range(n - 2)]
q = [cirq.GridQubit(0, i + n - 1) for i in range(n)]
yield cirq.H(ctrl)
yield cirq.CNOT(ctrl, q[n - 1])
yield cirq.TOFFOLI(ctrl, q[n - 1], q[n - 2])
yield cirq.TOFFOLI(ctrl, q[n - 1], a[0])
yield cirq.TOFFOLI(q[n - 2], a[0], a[1])
for i in range(n - 4):
yield cirq.CNOT(a[i + 1], q[n - i - 3])
yield cirq.TOFFOLI(a[i + 1], q[n - i - 3], a[i + 2])
yield cirq.CNOT(a[n - 3], q[1])
yield cirq.TOFFOLI(a[n - 3], q[1], q[0])
for i in range(n - 3):
yield cirq.TOFFOLI(q[i + 2], a[n - i - 4], a[n - i - 3])
yield cirq.TOFFOLI(ctrl, q[n - 1], a[0])
yield cirq.H(ctrl)
if m:
yield cirq.Moment([cirq.measure(ctrl, key='a')])
def test_create_circuits_trotter_zigzag() -> None:
layout = ZigZagLayout(size=4)
parameters = _create_test_parameters(layout, u=2.0)
_, trotter, _ = create_circuits(parameters, trotter_steps=1)
up1, up2, up3, up4 = layout.up_qubits
down1, down2, down3, down4 = layout.down_qubits
expected = cirq.Circuit([
cirq.Moment(
cirq.FSimGate(theta=-0.2, phi=0.0).on(up2, up1),
cirq.FSimGate(theta=-0.2, phi=0.0).on(up4, up3),
cirq.FSimGate(theta=-0.2, phi=0.0).on(down2, down1),
cirq.FSimGate(theta=-0.2, phi=0.0).on(down4, down3),
),
cirq.Moment(
(cirq.CZ**-0.12732395447351627).on(down2, up2),
(cirq.CZ**-0.12732395447351627).on(down4, up4),
CPhaseEchoGate().on(down1),
CPhaseEchoGate().on(down3),
CPhaseEchoGate().on(up1),
CPhaseEchoGate().on(up3),
),
cirq.Moment(
cirq.FSimGate(theta=-1.5707963267948966, phi=0.0).on(up3, up2),
cirq.FSimGate(theta=-1.5707963267948966, phi=0.0).on(down3, down2),
),
cirq.Moment(
(cirq.CZ**-0.12732395447351627).on(down1, up1),
(cirq.CZ**-0.12732395447351627).on(down2, up2),
CPhaseEchoGate().on(down3),
CPhaseEchoGate().on(down4),
CPhaseEchoGate().on(up3),
CPhaseEchoGate().on(up4),
),
cirq.Moment(
cirq.FSimGate(theta=-1.7707963267948965, phi=0.0).on(up3, up2),
cirq.FSimGate(theta=-1.7707963267948965, phi=0.0).on(down3, down2),
),
cirq.Moment(
cirq.Z(up2),
cirq.Z(up3),
cirq.Z(down2),
cirq.Z(down3),
),
])
assert cirq.approx_eq(trotter, expected)
def test_align_left():
q1 = cirq.NamedQubit('q1')
q2 = cirq.NamedQubit('q2')
assert_optimizes(
before=cirq.Circuit(
[
cirq.Moment([cirq.X(q1)]),
cirq.Moment([cirq.Y(q1), cirq.X(q2)]),
cirq.Moment([cirq.X(q1), cirq.Y(q2)]),
cirq.Moment([cirq.Y(q1)]),
cirq.measure(*[q1, q2], key='a'),
]
),
after=cirq.Circuit(
[
cirq.Moment([cirq.X(q1), cirq.X(q2)]),
cirq.Moment([cirq.Y(q1), cirq.Y(q2)]),
cirq.Moment([cirq.X(q1)]),
cirq.Moment([cirq.Y(q1)]),
cirq.measure(*[q1, q2], key='a'),
]
),
)
def test_blocked_shift_one():
q1 = cirq.NamedQubit('q1')
q2 = cirq.NamedQubit('q2')
before = cirq.Circuit(
[
cirq.Moment([cirq.H(q1), cirq.H(q2)]),
cirq.Moment([cirq.measure(q1), cirq.Z(q2)]),
cirq.Moment([cirq.H(q1), cirq.measure(q2).with_tags(NO_COMPILE_TAG)]),
]
)
after = cirq.Circuit(
[
cirq.Moment([cirq.H(q1), cirq.H(q2)]),
cirq.Moment([cirq.measure(q1), cirq.Z(q2)]),
cirq.Moment([cirq.H(q1)]),
cirq.Moment([cirq.measure(q2).with_tags(NO_COMPILE_TAG)]),
]
)
assert_optimizes(before=before, after=after)
assert_optimizes(before=before, after=before, with_context=True)
def test_measurement_key_objs_caching():
q0, q1, q2, q3 = cirq.LineQubit.range(4)
m = cirq.Moment(cirq.measure(q0, key='foo'))
assert m._measurement_key_objs is None
key_objs = cirq.measurement_key_objs(m)
assert m._measurement_key_objs == key_objs
# Make sure it gets updated when adding an operation.
m = m.with_operation(cirq.measure(q1, key='bar'))
assert m._measurement_key_objs == {
cirq.MeasurementKey(name='bar'),
cirq.MeasurementKey(name='foo'),
}
# Or multiple operations.
m = m.with_operations(cirq.measure(q2, key='doh'),
cirq.measure(q3, key='baz'))
assert m._measurement_key_objs == {
cirq.MeasurementKey(name='bar'),
cirq.MeasurementKey(name='foo'),
cirq.MeasurementKey(name='doh'),
cirq.MeasurementKey(name='baz'),
}
def test_stopped_at_2qubit():
m = cirq.google.MergeRotations(0.000001)
q = cirq.QubitId()
q2 = cirq.QubitId()
c = cirq.Circuit([
cirq.Moment([cirq.Z(q)]),
cirq.Moment([cirq.H(q)]),
cirq.Moment([cirq.X(q)]),
cirq.Moment([cirq.H(q)]),
cirq.Moment([cirq.CZ(q, q2)]),
cirq.Moment([cirq.H(q)]),
])
assert (m.optimization_at(c, 0, c.operation_at(
q, 0)) == cirq.PointOptimizationSummary(clear_span=4,
clear_qubits=[q],
new_operations=[]))
def test_align_left_no_compile_context():
q1 = cirq.NamedQubit('q1')
q2 = cirq.NamedQubit('q2')
cirq.testing.assert_same_circuits(
cirq.align_left(
cirq.Circuit([
cirq.Moment([cirq.X(q1)]),
cirq.Moment([cirq.Y(q1), cirq.X(q2)]),
cirq.Moment([cirq.X(q1),
cirq.Y(q2).with_tags("nocompile")]),
cirq.Moment([cirq.Y(q1)]),
cirq.measure(*[q1, q2], key='a'),
]),
context=cirq.TransformerContext(tags_to_ignore=["nocompile"]),
),
cirq.Circuit([
cirq.Moment([cirq.X(q1), cirq.X(q2)]),
cirq.Moment([cirq.Y(q1)]),
cirq.Moment([cirq.X(q1),
cirq.Y(q2).with_tags("nocompile")]),
cirq.Moment([cirq.Y(q1)]),
cirq.measure(*[q1, q2], key='a'),
]),
)
def decompose_preserving_moments(
circuit: cirq.Circuit, decompose_func: Union[DecomposeCallable,
Iterable[DecomposeCallable]]
) -> cirq.Circuit:
"""Decomposes circuit moment by moment.
This function decomposes each operation within every moment simultaneously
and expands the moment into the longest operation that was decomposed. It
never mixes operation from two different input moments together.
Args:
circuit: Circuit to decompose.
decompose_func: Function or iterable of functions that decomposes
operation into iterable of moments of simultaneously executed
operations. If many functions are provided, all off them are tried
until decomposition is not None. When no decomposition is found,
input gate is copied as is.
Returns:
New cirq.Circuit instance which is a decomposed version of circuit.
"""
def decompose(operation: cirq.Operation) -> Decomposition:
for func in decompose_func:
decomposition = func(operation)
if decomposition is not None:
return decomposition
return (operation, ),
if not isinstance(decompose_func, Iterable):
decompose_func = decompose_func,
decomposed = cirq.Circuit()
for moment in circuit:
decompositions = (decompose(operation) for operation in moment)
for operations in zip_longest(*decompositions, fillvalue=()):
decomposed += cirq.Moment(operations)
return decomposed
