def test_toffoli():
a, b, c, d = cirq.LineQubit.range(4)
# Raw.
circuit = cirq.Circuit.from_ops(cirq.TOFFOLI(a, b, c))
assert_links_to(circuit,
"""
http://algassert.com/quirk#circuit={"cols":[["•","•","X"]]}
""",
escape_url=False)
# With exponent. Doesn't merge with other operation.
circuit = cirq.Circuit.from_ops(cirq.CCX(a, b, c)**0.5, cirq.H(d))
assert_links_to(circuit,
"""
http://algassert.com/quirk#circuit={"cols":[
["•","•","X^½"],[1,1,1,"H"]]}
""",
escape_url=False)
# Unknown exponent.
circuit = cirq.Circuit.from_ops(cirq.CCX(a, b, c)**0.01)
assert_links_to(circuit,
"""
http://algassert.com/quirk#circuit={"cols":[
["UNKNOWN","UNKNOWN","UNKNOWN"]
]}
""",
escape_url=False,
prefer_unknown_gate_to_failure=True)
def test_merge_moments_deep():
q = cirq.LineQubit.range(3)
c_z_moments = cirq.Circuit(
[cirq.Z.on_each(q[0], q[1]), cirq.Z.on_each(q[1], q[2]), cirq.Z.on_each(q[1], q[0])],
strategy=cirq.InsertStrategy.NEW_THEN_INLINE,
)
merged_z_moment = cirq.Moment(cirq.Z.on_each(*q[1:]))
c_nested_circuit = cirq.FrozenCircuit(c_z_moments, cirq.CCX(*q), c_z_moments)
c_merged_circuit = cirq.FrozenCircuit(merged_z_moment, cirq.CCX(*q), merged_z_moment)
c_orig = cirq.Circuit(
cirq.CircuitOperation(c_nested_circuit).repeat(5).with_tags("ignore"),
c_nested_circuit,
cirq.CircuitOperation(c_nested_circuit).repeat(6).with_tags("preserve_tag"),
c_nested_circuit,
cirq.CircuitOperation(c_nested_circuit).repeat(7),
)
c_expected = cirq.Circuit(
cirq.CircuitOperation(c_nested_circuit).repeat(5).with_tags("ignore"),
c_merged_circuit,
cirq.CircuitOperation(c_merged_circuit).repeat(6).with_tags("preserve_tag"),
c_merged_circuit,
cirq.CircuitOperation(c_merged_circuit).repeat(7),
)
cirq.testing.assert_same_circuits(
cirq.merge_moments(c_orig, _merge_z_moments_func, tags_to_ignore=("ignore",), deep=True),
c_expected,
)
def _all_operations(q0, q1, q2, q3, q4, include_measurements=True):
class DummyOperation(cirq.Operation):
qubits = (q0, )
with_qubits = NotImplemented
def _qasm_(self, args: cirq.QasmArgs) -> str:
return '// Dummy operation\n'
def _decompose_(self):
# Only used by test_output_unitary_same_as_qiskit
return () # coverage: ignore
class DummyCompositeOperation(cirq.Operation):
qubits = (q0, )
with_qubits = NotImplemented
def _decompose_(self):
return cirq.X(self.qubits[0])
def __repr__(self):
return 'DummyCompositeOperation()'
return (
cirq.Z(q0),
cirq.Z(q0)**0.625,
cirq.Y(q0),
cirq.Y(q0)**0.375,
cirq.X(q0),
cirq.X(q0)**0.875,
cirq.H(q1),
cirq.CZ(q0, q1),
cirq.CZ(q0, q1)**0.25, # Requires 2-qubit decomposition
cirq.CNOT(q0, q1),
cirq.CNOT(q0, q1)**0.5, # Requires 2-qubit decomposition
cirq.SWAP(q0, q1),
cirq.SWAP(q0, q1)**0.75, # Requires 2-qubit decomposition
cirq.CCZ(q0, q1, q2),
cirq.CCX(q0, q1, q2),
cirq.CCZ(q0, q1, q2)**0.5,
cirq.CCX(q0, q1, q2)**0.5,
cirq.CSWAP(q0, q1, q2),
cirq.IdentityGate(1).on(q0),
cirq.IdentityGate(3).on(q0, q1, q2),
cirq.ISWAP(q2, q0), # Requires 2-qubit decomposition
cirq.PhasedXPowGate(phase_exponent=0.111, exponent=0.25).on(q1),
cirq.PhasedXPowGate(phase_exponent=0.333, exponent=0.5).on(q1),
cirq.PhasedXPowGate(phase_exponent=0.777, exponent=-0.5).on(q1),
(
cirq.measure(q0, key='xX'),
cirq.measure(q2, key='x_a'),
cirq.measure(q1, key='x?'),
cirq.measure(q3, key='X'),
cirq.measure(q4, key='_x'),
cirq.measure(q2, key='x_a'),
cirq.measure(q1, q2, q3, key='multi', invert_mask=(False, True)),
) if include_measurements else (),
DummyOperation(),
DummyCompositeOperation(),
)
def _all_operations(q0, q1, q2, q3, q4, include_measurments=True):
class DummyOperation(cirq.Operation, cirq.QasmConvertibleOperation,
cirq.CompositeOperation):
qubits = (q0, )
with_qubits = NotImplemented
def known_qasm_output(self, args):
return '// Dummy operation\n'
def default_decompose(self):
# Only used by test_output_unitary_same_as_qiskit
return () # coverage: ignore
class DummyCompositeOperation(cirq.Operation, cirq.CompositeOperation):
qubits = (q0, )
with_qubits = NotImplemented
def default_decompose(self):
return cirq.X(self.qubits[0])
def __repr__(self):
return 'DummyCompositeOperation()'
return (
cirq.Z(q0),
cirq.Z(q0)**.625,
cirq.Y(q0),
cirq.Y(q0)**.375,
cirq.X(q0),
cirq.X(q0)**.875,
cirq.H(q1),
cirq.CZ(q0, q1),
cirq.CZ(q0, q1)**0.25, # Requires 2-qubit decomposition
cirq.CNOT(q0, q1),
cirq.CNOT(q0, q1)**0.5, # Requires 2-qubit decomposition
cirq.SWAP(q0, q1),
cirq.SWAP(q0, q1)**0.75, # Requires 2-qubit decomposition
cirq.CCZ(q0, q1, q2),
cirq.CCX(q0, q1, q2),
cirq.CCZ(q0, q1, q2)**0.5,
cirq.CCX(q0, q1, q2)**0.5,
cirq.CSWAP(q0, q1, q2),
cirq.ISWAP(q2, q0), # Requires 2-qubit decomposition
cirq.google.ExpWGate(axis_half_turns=0.125, half_turns=0.25)(q1),
(
cirq.MeasurementGate('xX')(q0),
cirq.MeasurementGate('x_a')(q2),
cirq.MeasurementGate('x?')(q1),
cirq.MeasurementGate('X')(q3),
cirq.MeasurementGate('_x')(q4),
cirq.MeasurementGate('x_a')(q2),
cirq.MeasurementGate('multi', (False, True))(q1, q2, q3),
) if include_measurments else (),
DummyOperation(),
DummyCompositeOperation(),
)
def CNOT_toffoli_decomp(bitset, garbage, t, d):
target = t
gates = []
for i in range(1, len(bitset) - 1):
gates.append(cirq.CCX(garbage[-i - d], bitset[-i], target))
target = garbage[-i - d]
for gate in gates:
yield gate
gates.reverse()
yield cirq.CCX(bitset[0], bitset[1], target)
for gate in gates[:-1]:
yield gate
def wiki_test_function(circuit, input, output):
"""
This is a reverse-engineered implementation of the example function
provided on the Wiki article for Simon's problem:
https://en.wikipedia.org/wiki/Simon's_problem#Example
Parameters:
circuit (Circuit): The circuit being constructed
input (list[Qid]): The register that contains the input.
This can be in any arbitrary state.
output (list[Qid]): The register that will hold the function output.
This must be in the state |0...0>.
"""
# Prepare the first answer qubit
circuit.append(cirq.X(input[0]))
for i in range(0, 3):
circuit.append(cirq.CNOT(input[i], output[0]))
circuit.append(cirq.X(input[0]))
# Prepare the second answer qubit
circuit.append(cirq.CNOT(input[2], output[1]))
# Prepare the third answer qubit
circuit.append(cirq.X(output[1]))
circuit.append(cirq.CCX(output[0], output[1], output[2]))
circuit.append(cirq.X(output[1]))
def apply_n_qubit_tof(ancilla, args):
if (len(args) == 3):
yield cirq.CCX.on(args[0], args[1], args[2])
else:
yield cirq.CCX.on(args[0], args[1], ancilla[0])
for k in range(2, len(args)-1):
yield cirq.CCX(args[k], ancilla[k-2], ancilla[k-1])
yield cirq.CNOT.on(ancilla[len(args)-3], args[len(args)-1])
for k in range(len(args)-2, 1, -1):
yield cirq.CCX(args[k], ancilla[k-2], ancilla[k-1])
yield cirq.CCX.on(args[0], args[1], ancilla[0])
def test_diagram():
a, b, c, d = cirq.LineQubit.range(4)
circuit = cirq.Circuit.from_ops(cirq.TOFFOLI(a, b, c),
cirq.TOFFOLI(a, b, c)**0.5,
cirq.CCX(a, c, b), cirq.CCZ(a, d, b),
cirq.CCZ(a, d, b)**0.5,
cirq.CSWAP(a, c, d), cirq.FREDKIN(a, b, c))
cirq.testing.assert_has_diagram(
circuit, """
0: ───@───@───────@───@───@───────@───@───
│ │ │ │ │ │ │
1: ───@───@───────X───@───@───────┼───×───
│ │ │ │ │ │ │
2: ───X───X^0.5───@───┼───┼───────×───×───
│ │ │
3: ───────────────────@───@^0.5───×───────
""")
cirq.testing.assert_has_diagram(circuit,
"""
0: ---@---@-------@---@---@-------@------@------
| | | | | | |
1: ---@---@-------X---@---@-------|------swap---
| | | | | | |
2: ---X---X^0.5---@---|---|-------swap---swap---
| | |
3: -------------------@---@^0.5---swap----------
""",
use_unicode_characters=False)
def test_diagram():
a, b, c, d = cirq.LineQubit.range(4)
circuit = cirq.Circuit(
cirq.TOFFOLI(a, b, c),
cirq.TOFFOLI(a, b, c)**0.5,
cirq.CCX(a, c, b),
cirq.CCZ(a, d, b),
cirq.CCZ(a, d, b)**0.5,
cirq.CSWAP(a, c, d),
cirq.FREDKIN(a, b, c),
)
cirq.testing.assert_has_diagram(
circuit,
"""
0: ───@───@───────@───@───@───────@───@───
│ │ │ │ │ │ │
1: ───@───@───────X───@───@───────┼───×───
│ │ │ │ │ │ │
2: ───X───X^0.5───@───┼───┼───────×───×───
│ │ │
3: ───────────────────@───@^0.5───×───────
""",
)
cirq.testing.assert_has_diagram(
circuit,
"""
0: ---@---@-------@---@---@-------@------@------
| | | | | | |
1: ---@---@-------X---@---@-------|------swap---
| | | | | | |
2: ---X---X^0.5---@---|---|-------swap---swap---
| | |
3: -------------------@---@^0.5---swap----------
""",
use_unicode_characters=False,
)
diagonal_circuit = cirq.Circuit(
cirq.ThreeQubitDiagonalGate([2, 3, 5, 7, 11, 13, 17, 19])(a, b, c))
cirq.testing.assert_has_diagram(
diagonal_circuit,
"""
0: ───diag(2, 3, 5, 7, 11, 13, 17, 19)───
│
1: ───#2─────────────────────────────────
│
2: ───#3─────────────────────────────────
""",
)
cirq.testing.assert_has_diagram(
diagonal_circuit,
"""
0: ---diag(2, 3, 5, 7, 11, 13, 17, 19)---
|
1: ---#2---------------------------------
|
2: ---#3---------------------------------
""",
use_unicode_characters=False,
)
def test_cirq_channel_conversions_simple(self):
q0 = cirq.GridQubit(0,0)
q1 = cirq.GridQubit(0,1)
q2 = cirq.GridQubit(0,2)
#circ = cirq.Circuit([cirq.CZ(q0,q1), cirq.X.on(q0), cirq.CZ(q0,q1)])
circ = cirq.Circuit([cirq.CCX(q0,q1,q2),cirq.CZ(q0,q2),cirq.Y.on(q0), cirq.H.on(q2), cirq.CZ(q1,q2), cirq.X.on(q1), cirq.CZ(q0,q1),cirq.H.on(q0)])
C = mhel.cirq_to_total_channel(circ)
self.assertEqual(np.linalg.norm(C.kraus()[0]-circ.unitary()),0)
Clist = mhel.cirq_moments_to_channel_list(circ)
circ2 = mhel.channel_list_to_circuit(Clist)
self.assertEqual(np.linalg.norm(circ.unitary()-circ2.unitary()),0)
Clist2 = [ch.QuantumChannel(cirq.Circuit(m).unitary(),'unitary') for m in circ]
diffs = [np.linalg.norm(c.liouvillian()-c.liouvillian())==0 for c,cc in zip(Clist,Clist2)]
self.assertTrue(all(diffs))
Prop = [Clist[0]]
for CC in Clist[1:]:
Prop.append(CC*Prop[-1])
self.assertTrue(np.linalg.norm(Prop[-1].liouvillian()-C.liouvillian())<1e-14)
diffs = [np.linalg.norm(Prop[i-1].liouvillian()-ch.QuantumChannel(cirq.Circuit(circ[:i]).unitary(),'unitary').liouvillian())<=1e-14 for i in range(1,len(Prop))]
self.assertTrue(all(diffs))
def test_merge_moments():
q = cirq.LineQubit.range(3)
c_orig = cirq.Circuit(
cirq.Z.on_each(q[0], q[1]),
cirq.Z.on_each(q[1], q[2]),
cirq.Z.on_each(q[1], q[0]),
strategy=cirq.InsertStrategy.NEW_THEN_INLINE,
)
c_orig = cirq.Circuit(c_orig, cirq.CCX(*q), c_orig)
cirq.testing.assert_has_diagram(
c_orig,
'''
0: ───Z───────Z───@───Z───────Z───
│
1: ───Z───Z───Z───@───Z───Z───Z───
│
2: ───────Z───────X───────Z───────
''',
)
cirq.testing.assert_has_diagram(
cirq.merge_moments(c_orig, _merge_z_moments_func),
'''
0: ───────@───────
│
1: ───Z───@───Z───
│
2: ───Z───X───Z───
''',
)
def test_three_qubits():
q0, q1, q2 = cirq.LineQubit.range(3)
circuit = cirq.Circuit(cirq.CCX(q0, q1, q2))
with pytest.raises(ValueError,
match="Can only handle 1 and 2 qubit operations"):
assert_same_output_as_dense(circuit=circuit, qubit_order=[q0, q1, q2])
def test_same_pauli_traces_clifford():
n_qubits = 4
qubits = cirq.LineQubit.range(n_qubits)
circuit_clifford = cirq.Circuit(cirq.X(qubits[3]), )
circuit_general = cirq.Circuit(
cirq.CCX(qubits[0], qubits[1], qubits[2]),
circuit_clifford,
)
def _run_dfe(circuit):
class NoiseOnLastQubitOnly(cirq.NoiseModel):
def __init__(self):
self.qubit_noise_gate = cirq.amplitude_damp(1.0)
def noisy_moment(self, moment, system_qubits):
return [
moment,
cirq.Moment([
self.qubit_noise_gate(q).with_tags(
cirq.ops.VirtualTag()) for q in system_qubits[-1:]
]),
]
np.random.seed(0)
noise = NoiseOnLastQubitOnly()
noisy_simulator = cirq.DensityMatrixSimulator(noise=noise)
_, intermediate_results = dfe.direct_fidelity_estimation(
circuit,
qubits,
noisy_simulator,
n_measured_operators=None,
samples_per_term=1)
return intermediate_results.pauli_traces, intermediate_results.clifford_tableau is not None
# Run both algos
pauli_traces_clifford, clifford_is_clifford = _run_dfe(circuit_clifford)
pauli_traces_general, general_is_clifford = _run_dfe(circuit_general)
assert clifford_is_clifford
assert not general_is_clifford
assert len(pauli_traces_clifford) == 2**n_qubits
for pauli_trace_clifford in pauli_traces_clifford:
pauli_trace_general = [
x for x in pauli_traces_general
if x.P_i == pauli_trace_clifford.P_i
]
assert len(pauli_trace_general) == 1
pauli_trace_general = pauli_trace_general[0]
# The code itself checks that the rho_i is either +1 or -1, so here we
# simply test that the sign is the same.
assert np.isclose(pauli_trace_general.rho_i,
pauli_trace_clifford.rho_i,
atol=0.01)
def test_default_gates_and_qbit_reorder(self):
gcirq = cirq.Circuit()
qreg1 = [cirq.GridQubit(i, 0) for i in range(2)]
qreg2 = [cirq.LineQubit(0)]
qreg3 = [cirq.LineQubit(i) for i in range(1, 3)]
for op in gates_1qb:
gcirq.append(op(qreg2[0])**-1.0)
for op in gates_2qb:
gcirq.append(op(qreg3[0], qreg1[1])**-1.0)
gcirq.append(cirq.CCX(qreg1[0], qreg3[1], qreg2[0]))
gcirq.append(cirq.CSWAP(qreg1[0], qreg3[1], qreg2[0]))
gcirq.append(cirq.CCZ(qreg1[0], qreg3[1], qreg2[0]))
# Toffoli | (qreg3[1], qreg1[0], qreg2[0])
for qbit in qreg1 + qreg2 + qreg3:
gcirq.append(cirq.measure(qbit))
# Generating qlm circuit
result = cirq_to_qlm(gcirq)
# Generating equivalent qlm circuit
prog = Program()
qubits = prog.qalloc(5)
cbits = prog.calloc(5)
for op in pygates_1qb:
prog.apply(op.dag(), qubits[2])
for op in pygates_2qb:
prog.apply(op.dag(), qubits[3], qubits[1])
prog.apply(CCNOT, qubits[0], qubits[4], qubits[2])
prog.apply(SWAP.ctrl(), qubits[0], qubits[4], qubits[2])
prog.apply(Z.ctrl().ctrl(), qubits[0], qubits[4], qubits[2])
for i in range(5):
prog.measure(qubits[i], cbits[i])
expected = prog.to_circ()
self.assertEqual(len(result.ops), len(expected.ops))
for i in range(len(result.ops)):
res_op = result.ops[i]
exp_op = expected.ops[i]
if res_op.type == OpType.MEASURE:
self.assertEqual(res_op, exp_op)
continue
result_gate_name, result_gate_params = extract_syntax(
result.gateDic[res_op.gate], result.gateDic)
# print("got gate {} with params {} on qbits {}"
# .format(result_gate_name, result_gate_params,
# res_op.qbits))
expected_gate_name, expected_gate_params = extract_syntax(
expected.gateDic[exp_op.gate], expected.gateDic)
# print("expected gate {} with params {} on qbits {}"
# .format(expected_gate_name, expected_gate_params,
# exp_op.qbits))
self.assertEqual(expected_gate_name, result_gate_name)
self.assertEqual(expected_gate_params, result_gate_params)
def test_eq():
a, b, c, d = cirq.LineQubit.range(4)
eq = cirq.testing.EqualsTester()
eq.add_equality_group(cirq.CCZ(a, b, c), cirq.CCZ(a, c, b),
cirq.CCZ(b, c, a))
eq.add_equality_group(cirq.CCZ(a, b, d))
eq.add_equality_group(cirq.TOFFOLI(a, b, c), cirq.CCX(a, b, c))
eq.add_equality_group(cirq.TOFFOLI(a, c, b), cirq.TOFFOLI(c, a, b))
eq.add_equality_group(cirq.TOFFOLI(a, b, d))
eq.add_equality_group(cirq.CSWAP(a, b, c), cirq.FREDKIN(a, b, c))
eq.add_equality_group(cirq.CSWAP(b, a, c), cirq.CSWAP(b, c, a))
def matrix_to_sycamore_operations(qs: List[cirq.GridQubit],
matrix: np.ndarray) -> cirq.OP_TREE:
num_qubits = len(qs)
if np.allclose(matrix, np.eye(2**num_qubits)):
res = []
elif num_qubits == 3:
res = [cirq.CCX(*qs)]
else:
return NotImplemented
c = cirq.Circuit(res)
return cirq.google.optimized_for_sycamore(c).all_operations()
def test_autodecompose_deprecated():
dev = ValidatingTestDevice(
allowed_qubit_types=(cirq.LineQubit, ),
allowed_gates=(
cirq.XPowGate,
cirq.ZPowGate,
cirq.CZPowGate,
cirq.YPowGate,
cirq.MeasurementGate,
),
qubits=set(cirq.LineQubit.range(3)),
name='test',
validate_locality=False,
auto_decompose_gates=(cirq.CCXPowGate, ),
)
a, b, c = cirq.LineQubit.range(3)
circuit = cirq.Circuit(cirq.CCX(a, b, c), device=dev)
decomposed = cirq.decompose(cirq.CCX(a, b, c))
assert circuit.moments == cirq.Circuit(decomposed).moments
with pytest.raises(ValueError,
match="Unsupported gate type: cirq.TOFFOLI"):
dev = ValidatingTestDevice(
allowed_qubit_types=(cirq.LineQubit, ),
allowed_gates=(
cirq.XPowGate,
cirq.ZPowGate,
cirq.CZPowGate,
cirq.YPowGate,
cirq.MeasurementGate,
),
qubits=set(cirq.LineQubit.range(3)),
name='test',
validate_locality=False,
auto_decompose_gates=tuple(),
)
a, b, c = cirq.LineQubit.range(3)
cirq.Circuit(cirq.CCX(a, b, c), device=dev)
def _all_operations(q0, q1, q2, q3, q4, include_measurements=True):
return (
cirq.Z(q0),
cirq.Z(q0)**0.625,
cirq.Y(q0),
cirq.Y(q0)**0.375,
cirq.X(q0),
cirq.X(q0)**0.875,
cirq.H(q1),
cirq.CZ(q0, q1),
cirq.CZ(q0, q1)**0.25, # Requires 2-qubit decomposition
cirq.CNOT(q0, q1),
cirq.CNOT(q0, q1)**0.5, # Requires 2-qubit decomposition
cirq.SWAP(q0, q1),
cirq.SWAP(q1, q0)**-1,
cirq.SWAP(q0, q1)**0.75, # Requires 2-qubit decomposition
cirq.CCZ(q0, q1, q2),
cirq.CCX(q0, q1, q2),
cirq.CCZ(q0, q1, q2)**0.5,
cirq.CCX(q0, q1, q2)**0.5,
cirq.CSWAP(q0, q1, q2),
cirq.XX(q0, q1),
cirq.XX(q0, q1)**0.75,
cirq.YY(q0, q1),
cirq.YY(q0, q1)**0.75,
cirq.ZZ(q0, q1),
cirq.ZZ(q0, q1)**0.75,
cirq.IdentityGate(1).on(q0),
cirq.IdentityGate(3).on(q0, q1, q2),
cirq.ISWAP(q2, q0), # Requires 2-qubit decomposition
cirq.PhasedXPowGate(phase_exponent=0.111, exponent=0.25).on(q1),
cirq.PhasedXPowGate(phase_exponent=0.333, exponent=0.5).on(q1),
cirq.PhasedXPowGate(phase_exponent=0.777, exponent=-0.5).on(q1),
cirq.wait(q0, nanos=0),
cirq.measure(q0, key='xX'),
cirq.measure(q2, key='x_a'),
cirq.measure(q3, key='X'),
cirq.measure(q2, key='x_a'),
cirq.measure(q1, q2, q3, key='multi', invert_mask=(False, True)),
)
def test(qubits):
exp = 0.5
p = cirq.T**exp
c1, c2, c3, t = qubits
# yield cirq.H(t)
yield p(c1)
yield p(c2)
# yield cirq.CZ(c1, c2)**exp
yield p(c3)
yield p(t)
yield cirq.CCX(c1, c2, c3)
yield cirq.CNOT(c3, t)
yield (p**(-1))(c3)
yield p(t)
yield cirq.CCX(c1, c2, c3)
yield cirq.CNOT(c3, t)
yield cirq.CCX(c1, c2, c3)
yield (p**(-1))(t)
yield cirq.CNOT(c3, t)
yield cirq.CCX(c1, c2, c3)
yield (p**(-1))(t)
yield cirq.CNOT(c3, t)
def your_circuit(oracle):
"""3개 큐비트 도이치-조사 알고리즘을 위한 양자 회로 생성자."""
# 위상 반동(phase kickback) 공식을 사용합니다.
yield cirq.X(q2), cirq.H(q2)
# 입력 비트들을 동등한 양자 중첩상태로 바꿉니다.
yield cirq.H(q0), cirq.H(q1)
# 함수에 질의를 요청합니다.
yield oracle
# 결과를 얻기 위해 간섭을 수행하고 마지막 큐비트를 |1> 상태로 둡니다.
yield cirq.H(q0), cirq.H(q1), cirq.H(q2)
# 결과를 목적 큐비트에 담기 위해 마지막 OR 게이트를 수행합니다.
yield cirq.X(q0), cirq.X(q1), cirq.CCX(q0, q1, q2)
yield cirq.measure(q2)
def your_circuit(oracle):
"""Yields a circuit for the Deutsch-Jozsa algorithm on three qubits."""
# phase kickback trick
yield cirq.X(q2), cirq.H(q2)
# equal superposition over input bits
yield cirq.H(q0), cirq.H(q1)
# query the function
yield oracle
# interference to get result, put last qubit into |1>
yield cirq.H(q0), cirq.H(q1), cirq.H(q2)
# a final OR gate to put result in final qubit
yield cirq.X(q0), cirq.X(q1), cirq.CCX(q0, q1, q2)
yield cirq.measure(q2)
def test_merge_moments():
q = cirq.LineQubit.range(3)
c_orig = cirq.Circuit(
cirq.Z.on_each(q[0], q[1]),
cirq.Z.on_each(q[1], q[2]),
cirq.Z.on_each(q[1], q[0]),
strategy=cirq.InsertStrategy.NEW_THEN_INLINE,
)
c_orig = cirq.Circuit(c_orig, cirq.CCX(*q), c_orig)
cirq.testing.assert_has_diagram(
c_orig,
'''
0: ───Z───────Z───@───Z───────Z───
│
1: ───Z───Z───Z───@───Z───Z───Z───
│
2: ───────Z───────X───────Z───────
''',
)
def merge_func(m1: cirq.Moment, m2: cirq.Moment) -> Optional[cirq.Moment]:
def is_z_moment(m):
return all(op.gate == cirq.Z for op in m)
if not (is_z_moment(m1) and is_z_moment(m2)):
return None
qubits = m1.qubits | m2.qubits
def mul(op1, op2):
return (op1 or op2) if not (op1 and op2) else cirq.decompose_once(
op1 * op2)
return cirq.Moment(
mul(m1.operation_at(q), m2.operation_at(q)) for q in qubits)
cirq.testing.assert_has_diagram(
cirq.merge_moments(c_orig, merge_func),
'''
0: ───────@───────
│
1: ───Z───@───Z───
│
2: ───Z───X───Z───
''',
)
def decompose_large_CNOT(control_qubits, target, ancilla):
if len(control_qubits) == 0:
return cirq.X(target)
if len(control_qubits) == 1:
return cirq.CX(control_qubits[0], target)
if len(control_qubits) == 2:
return cirq.CCX(control_qubits[0], control_qubits[1], target)
bitset1 = [tq for i, tq in enumerate(control_qubits) if i % 2 == 0]
bitset2 = [tq for i, tq in enumerate(control_qubits) if i % 2 == 1]
bitset2.append(ancilla)
gate1 = CNOT_toffoli_decomp(bitset1, bitset2, ancilla, 1)
gate2 = CNOT_toffoli_decomp(bitset2, bitset1, target, 0)
gate3 = CNOT_toffoli_decomp(bitset1, bitset2, ancilla, 1)
gate4 = CNOT_toffoli_decomp(bitset2, bitset1, target, 0)
return cirq.Circuit([gate1, gate2, gate3, gate4])
def test_circuit_to_compute_and_feed_dict_works_on_unknown_ops():
qs = cirq.LineQubit.range(10)
class PhasedSwapGate(cirq.TwoQubitGate):
def _unitary_(self):
return np.array([
[1, 0, 0, 0],
[0, 0, -1j, 0],
[0, -1, 0, 0],
[0, 0, 0, 1j],
])
phased_swap = PhasedSwapGate()
c = cirq.Circuit([cirq.Y(q)**(0.13 * i + 0.1) for i, q in enumerate(qs)],
cirq.CCX(qs[0], qs[4], qs[8])**0.5,
phased_swap(qs[0], qs[1]), phased_swap(qs[3], qs[9]),
phased_swap(qs[0], qs[6]), phased_swap(qs[9], qs[8]))
_assert_evaluates_correctly(c, up_to_global_phase=True)
def test_decomposable_gate(self):
qubits = cirq.LineQubit.range(3)
# The Toffoli gate (CCX) decomposes into multiple qsim-supported gates.
cirq_circuit = cirq.Circuit(
cirq.H(qubits[0]),
cirq.H(qubits[1]),
cirq.CCX(*qubits),
cirq.H(qubits[2]),
)
qsimSim = qsimcirq.QSimSimulator()
result = qsimSim.simulate(cirq_circuit, qubit_order=qubits)
assert result.state_vector().shape == (8, )
cirqSim = cirq.Simulator()
cirq_result = cirqSim.simulate(cirq_circuit, qubit_order=qubits)
# Decomposition may result in gates which add a global phase.
assert cirq.linalg.allclose_up_to_global_phase(
result.state_vector(), cirq_result.state_vector())
def test_extra_controlled_bits():
q0, q1 = cirq.LineQubit.range(2)
circuit = cirq.Circuit(
cirq.measure(q0, key='a'),
cirq.CX(q0, q1).with_classical_controls('a'),
cirq.measure(q1, key='b'),
)
assert_equivalent_to_deferred(circuit)
deferred = cirq.defer_measurements(circuit)
q_ma = _MeasurementQid('a', q0)
cirq.testing.assert_same_circuits(
deferred,
cirq.Circuit(
cirq.CX(q0, q_ma),
cirq.CCX(q_ma, q0, q1),
cirq.measure(q_ma, key='a'),
cirq.measure(q1, key='b'),
),
)
def your_circuit(oracle):
# Phase kickback
yield cirq.X(q2), cirq.H(q2)
# Superposition over input bits
yield cirq.H(q0), cirq.H(q1)
# Query the function
yield oracle
# Interference to get result,
# put last qubit in to |1> state
yield cirq.H(q0), cirq.H(q1), cirq.H(q2)
# A final OR gate to put the result
# in to the final qubit
yield cirq.X(q0), cirq.X(q1), cirq.CCX(q0, q1, q2)
# Perform measurement
yield cirq.measure(q2)
def test_diagram():
a, b, c, d = cirq.LineQubit.range(4)
circuit = cirq.Circuit.from_ops(cirq.TOFFOLI(a, b, c), cirq.CCX(a, c, b),
cirq.CCZ(a, d, b), cirq.CSWAP(a, c, d),
cirq.FREDKIN(a, b, c))
assert circuit.to_text_diagram() == """
0: ───@───@───@───@───@───
│ │ │ │ │
1: ───@───X───@───┼───×───
│ │ │ │ │
2: ───X───@───┼───×───×───
│ │
3: ───────────@───×───────
""".strip()
assert circuit.to_text_diagram(use_unicode_characters=False) == """
0: ---@---@---@---@------@------
| | | | |
1: ---@---X---@---|------swap---
| | | | |
2: ---X---@---|---swap---swap---
| |
3: -----------@---swap----------
""".strip()
def test_identity_multiplication():
a, b, c = cirq.LineQubit.range(3)
assert cirq.CCX(a, b, c) * cirq.I(a) == cirq.CCX(a, b, c)
assert cirq.CCX(a, b, c) * cirq.I(b) == cirq.CCX(a, b, c)
assert cirq.CCX(a, b, c)**0.5 * cirq.I(c) == cirq.CCX(a, b, c)**0.5
assert cirq.I(c) * cirq.CCZ(a, b, c)**0.5 == cirq.CCZ(a, b, c)**0.5
eq.add_equality_group(cirq.CCZPowGate(), cirq.CCZPowGate())
def test_identity_multiplication():
a, b, c = cirq.LineQubit.range(3)
assert cirq.CCX(a, b, c) * cirq.I(a) == cirq.CCX(a, b, c)
assert cirq.CCX(a, b, c) * cirq.I(b) == cirq.CCX(a, b, c)
assert cirq.CCX(a, b, c)**0.5 * cirq.I(c) == cirq.CCX(a, b, c)**0.5
assert cirq.I(c) * cirq.CCZ(a, b, c)**0.5 == cirq.CCZ(a, b, c)**0.5
@pytest.mark.parametrize(
'op,max_two_cost',
[
(cirq.CCZ(*cirq.LineQubit.range(3)), 8),
(cirq.CCX(*cirq.LineQubit.range(3)), 8),
(cirq.CCZ(cirq.LineQubit(0), cirq.LineQubit(2), cirq.LineQubit(1)), 8),
(cirq.CCZ(cirq.LineQubit(0), cirq.LineQubit(2), cirq.LineQubit(1))**
sympy.Symbol("s"), 8),
(cirq.CSWAP(*cirq.LineQubit.range(3)), 9),
(cirq.CSWAP(*reversed(cirq.LineQubit.range(3))), 9),
(cirq.CSWAP(cirq.LineQubit(1), cirq.LineQubit(0),
cirq.LineQubit(2)), 12),
(
cirq.ThreeQubitDiagonalGate([2, 3, 5, 7, 11, 13, 17, 19])(
cirq.LineQubit(1), cirq.LineQubit(2), cirq.LineQubit(3)),
8,
),
],
)
def test_decomposition_cost(op: cirq.Operation, max_two_cost: int):
