def assert_optimizes(no_decomp, expected, actual):
with cirq.testing.assert_deprecated("Use cirq.expand_composite",
deadline='v1.0'):
expander = cirq.ExpandComposite(
no_decomp) if no_decomp else cirq.ExpandComposite()
expander(expected)
if actual:
assert_equal_mod_empty(expected, actual)
def test_circular_shift_gate_decomposition():
qubits = [cirq.NamedQubit(q) for q in 'abcdef']
expander = cirq.ExpandComposite()
circular_shift = cca.CircularShiftGate(2, 1, cirq.CZ)(*qubits[:2])
circuit = cirq.Circuit(circular_shift)
expander.optimize_circuit(circuit)
expected_circuit = cirq.Circuit(
(cirq.Moment((cirq.CZ(*qubits[:2]),)),))
assert circuit == expected_circuit
no_decomp = lambda op: (isinstance(op, cirq.GateOperation) and
op.gate == cirq.SWAP)
expander = cirq.ExpandComposite(no_decomp=no_decomp)
circular_shift = cca.CircularShiftGate(6, 3)(*qubits)
circuit = cirq.Circuit(circular_shift)
expander.optimize_circuit(circuit)
actual_text_diagram = circuit.to_text_diagram().strip()
expected_text_diagram = """
a: ───────────×───────────
│
b: ───────×───×───×───────
│ │
c: ───×───×───×───×───×───
│ │ │
d: ───×───×───×───×───×───
│ │
e: ───────×───×───×───────
│
f: ───────────×───────────
""".strip()
assert actual_text_diagram == expected_text_diagram
circular_shift = cca.CircularShiftGate(6, 2)(*qubits)
circuit = cirq.Circuit(circular_shift)
expander.optimize_circuit(circuit)
actual_text_diagram = circuit.to_text_diagram().strip()
expected_text_diagram = """
a: ───────×───────────────
│
b: ───×───×───×───────────
│ │
c: ───×───×───×───×───────
│ │
d: ───────×───×───×───×───
│ │
e: ───────────×───×───×───
│
f: ───────────────×───────
""".strip()
assert actual_text_diagram == expected_text_diagram
def test_decompose_with_symbol():
q0, = _make_qubits(1)
ps = cirq.PauliString({q0: cirq.Pauli.Y})
op = PauliStringPhasor(ps, half_turns=cirq.Symbol('a'))
circuit = cirq.Circuit.from_ops(op)
cirq.ExpandComposite().optimize_circuit(circuit)
assert circuit.to_text_diagram() == "q0: ───X^0.5───Z^a───X^-0.5───"
ps = cirq.PauliString({q0: cirq.Pauli.Y}, True)
op = PauliStringPhasor(ps, half_turns=cirq.Symbol('a'))
circuit = cirq.Circuit.from_ops(op)
cirq.ExpandComposite().optimize_circuit(circuit)
assert circuit.to_text_diagram() == "q0: ───X^0.5───X───Z^a───X───X^-0.5───"
def test_decompose_with_symbol():
(q0,) = _make_qubits(1)
ps = cirq.PauliString({q0: cirq.Y})
op = cirq.PauliStringPhasor(ps, exponent_neg=sympy.Symbol('a'))
circuit = cirq.Circuit(op)
cirq.ExpandComposite().optimize_circuit(circuit)
cirq.testing.assert_has_diagram(circuit, "q0: ───X^0.5───Z^a───X^-0.5───")
ps = cirq.PauliString({q0: cirq.Y}, -1)
op = cirq.PauliStringPhasor(ps, exponent_neg=sympy.Symbol('a'))
circuit = cirq.Circuit(op)
cirq.ExpandComposite().optimize_circuit(circuit)
cirq.testing.assert_has_diagram(circuit, "q0: ───X^0.5───X───Z^a───X───X^-0.5───")
def test_decompose_with_symbol():
q0, = _make_qubits(1)
ps = cirq.PauliString({q0: cirq.Y})
op = PauliStringPhasor(ps, half_turns=sympy.Symbol('a'))
circuit = cirq.Circuit.from_ops(op)
cirq.ExpandComposite().optimize_circuit(circuit)
cirq.testing.assert_has_diagram(circuit, "q0: ───X^0.5───Z^a───X^-0.5───")
ps = cirq.PauliString({q0: cirq.Y}, -1)
op = PauliStringPhasor(ps, half_turns=sympy.Symbol('a'))
circuit = cirq.Circuit.from_ops(op)
cirq.ExpandComposite().optimize_circuit(circuit)
cirq.testing.assert_has_diagram(
circuit, "q0: ───X^0.5───Z^(-a)───X^-0.5───")
def test_swap_permutation_gate():
no_decomp = lambda op: (isinstance(op, cirq.GateOperation) and op.gate ==
cirq.SWAP)
a, b = cirq.NamedQubit('a'), cirq.NamedQubit('b')
expander = cirq.ExpandComposite(no_decomp=no_decomp)
circuit = cirq.Circuit.from_ops(SwapPermutationGate()(a, b))
expander(circuit)
assert tuple(circuit.all_operations()) == (cirq.SWAP(a, b), )
no_decomp = lambda op: (isinstance(op, cirq.GateOperation) and op.gate ==
cirq.CZ)
expander = cirq.ExpandComposite(no_decomp=no_decomp)
circuit = cirq.Circuit.from_ops(SwapPermutationGate(cirq.CZ)(a, b))
expander(circuit)
assert tuple(circuit.all_operations()) == (cirq.CZ(a, b), )
def test_decompose_returns_deep_op_tree():
class DummyGate(cirq.Gate, cirq.CompositeGate):
def default_decompose(self, qubits):
q0, q1 = qubits
# Yield a tuple
yield ((X(q0), Y(q0)), Z(q0))
# Yield nested lists
yield [X(q0), [Y(q0), Z(q0)]]
def generator(depth):
if depth <= 0:
yield CZ(q0, q1), Y(q0)
else:
yield X(q0), generator(depth - 1)
yield Z(q0)
# Yield nested generators
yield generator(2)
q0, q1 = QubitId(), QubitId()
circuit = cirq.Circuit.from_ops(DummyGate()(q0, q1))
opt = cirq.ExpandComposite()
opt.optimize_circuit(circuit)
expected = cirq.Circuit().from_ops(X(q0), Y(q0), Z(q0), # From tuple
X(q0), Y(q0), Z(q0), # From nested lists
# From nested generators
X(q0), X(q0),
CZ(q0, q1), Y(q0),
Z(q0), Z(q0))
assert_equal_mod_empty(expected, circuit)
def test_cirq_qsim_simulate_random_unitary(mode: str):
q0, q1 = cirq.LineQubit.range(2)
qsimSim = qsimcirq.QSimSimulator(qsim_options={"t": 16, "v": 0})
for iter in range(10):
random_circuit = cirq.testing.random_circuit(
qubits=[q0, q1], n_moments=8, op_density=0.99, random_state=iter
)
cirq.ConvertToCzAndSingleGates().optimize_circuit(
random_circuit
) # cannot work with params
cirq.ExpandComposite().optimize_circuit(random_circuit)
if mode == "noisy":
random_circuit.append(NoiseTrigger().on(q0))
result = qsimSim.simulate(random_circuit, qubit_order=[q0, q1])
assert result.state_vector().shape == (4,)
cirqSim = cirq.Simulator()
cirq_result = cirqSim.simulate(random_circuit, qubit_order=[q0, q1])
# When using rotation gates such as S, qsim may add a global phase relative
# to other simulators. This is fine, as the result is equivalent.
assert cirq.linalg.allclose_up_to_global_phase(
result.state_vector(), cirq_result.state_vector(), atol=1.0e-6
)
def main():
"""Demonstrates Quantum Fourier transform.
"""
# Create circuit
qft_circuit = generate_2x2_grid_qft_circuit()
cirq.ConvertToCzAndSingleGates().optimize_circuit(
qft_circuit) # cannot work with params
cirq.ExpandComposite().optimize_circuit(qft_circuit)
print('Circuit:')
print(qft_circuit)
qsim_circuit = qsimcirq.QSimCircuit(cirq_circuit=qft_circuit,
allow_decomposition=True)
# Simulate and collect final_state
sv_simulator = cirq.Simulator()
qs_simulator = qsimcirq.QSimSimulator(qsim_options={'t': 16, 'v': 2})
sv_result = sv_simulator.simulate(qft_circuit)
qs_result = qs_simulator.simulate(qsim_circuit)
assert sv_result.state_vector().shape == (16, )
assert qs_result.state_vector().shape == (16, )
assert cirq.linalg.allclose_up_to_global_phase(sv_result.state_vector(),
qs_result.state_vector())
kc_simulator = cirq.KnowledgeCompilationSimulator(qft_circuit,
intermediate=False)
kc_result = kc_simulator.simulate(qft_circuit)
print()
print('FinalState')
assert cirq.linalg.allclose_up_to_global_phase(sv_result.state_vector(),
kc_result.state_vector())
print(kc_result.state_vector())
print(np.around(kc_result.final_state_vector, 3))
def test_ignore_non_composite():
q0, q1 = cirq.LineQubit.range(2)
circuit = cirq.Circuit()
circuit.append([cirq.X(q0), cirq.Y(q1), cirq.CZ(q0, q1), cirq.Z(q0)])
expected = circuit.copy()
opt = cirq.ExpandComposite()
opt.optimize_circuit(circuit)
assert_equal_mod_empty(expected, circuit)
def test_ignore_non_composite():
q0, q1 = QubitId(), QubitId()
circuit = cirq.Circuit()
circuit.append([X(q0), Y(q1), CZ(q0, q1), Z(q0)])
expected = circuit.copy()
opt = cirq.ExpandComposite()
opt.optimize_circuit(circuit)
assert_equal_mod_empty(expected, circuit)
def test_decompose(gate):
q0, q1 = cirq.NamedQubit('q0'), cirq.NamedQubit('q1')
circuit = cirq.Circuit.from_ops(
gate(q0, q1))
cirq.ExpandComposite().optimize_circuit(circuit)
decompose_mat = circuit.to_unitary_matrix()
gate_mat = cirq.unitary(gate)
cirq.testing.assert_allclose_up_to_global_phase(
decompose_mat, gate_mat, rtol=1e-7, atol=1e-7)
def test_composite_default():
q0, q1 = cirq.LineQubit.range(2)
cnot = cirq.CNOT(q0, q1)
circuit = cirq.Circuit()
circuit.append(cnot)
opt = cirq.ExpandComposite()
opt.optimize_circuit(circuit)
expected = cirq.Circuit()
expected.append([cirq.Y(q1) ** -0.5, cirq.CZ(q0, q1), cirq.Y(q1) ** 0.5])
assert_equal_mod_empty(expected, circuit)
def test_composite_default():
q0, q1 = QubitId(), QubitId()
cnot = CNOT(q0, q1)
circuit = cirq.Circuit()
circuit.append(cnot)
opt = cirq.ExpandComposite()
opt.optimize_circuit(circuit)
expected = cirq.Circuit()
expected.append([Y(q1) ** -0.5, CZ(q0, q1), Y(q1) ** 0.5])
assert_equal_mod_empty(expected, circuit)
def test_composite_extension_overrides():
q0, q1 = QubitId(), QubitId()
cnot = CNOT(q0, q1)
circuit = cirq.Circuit()
circuit.append(cnot)
ext = cirq.Extensions()
ext.add_cast(cirq.CompositeGate, cirq.CNotGate, lambda _: OtherCNot())
opt = cirq.ExpandComposite(composite_gate_extension=ext)
opt.optimize_circuit(circuit)
expected = cirq.Circuit()
expected.append([Z(q0), Y(q1) ** -0.5, CZ(q0, q1), Y(q1) ** 0.5, Z(q0)])
assert_equal_mod_empty(expected, circuit)
def test_swap_permutation_gate():
no_decomp = lambda op: (isinstance(op, cirq.GateOperation) and op.gate ==
cirq.SWAP)
a, b = cirq.NamedQubit('a'), cirq.NamedQubit('b')
expander = cirq.ExpandComposite(no_decomp=no_decomp)
gate = cca.SwapPermutationGate()
assert gate.num_qubits() == 2
circuit = cirq.Circuit(gate(a, b))
expander(circuit)
assert tuple(circuit.all_operations()) == (cirq.SWAP(a, b), )
no_decomp = lambda op: (isinstance(op, cirq.GateOperation) and op.gate ==
cirq.CZ)
expander = cirq.ExpandComposite(no_decomp=no_decomp)
circuit = cirq.Circuit(cca.SwapPermutationGate(cirq.CZ)(a, b))
expander(circuit)
assert tuple(circuit.all_operations()) == (cirq.CZ(a, b), )
assert cirq.commutes(gate, cirq.ZZ)
with pytest.raises(TypeError):
cirq.commutes(gate, cirq.CCZ)
def test_circuit_diagrams(part_size, subgraph):
qubits = cirq.LineQubit.range(2 * part_size)
gate = cca.BipartiteSwapNetworkGate(subgraph, part_size)
circuit = cirq.Circuit.from_ops(gate(*qubits))
diagram = circuit_diagrams['undecomposed', subgraph, part_size]
cirq.testing.assert_has_diagram(circuit, diagram)
no_decomp = (lambda op: isinstance(op.gate, (
cca.AcquaintanceOpportunityGate, cca.SwapPermutationGate)))
expander = cirq.ExpandComposite(no_decomp=no_decomp)
expander(circuit)
diagram = circuit_diagrams['decomposed', subgraph, part_size]
cirq.testing.assert_has_diagram(circuit, diagram)
def test_decompose_returns_not_flat_op_tree():
class DummyGate(cirq.SingleQubitGate):
def _decompose_(self, qubits):
(q0,) = qubits
# Yield a tuple of gates instead of yielding a gate
yield cirq.X(q0),
q0 = cirq.NamedQubit('q0')
circuit = cirq.Circuit(DummyGate()(q0))
opt = cirq.ExpandComposite()
opt.optimize_circuit(circuit)
expected = cirq.Circuit(cirq.X(q0))
assert_equal_mod_empty(expected, circuit)
def test_mix_composite_non_composite():
q0, q1 = cirq.LineQubit.range(2)
actual = cirq.Circuit(cirq.X(q0), cirq.CNOT(q0, q1), cirq.X(q1))
opt = cirq.ExpandComposite()
opt.optimize_circuit(actual)
expected = cirq.Circuit(cirq.X(q0),
cirq.Y(q1)**-0.5,
cirq.CZ(q0, q1),
cirq.Y(q1)**0.5,
cirq.X(q1),
strategy=cirq.InsertStrategy.NEW)
assert_equal_mod_empty(expected, actual)
def test_non_recursive_expansion():
qubits = [cirq.NamedQubit(s) for s in 'xy']
no_decomp = lambda op: (isinstance(op, cirq.GateOperation) and op.gate ==
cirq.ISWAP)
expander = cirq.ExpandComposite(no_decomp=no_decomp)
unexpanded_circuit = cirq.Circuit(cirq.ISWAP(*qubits))
circuit = unexpanded_circuit.__copy__()
expander.optimize_circuit(circuit)
assert circuit == unexpanded_circuit
no_decomp = lambda op: (isinstance(op, cirq.GateOperation) and isinstance(
op.gate, (cirq.CNotPowGate, cirq.HPowGate)))
expander = cirq.ExpandComposite(no_decomp=no_decomp)
circuit = unexpanded_circuit.__copy__()
expander.optimize_circuit(circuit)
actual_text_diagram = circuit.to_text_diagram().strip()
expected_text_diagram = """
x: ───@───H───X───S───X───S^-1───H───@───
│ │ │ │
y: ───X───────@───────@──────────────X───
""".strip()
assert actual_text_diagram == expected_text_diagram
def test_mix_composite_non_composite():
q0, q1 = QubitId(), QubitId()
actual = cirq.Circuit.from_ops(X(q0), CNOT(q0, q1), X(q1))
opt = cirq.ExpandComposite()
opt.optimize_circuit(actual)
expected = cirq.Circuit.from_ops(X(q0),
Y(q1) ** -0.5,
CZ(q0, q1),
Y(q1) ** 0.5,
X(q1),
strategy=cirq.InsertStrategy.NEW)
assert_equal_mod_empty(expected, actual)
def test_decompose_returns_not_flat_op_tree():
class DummyGate(cirq.Gate, cirq.CompositeGate):
def default_decompose(self, qubits):
q0, = qubits
# Yield a tuple of gates instead of yielding a gate
yield X(q0),
q0 = QubitId()
circuit = cirq.Circuit.from_ops(DummyGate()(q0))
opt = cirq.ExpandComposite()
opt.optimize_circuit(circuit)
expected = cirq.Circuit().from_ops(X(q0))
assert_equal_mod_empty(expected, circuit)
def test_recursive_composite():
q0, q1 = cirq.LineQubit.range(2)
swap = cirq.SWAP(q0, q1)
circuit = cirq.Circuit()
circuit.append(swap)
opt = cirq.ExpandComposite()
opt.optimize_circuit(circuit)
expected = cirq.Circuit(
cirq.Y(q1)**-0.5, cirq.CZ(q0, q1),
cirq.Y(q1)**0.5,
cirq.Y(q0)**-0.5, cirq.CZ(q1, q0),
cirq.Y(q0)**0.5,
cirq.Y(q1)**-0.5, cirq.CZ(q0, q1),
cirq.Y(q1)**0.5)
assert_equal_mod_empty(expected, circuit)
def test_recursive_composite_extension_overrides():
q0, q1 = QubitId(), QubitId()
swap = SWAP(q0, q1)
circuit = cirq.Circuit()
circuit.append(swap)
ext = cirq.Extensions()
ext.add_cast(cirq.CompositeGate, cirq.CNotGate, lambda _: OtherCNot())
opt = cirq.ExpandComposite(composite_gate_extension=ext)
opt.optimize_circuit(circuit)
expected = cirq.Circuit()
expected.append([Z(q0), Y(q1) ** -0.5, CZ(q0, q1), Y(q1) ** 0.5, Z(q0)])
expected.append([Z(q1), Y(q0) ** -0.5, CZ(q1, q0), Y(q0) ** 0.5, Z(q1)],
strategy=cirq.InsertStrategy.INLINE)
expected.append([Z(q0), Y(q1) ** -0.5, CZ(q0, q1), Y(q1) ** 0.5, Z(q0)],
strategy=cirq.InsertStrategy.INLINE)
assert_equal_mod_empty(expected, circuit)
def test_recursive_composite():
q0, q1 = QubitId(), QubitId()
swap = SWAP(q0, q1)
circuit = cirq.Circuit()
circuit.append(swap)
opt = cirq.ExpandComposite()
opt.optimize_circuit(circuit)
expected = cirq.Circuit().from_ops(Y(q1) ** -0.5,
CZ(q0, q1),
Y(q1) ** 0.5,
Y(q0) ** -0.5,
CZ(q1, q0),
Y(q0) ** 0.5,
Y(q1) ** -0.5,
CZ(q0, q1),
Y(q1) ** 0.5)
assert_equal_mod_empty(expected, circuit)
def test_decompose_returns_deep_op_tree():
class DummyGate(cirq.testing.TwoQubitGate):
def _decompose_(self, qubits):
q0, q1 = qubits
# Yield a tuple
yield ((cirq.X(q0), cirq.Y(q0)), cirq.Z(q0))
# Yield nested lists
yield [cirq.X(q0), [cirq.Y(q0), cirq.Z(q0)]]
def generator(depth):
if depth <= 0:
yield cirq.CZ(q0, q1), cirq.Y(q0)
else:
yield cirq.X(q0), generator(depth - 1)
yield cirq.Z(q0)
# Yield nested generators
yield generator(2)
q0, q1 = cirq.LineQubit.range(2)
circuit = cirq.Circuit(DummyGate()(q0, q1))
opt = cirq.ExpandComposite()
opt.optimize_circuit(circuit)
expected = cirq.Circuit(
cirq.X(q0),
cirq.Y(q0),
cirq.Z(q0), # From tuple
cirq.X(q0),
cirq.Y(q0),
cirq.Z(q0), # From nested lists
# From nested generators
cirq.X(q0),
cirq.X(q0),
cirq.CZ(q0, q1),
cirq.Y(q0),
cirq.Z(q0),
cirq.Z(q0),
)
assert_equal_mod_empty(expected, circuit)
def test_swap_network_gate():
qubits = tuple(cirq.NamedQubit(s) for s in alphabet)
acquaintance_size = 3
n_parts = 3
part_lens = (acquaintance_size - 1, ) * n_parts
n_qubits = sum(part_lens)
swap_network_op = SwapNetworkGate(
part_lens, acquaintance_size=acquaintance_size)(*qubits[:n_qubits])
swap_network = cirq.Circuit.from_ops(swap_network_op)
actual_text_diagram = swap_network.to_text_diagram().strip()
expected_text_diagram = """
a: ───×(0,0)───
│
b: ───×(0,1)───
│
c: ───×(1,0)───
│
d: ───×(1,1)───
│
e: ───×(2,0)───
│
f: ───×(2,1)───
""".strip()
assert actual_text_diagram == expected_text_diagram
no_decomp = lambda op: isinstance(op.gate, (CircularShiftGate,
LinearPermutationGate))
expander = cirq.ExpandComposite(no_decomp=no_decomp)
expander(swap_network)
actual_text_diagram = swap_network.to_text_diagram().strip()
expected_text_diagram = """
a: ───█───────╲0╱───█─────────────────█───────────╲0╱───█───────0↦1───
│ │ │ │ │ │ │
b: ───█───█───╲1╱───█───█─────────────█───█───────╲1╱───█───█───1↦0───
│ │ │ │ │ │ │ │ │ │
c: ───█───█───╱2╲───█───█───█───╲0╱───█───█───█───╱2╲───█───█───0↦1───
│ │ │ │ │ │ │ │ │ │
d: ───────█───╱3╲───█───█───█───╲1╱───█───█───█───╱3╲───────█───1↦0───
│ │ │ │ │
e: ─────────────────█───────█───╱2╲───█───────█───0↦1─────────────────
│ │ │ │
f: ─────────────────█───────────╱3╲───█───────────1↦0─────────────────
""".strip()
assert actual_text_diagram == expected_text_diagram
no_decomp = lambda op: isinstance(op.gate, CircularShiftGate)
expander = cirq.ExpandComposite(no_decomp=no_decomp)
acquaintance_size = 3
n_parts = 6
part_lens = (1, ) * n_parts
n_qubits = sum(part_lens)
swap_network_op = SwapNetworkGate(
part_lens, acquaintance_size=acquaintance_size)(*qubits[:n_qubits])
swap_network = cirq.Circuit.from_ops(swap_network_op)
expander(swap_network)
actual_text_diagram = swap_network.to_text_diagram().strip()
expected_text_diagram = """
a: ───╲0╱─────────╲0╱─────────╲0╱─────────
│ │ │
b: ───╱1╲───╲0╱───╱1╲───╲0╱───╱1╲───╲0╱───
│ │ │
c: ───╲0╱───╱1╲───╲0╱───╱1╲───╲0╱───╱1╲───
│ │ │
d: ───╱1╲───╲0╱───╱1╲───╲0╱───╱1╲───╲0╱───
│ │ │
e: ───╲0╱───╱1╲───╲0╱───╱1╲───╲0╱───╱1╲───
│ │ │
f: ───╱1╲─────────╱1╲─────────╱1╲─────────
""".strip()
assert actual_text_diagram == expected_text_diagram
def test_empty_moment():
circuit = cirq.Circuit([])
opt = cirq.ExpandComposite()
opt.optimize_circuit(circuit)
assert_equal_mod_empty(cirq.Circuit([]), circuit)
def test_swap_network_gate():
qubits = tuple(cirq.NamedQubit(s) for s in alphabet)
acquaintance_size = 3
n_parts = 3
part_lens = (acquaintance_size - 1, ) * n_parts
n_qubits = sum(part_lens)
swap_network_op = cca.SwapNetworkGate(
part_lens, acquaintance_size=acquaintance_size)(*qubits[:n_qubits])
swap_network = cirq.Circuit(swap_network_op)
expected_text_diagram = """
a: ───×(0,0)───
│
b: ───×(0,1)───
│
c: ───×(1,0)───
│
d: ───×(1,1)───
│
e: ───×(2,0)───
│
f: ───×(2,1)───
""".strip()
ct.assert_has_diagram(swap_network, expected_text_diagram)
no_decomp = lambda op: isinstance(op.gate, (cca.CircularShiftGate, cca.
LinearPermutationGate))
expander = cirq.ExpandComposite(no_decomp=no_decomp)
expander(swap_network)
expected_text_diagram = """
a: ───█───────╲0╱───█─────────────────█───────────╲0╱───█───────0↦1───
│ │ │ │ │ │ │
b: ───█───█───╲1╱───█───█─────────────█───█───────╲1╱───█───█───1↦0───
│ │ │ │ │ │ │ │ │ │ │
c: ───█───█───╱2╲───█───█───█───╲0╱───█───█───█───╱2╲───█───█───2↦3───
│ │ │ │ │ │ │ │ │ │
d: ───────█───╱3╲───█───█───█───╲1╱───█───█───█───╱3╲───────█───3↦2───
│ │ │ │ │ │
e: ─────────────────█───────█───╱2╲───█───────█─────────────────4↦5───
│ │ │ │
f: ─────────────────█───────────╱3╲───█─────────────────────────5↦4───
""".strip()
ct.assert_has_diagram(swap_network, expected_text_diagram)
no_decomp = lambda op: isinstance(op.gate, cca.CircularShiftGate)
expander = cirq.ExpandComposite(no_decomp=no_decomp)
acquaintance_size = 3
n_parts = 6
part_lens = (1, ) * n_parts
n_qubits = sum(part_lens)
swap_network_op = cca.SwapNetworkGate(
part_lens, acquaintance_size=acquaintance_size)(*qubits[:n_qubits])
swap_network = cirq.Circuit(swap_network_op)
expander(swap_network)
expected_text_diagram = """
a: ───╲0╱─────────╲0╱─────────╲0╱─────────
│ │ │
b: ───╱1╲───╲0╱───╱1╲───╲0╱───╱1╲───╲0╱───
│ │ │
c: ───╲0╱───╱1╲───╲0╱───╱1╲───╲0╱───╱1╲───
│ │ │
d: ───╱1╲───╲0╱───╱1╲───╲0╱───╱1╲───╲0╱───
│ │ │
e: ───╲0╱───╱1╲───╲0╱───╱1╲───╲0╱───╱1╲───
│ │ │
f: ───╱1╲─────────╱1╲─────────╱1╲─────────
""".strip()
ct.assert_has_diagram(swap_network, expected_text_diagram)
def test_complete_acquaintance_strategy():
qubits = [cirq.NamedQubit(s) for s in alphabet]
with pytest.raises(ValueError):
_ = cca.complete_acquaintance_strategy(qubits, -1)
empty_strategy = cca.complete_acquaintance_strategy(qubits)
assert empty_strategy._moments == []
trivial_strategy = cca.complete_acquaintance_strategy(qubits[:4], 1)
actual_text_diagram = trivial_strategy.to_text_diagram().strip()
expected_text_diagram = """
a: ───█───
b: ───█───
c: ───█───
d: ───█───
""".strip()
assert actual_text_diagram == expected_text_diagram
assert cca.get_acquaintance_size(trivial_strategy) == 1
is_shift_or_lin_perm = lambda op: isinstance(op.gate, (
cca.CircularShiftGate, cca.LinearPermutationGate))
expand = cirq.ExpandComposite(no_decomp=is_shift_or_lin_perm)
quadratic_strategy = cca.complete_acquaintance_strategy(qubits[:8], 2)
actual_text_diagram = quadratic_strategy.to_text_diagram().strip()
expected_text_diagram = """
a: ───×(0,0)───
│
b: ───×(1,0)───
│
c: ───×(2,0)───
│
d: ───×(3,0)───
│
e: ───×(4,0)───
│
f: ───×(5,0)───
│
g: ───×(6,0)───
│
h: ───×(7,0)───
""".strip()
assert actual_text_diagram == expected_text_diagram
assert cca.get_acquaintance_size(quadratic_strategy) == 2
expand(quadratic_strategy)
actual_text_diagram = quadratic_strategy.to_text_diagram(
transpose=True).strip()
expected_text_diagram = '\n'.join(
("a b c d e f g h ".strip(),
"│ │ │ │ │ │ │ │ ".strip(),
"█───█ █───█ █───█ █───█ ".strip(),
"│ │ │ │ │ │ │ │ ".strip(),
"╲0╱─╱1╲ ╲0╱─╱1╲ ╲0╱─╱1╲ ╲0╱─╱1╲ ".strip(),
"│ │ │ │ │ │ │ │ ".strip(),
"│ █───█ █───█ █───█ │ ".strip(),
"│ │ │ │ │ │ │ │ ".strip(),
"│ ╲0╱─╱1╲ ╲0╱─╱1╲ ╲0╱─╱1╲ │ ".strip(),
"│ │ │ │ │ │ │ │ ".strip(),
"█───█ █───█ █───█ █───█ ".strip(),
"│ │ │ │ │ │ │ │ ".strip(),
"╲0╱─╱1╲ ╲0╱─╱1╲ ╲0╱─╱1╲ ╲0╱─╱1╲ ".strip(),
"│ │ │ │ │ │ │ │ ".strip(),
"│ █───█ █───█ █───█ │ ".strip(),
"│ │ │ │ │ │ │ │ ".strip(),
"│ ╲0╱─╱1╲ ╲0╱─╱1╲ ╲0╱─╱1╲ │ ".strip(),
"│ │ │ │ │ │ │ │ ".strip(),
"█───█ █───█ █───█ █───█ ".strip(),
"│ │ │ │ │ │ │ │ ".strip(),
"╲0╱─╱1╲ ╲0╱─╱1╲ ╲0╱─╱1╲ ╲0╱─╱1╲ ".strip(),
"│ │ │ │ │ │ │ │ ".strip(),
"│ █───█ █───█ █───█ │ ".strip(),
"│ │ │ │ │ │ │ │ ".strip(),
"│ ╲0╱─╱1╲ ╲0╱─╱1╲ ╲0╱─╱1╲ │ ".strip(),
"│ │ │ │ │ │ │ │ ".strip(),
"█───█ █───█ █───█ █───█ ".strip(),
"│ │ │ │ │ │ │ │ ".strip(),
"╲0╱─╱1╲ ╲0╱─╱1╲ ╲0╱─╱1╲ ╲0╱─╱1╲ ".strip(),
"│ │ │ │ │ │ │ │ ".strip(),
"│ █───█ █───█ █───█ │ ".strip(),
"│ │ │ │ │ │ │ │ ".strip(),
"│ ╲0╱─╱1╲ ╲0╱─╱1╲ ╲0╱─╱1╲ │ ".strip(),
"│ │ │ │ │ │ │ │ ".strip()))
assert actual_text_diagram == expected_text_diagram
assert cca.get_acquaintance_size(quadratic_strategy) == 2
cubic_strategy = cca.complete_acquaintance_strategy(qubits[:4], 3)
actual_text_diagram = cubic_strategy.to_text_diagram(
transpose=True).strip()
expected_text_diagram = """
a b c d
│ │ │ │
×(0,0)─×(0,1)─×(1,0)─×(1,1)
│ │ │ │
╱1╲────╲0╱ ╱1╲────╲0╱
│ │ │ │
×(0,0)─×(1,0)─×(1,1)─×(2,0)
│ │ │ │
│ ╲0╱────╱1╲ │
│ │ │ │
×(0,0)─×(0,1)─×(1,0)─×(1,1)
│ │ │ │
╱1╲────╲0╱ ╱1╲────╲0╱
│ │ │ │
×(0,0)─×(1,0)─×(1,1)─×(2,0)
│ │ │ │
│ ╲0╱────╱1╲ │
│ │ │ │
""".strip()
assert actual_text_diagram == expected_text_diagram
assert cca.get_acquaintance_size(cubic_strategy) == 3