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):