def test_string_format(): x, y, z = cirq.LineQubit.range(3) fc0 = cirq.FrozenCircuit() op0 = cirq.CircuitOperation(fc0) assert ( str(op0) == f"""\ {op0.circuit.serialization_key()}: [ ]""" ) fc1 = cirq.FrozenCircuit(cirq.X(x), cirq.H(y), cirq.CX(y, z), cirq.measure(x, y, z, key='m')) op1 = cirq.CircuitOperation(fc1) assert ( str(op1) == f"""\ {op1.circuit.serialization_key()}: [ 0: ───X───────M('m')─── ] [ │ ] [ 1: ───H───@───M──────── ] [ │ │ ] [ 2: ───────X───M──────── ]""" ) assert ( repr(op1) == f"""\ cirq.CircuitOperation( circuit=cirq.FrozenCircuit([ cirq.Moment( cirq.X(cirq.LineQubit(0)), cirq.H(cirq.LineQubit(1)), ), cirq.Moment( cirq.CNOT(cirq.LineQubit(1), cirq.LineQubit(2)), ), cirq.Moment( cirq.measure(cirq.LineQubit(0), cirq.LineQubit(1), cirq.LineQubit(2), key='m'), ), ]), )""" ) fc2 = cirq.FrozenCircuit(cirq.X(x), cirq.H(y), cirq.CX(y, x)) op2 = cirq.CircuitOperation(circuit=fc2, qubit_map=({y: z}), repetitions=3) assert ( str(op2) == f"""\ {op2.circuit.serialization_key()}: [ 0: ───X───X─── ] [ │ ] [ 1: ───H───@─── ](qubit_map={{1: 2}}, loops=3)""" ) assert ( repr(op2) == """\ cirq.CircuitOperation( circuit=cirq.FrozenCircuit([ cirq.Moment( cirq.X(cirq.LineQubit(0)), cirq.H(cirq.LineQubit(1)), ), cirq.Moment( cirq.CNOT(cirq.LineQubit(1), cirq.LineQubit(0)), ), ]), repetitions=3, qubit_map={cirq.LineQubit(1): cirq.LineQubit(2)}, )""" ) fc3 = cirq.FrozenCircuit( cirq.X(x) ** sympy.Symbol('b'), cirq.measure(x, key='m'), ) op3 = cirq.CircuitOperation( circuit=fc3, qubit_map={x: y}, measurement_key_map={'m': 'p'}, param_resolver={sympy.Symbol('b'): 2}, ) indented_fc3_repr = repr(fc3).replace('\n', '\n ') assert ( str(op3) == f"""\ {op3.circuit.serialization_key()}: [ 0: ───X^b───M('m')─── ](qubit_map={{0: 1}}, \ key_map={{m: p}}, params={{b: 2}})""" ) assert ( repr(op3) == f"""\ cirq.CircuitOperation( circuit={indented_fc3_repr}, qubit_map={{cirq.LineQubit(0): cirq.LineQubit(1)}}, measurement_key_map={{'m': 'p'}}, param_resolver=cirq.ParamResolver({{sympy.Symbol('b'): 2}}), )""" ) fc4 = cirq.FrozenCircuit(cirq.X(y)) op4 = cirq.CircuitOperation(fc4) fc5 = cirq.FrozenCircuit(cirq.X(x), op4) op5 = cirq.CircuitOperation(fc5) assert ( repr(op5) == f"""\ cirq.CircuitOperation( circuit=cirq.FrozenCircuit([ cirq.Moment( cirq.X(cirq.LineQubit(0)), cirq.CircuitOperation( circuit=cirq.FrozenCircuit([ cirq.Moment( cirq.X(cirq.LineQubit(1)), ), ]), ), ), ]), )""" )
def test_map_operations_deep_subcircuits(): q = cirq.LineQubit.range(5) c_orig = cirq.Circuit(cirq.CX(q[0], q[1]), cirq.CX(q[3], q[2]), cirq.CX(q[3], q[4])) c_orig_with_circuit_ops = cirq.Circuit( cirq.CircuitOperation( cirq.FrozenCircuit( [ cirq.CircuitOperation(cirq.FrozenCircuit(op)).repeat(2).with_tags("internal") for op in c_orig.all_operations() ] ) ) .repeat(6) .with_tags("external") ) def map_func(op: cirq.Operation, _: int) -> cirq.OP_TREE: yield [ cirq.Z.on_each(*op.qubits), cirq.CX(*op.qubits), cirq.Z.on_each(*op.qubits), ] if op.gate == cirq.CX else op cirq.testing.assert_has_diagram( c_orig_with_circuit_ops, ''' [ [ 0: ───@─── ] ] [ 0: ───[ │ ]────────────────────────────────────────────────────────────── ] [ [ 1: ───X─── ](loops=2)['internal'] ] [ │ ] [ 1: ───#2────────────────────────────────────────────────────────────────────────── ] [ ] [ [ 2: ───X─── ] ] 0: ───[ 2: ───[ │ ]────────────────────────────────────────────────────────────── ]──────────────────────── [ [ 3: ───@─── ](loops=2)['internal'] ] [ │ ] [ │ [ 3: ───@─── ] ] [ 3: ───#2────────────────────────────────────[ │ ]──────────────────────── ] [ [ 4: ───X─── ](loops=2)['internal'] ] [ │ ] [ 4: ─────────────────────────────────────────#2──────────────────────────────────── ](loops=6)['external'] │ 1: ───#2──────────────────────────────────────────────────────────────────────────────────────────────────────────── │ 2: ───#3──────────────────────────────────────────────────────────────────────────────────────────────────────────── │ 3: ───#4──────────────────────────────────────────────────────────────────────────────────────────────────────────── │ 4: ───#5──────────────────────────────────────────────────────────────────────────────────────────────────────────── ''', ) c_mapped = cirq.map_operations(c_orig_with_circuit_ops, map_func, deep=True) for unroller in [ cirq.unroll_circuit_op, cirq.unroll_circuit_op_greedy_earliest, cirq.unroll_circuit_op_greedy_frontier, ]: cirq.testing.assert_has_diagram( unroller(c_mapped, deep=True), ''' [ [ 0: ───Z───@───Z─── ] ] [ 0: ───[ │ ]────────────────────────────────────────────────────────────────────── ] [ [ 1: ───Z───X───Z─── ](loops=2)['internal'] ] [ │ ] [ 1: ───#2────────────────────────────────────────────────────────────────────────────────────────── ] [ ] [ [ 2: ───Z───X───Z─── ] ] 0: ───[ 2: ───[ │ ]────────────────────────────────────────────────────────────────────── ]──────────────────────── [ [ 3: ───Z───@───Z─── ](loops=2)['internal'] ] [ │ ] [ │ [ 3: ───Z───@───Z─── ] ] [ 3: ───#2────────────────────────────────────────────[ │ ]──────────────────────── ] [ [ 4: ───Z───X───Z─── ](loops=2)['internal'] ] [ │ ] [ 4: ─────────────────────────────────────────────────#2──────────────────────────────────────────── ](loops=6)['external'] │ 1: ───#2──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── │ 2: ───#3──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── │ 3: ───#4──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── │ 4: ───#5──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── ''', )
def map_func(op: cirq.Operation, _: int) -> cirq.OP_TREE: yield cirq.Z.on_each(*op.qubits) yield cirq.CX(*op.qubits) yield cirq.Z.on_each(*op.qubits)
def test_cirq_qsim_all_supported_gates(): q0 = cirq.GridQubit(1, 1) q1 = cirq.GridQubit(1, 0) q2 = cirq.GridQubit(0, 1) q3 = cirq.GridQubit(0, 0) circuit = cirq.Circuit( cirq.Moment([ cirq.H(q0), cirq.H(q1), cirq.H(q2), cirq.H(q3), ]), cirq.Moment([ cirq.T(q0), cirq.T(q1), cirq.T(q2), cirq.T(q3), ]), cirq.Moment([ cirq.CZPowGate(exponent=0.7, global_shift=0.2)(q0, q1), cirq.CXPowGate(exponent=1.2, global_shift=0.4)(q2, q3), ]), cirq.Moment([ cirq.XPowGate(exponent=0.3, global_shift=1.1)(q0), cirq.YPowGate(exponent=0.4, global_shift=1)(q1), cirq.ZPowGate(exponent=0.5, global_shift=0.9)(q2), cirq.HPowGate(exponent=0.6, global_shift=0.8)(q3), ]), cirq.Moment([ cirq.CX(q0, q2), cirq.CZ(q1, q3), ]), cirq.Moment([ cirq.X(q0), cirq.Y(q1), cirq.Z(q2), cirq.S(q3), ]), cirq.Moment([ cirq.XXPowGate(exponent=0.4, global_shift=0.7)(q0, q1), cirq.YYPowGate(exponent=0.8, global_shift=0.5)(q2, q3), ]), cirq.Moment([cirq.I(q0), cirq.I(q1), cirq.IdentityGate(2)(q2, q3)]), cirq.Moment([ cirq.rx(0.7)(q0), cirq.ry(0.2)(q1), cirq.rz(0.4)(q2), cirq.PhasedXPowGate(phase_exponent=0.8, exponent=0.6, global_shift=0.3)(q3), ]), cirq.Moment([ cirq.ZZPowGate(exponent=0.3, global_shift=1.3)(q0, q2), cirq.ISwapPowGate(exponent=0.6, global_shift=1.2)(q1, q3), ]), cirq.Moment([ cirq.XPowGate(exponent=0.1, global_shift=0.9)(q0), cirq.YPowGate(exponent=0.2, global_shift=1)(q1), cirq.ZPowGate(exponent=0.3, global_shift=1.1)(q2), cirq.HPowGate(exponent=0.4, global_shift=1.2)(q3), ]), cirq.Moment([ cirq.SwapPowGate(exponent=0.2, global_shift=0.9)(q0, q1), cirq.PhasedISwapPowGate(phase_exponent=0.8, exponent=0.6)(q2, q3), ]), cirq.Moment([ cirq.PhasedXZGate(x_exponent=0.2, z_exponent=0.3, axis_phase_exponent=1.4)(q0), cirq.T(q1), cirq.H(q2), cirq.S(q3), ]), cirq.Moment([ cirq.SWAP(q0, q2), cirq.XX(q1, q3), ]), cirq.Moment([ cirq.rx(0.8)(q0), cirq.ry(0.9)(q1), cirq.rz(1.2)(q2), cirq.T(q3), ]), cirq.Moment([ cirq.YY(q0, q1), cirq.ISWAP(q2, q3), ]), cirq.Moment([ cirq.T(q0), cirq.Z(q1), cirq.Y(q2), cirq.X(q3), ]), cirq.Moment([ cirq.FSimGate(0.3, 1.7)(q0, q2), cirq.ZZ(q1, q3), ]), cirq.Moment([ cirq.ry(1.3)(q0), cirq.rz(0.4)(q1), cirq.rx(0.7)(q2), cirq.S(q3), ]), cirq.Moment([ cirq.IdentityGate(4).on(q0, q1, q2, q3), ]), cirq.Moment([ cirq.CCZPowGate(exponent=0.7, global_shift=0.3)(q2, q0, q1), ]), cirq.Moment([ cirq.CCXPowGate(exponent=0.4, global_shift=0.6)( q3, q1, q0).controlled_by(q2, control_values=[0]), ]), cirq.Moment([ cirq.rx(0.3)(q0), cirq.ry(0.5)(q1), cirq.rz(0.7)(q2), cirq.rx(0.9)(q3), ]), cirq.Moment([ cirq.TwoQubitDiagonalGate([0.1, 0.2, 0.3, 0.4])(q0, q1), ]), cirq.Moment([ cirq.ThreeQubitDiagonalGate([0.5, 0.6, 0.7, 0.8, 0.9, 1, 1.2, 1.3])(q1, q2, q3), ]), cirq.Moment([ cirq.CSwapGate()(q0, q3, q1), ]), cirq.Moment([ cirq.rz(0.6)(q0), cirq.rx(0.7)(q1), cirq.ry(0.8)(q2), cirq.rz(0.9)(q3), ]), cirq.Moment([ cirq.TOFFOLI(q3, q2, q0), ]), cirq.Moment([ cirq.FREDKIN(q1, q3, q2), ]), cirq.Moment([ cirq.MatrixGate( np.array([[0, -0.5 - 0.5j, -0.5 - 0.5j, 0], [0.5 - 0.5j, 0, 0, -0.5 + 0.5j], [0.5 - 0.5j, 0, 0, 0.5 - 0.5j], [0, -0.5 - 0.5j, 0.5 + 0.5j, 0]]))(q0, q1), cirq.MatrixGate( np.array([[0.5 - 0.5j, 0, 0, -0.5 + 0.5j], [0, 0.5 - 0.5j, -0.5 + 0.5j, 0], [0, -0.5 + 0.5j, -0.5 + 0.5j, 0], [0.5 - 0.5j, 0, 0, 0.5 - 0.5j]]))(q2, q3), ]), cirq.Moment([ cirq.MatrixGate(np.array([[1, 0], [0, 1j]]))(q0), cirq.MatrixGate(np.array([[0, -1j], [1j, 0]]))(q1), cirq.MatrixGate(np.array([[0, 1], [1, 0]]))(q2), cirq.MatrixGate(np.array([[1, 0], [0, -1]]))(q3), ]), cirq.Moment([ cirq.riswap(0.7)(q0, q1), cirq.givens(1.2)(q2, q3), ]), cirq.Moment([ cirq.H(q0), cirq.H(q1), cirq.H(q2), cirq.H(q3), ]), ) simulator = cirq.Simulator() cirq_result = simulator.simulate(circuit) qsim_simulator = qsimcirq.QSimSimulator() qsim_result = qsim_simulator.simulate(circuit) assert cirq.linalg.allclose_up_to_global_phase(qsim_result.state_vector(), cirq_result.state_vector())
import cirq q0, q1 = cirq.LineQubit.range(2) # q0 = cirq.GridQubit(0, 0) # q1 = cirq.GridQubit(0, 1) circuit = cirq.Circuit() circuit.append([cirq.H(q0), cirq.H(q1)]) # Oracle for |00⟩ : circuit.append([cirq.X(q0), cirq.X(q1)]) circuit.append(cirq.CX(q0, q1)) circuit.append([cirq.X(q0), cirq.X(q1)]) circuit.append([cirq.H(q0), cirq.H(q1)]) # reflection circuit : circuit.append([cirq.Z(q0), cirq.Z(q1)]) circuit.append(cirq.CX(q0, q1)) circuit.append([cirq.H(q0), cirq.H(q1)]) circuit.append([cirq.measure(q0), cirq.measure(q1)]) print(circuit) simulator = cirq.Simulator() result = simulator.simulate(circuit) # result = simulator.run(circuit, repetitions=40) # NISQ computers print(result)
def map_func(op: cirq.Operation, _: int) -> cirq.OP_TREE: yield [ cirq.Z.on_each(*op.qubits), cirq.CX(*op.qubits), cirq.Z.on_each(*op.qubits), ] if op.gate == cirq.CX else op
def test_string_format(): x, y, z = cirq.LineQubit.range(3) fc0 = cirq.FrozenCircuit() op0 = cirq.CircuitOperation(fc0) assert str(op0) == f"[ ]" fc0_global_phase_inner = cirq.FrozenCircuit( cirq.global_phase_operation(1j), cirq.global_phase_operation(1j)) op0_global_phase_inner = cirq.CircuitOperation(fc0_global_phase_inner) fc0_global_phase_outer = cirq.FrozenCircuit( op0_global_phase_inner, cirq.global_phase_operation(1j)) op0_global_phase_outer = cirq.CircuitOperation(fc0_global_phase_outer) assert (str(op0_global_phase_outer) == f"""\ [ ] [ ] [ global phase: -0.5π ]""") fc1 = cirq.FrozenCircuit(cirq.X(x), cirq.H(y), cirq.CX(y, z), cirq.measure(x, y, z, key='m')) op1 = cirq.CircuitOperation(fc1) assert (str(op1) == f"""\ [ 0: ───X───────M('m')─── ] [ │ ] [ 1: ───H───@───M──────── ] [ │ │ ] [ 2: ───────X───M──────── ]""") assert (repr(op1) == """\ cirq.CircuitOperation( circuit=cirq.FrozenCircuit([ cirq.Moment( cirq.X(cirq.LineQubit(0)), cirq.H(cirq.LineQubit(1)), ), cirq.Moment( cirq.CNOT(cirq.LineQubit(1), cirq.LineQubit(2)), ), cirq.Moment( cirq.measure(cirq.LineQubit(0), cirq.LineQubit(1), cirq.LineQubit(2), key=cirq.MeasurementKey(name='m')), ), ]), )""") fc2 = cirq.FrozenCircuit(cirq.X(x), cirq.H(y), cirq.CX(y, x)) op2 = cirq.CircuitOperation( circuit=fc2, qubit_map=({ y: z }), repetitions=3, parent_path=('outer', 'inner'), repetition_ids=['a', 'b', 'c'], ) assert (str(op2) == f"""\ [ 0: ───X───X─── ] [ │ ] [ 1: ───H───@─── ](qubit_map={{q(1): q(2)}}, parent_path=('outer', 'inner'),\ repetition_ids=['a', 'b', 'c'])""") assert (repr(op2) == """\ cirq.CircuitOperation( circuit=cirq.FrozenCircuit([ cirq.Moment( cirq.X(cirq.LineQubit(0)), cirq.H(cirq.LineQubit(1)), ), cirq.Moment( cirq.CNOT(cirq.LineQubit(1), cirq.LineQubit(0)), ), ]), repetitions=3, qubit_map={cirq.LineQubit(1): cirq.LineQubit(2)}, parent_path=('outer', 'inner'), repetition_ids=['a', 'b', 'c'], )""") fc3 = cirq.FrozenCircuit( cirq.X(x)**sympy.Symbol('b'), cirq.measure(x, key='m')) op3 = cirq.CircuitOperation( circuit=fc3, qubit_map={x: y}, measurement_key_map={'m': 'p'}, param_resolver={sympy.Symbol('b'): 2}, ) indented_fc3_repr = repr(fc3).replace('\n', '\n ') assert (str(op3) == f"""\ [ 0: ───X^b───M('m')─── ](qubit_map={{q(0): q(1)}}, \ key_map={{m: p}}, params={{b: 2}})""") assert (repr(op3) == f"""\ cirq.CircuitOperation( circuit={indented_fc3_repr}, qubit_map={{cirq.LineQubit(0): cirq.LineQubit(1)}}, measurement_key_map={{'m': 'p'}}, param_resolver=cirq.ParamResolver({{sympy.Symbol('b'): 2}}), )""") fc4 = cirq.FrozenCircuit(cirq.X(y)) op4 = cirq.CircuitOperation(fc4) fc5 = cirq.FrozenCircuit(cirq.X(x), op4) op5 = cirq.CircuitOperation(fc5) assert (repr(op5) == """\ cirq.CircuitOperation( circuit=cirq.FrozenCircuit([ cirq.Moment( cirq.X(cirq.LineQubit(0)), cirq.CircuitOperation( circuit=cirq.FrozenCircuit([ cirq.Moment( cirq.X(cirq.LineQubit(1)), ), ]), ), ), ]), )""") op6 = cirq.CircuitOperation(fc5, use_repetition_ids=False) assert (repr(op6) == """\ cirq.CircuitOperation( circuit=cirq.FrozenCircuit([ cirq.Moment( cirq.X(cirq.LineQubit(0)), cirq.CircuitOperation( circuit=cirq.FrozenCircuit([ cirq.Moment( cirq.X(cirq.LineQubit(1)), ), ]), ), ), ]), use_repetition_ids=False, )""") op7 = cirq.CircuitOperation( cirq.FrozenCircuit(cirq.measure(x, key='a')), use_repetition_ids=False, repeat_until=cirq.KeyCondition(cirq.MeasurementKey('a')), ) assert (repr(op7) == """\ cirq.CircuitOperation( circuit=cirq.FrozenCircuit([ cirq.Moment( cirq.measure(cirq.LineQubit(0), key=cirq.MeasurementKey(name='a')), ), ]), use_repetition_ids=False, repeat_until=cirq.KeyCondition(cirq.MeasurementKey(name='a')), )""")
import cirq qr = cirq.LineQubit.range(5) c = cirq.Circuit() c.append(cirq.H(qr[0])) c.append(cirq.H(qr[1])) c.append(cirq.H(qr[2])) c.append(cirq.Z(qr[0])) c.append(cirq.H(qr[2])) c.append(cirq.H(qr[0])) c.append(cirq.CX(qr[1], qr[2])) c.append(cirq.measure(qr[0], key='x0')) c.append(cirq.H(qr[1])) c.append(cirq.H(qr[2])) c.append(cirq.measure(qr[1], key='x1')) c.append(cirq.H(qr[2])) c.append(cirq.measure(qr[2], key='x2')) result = cirq.Simulator().run(c, repetitions=1000) print(c) cirq.plot_state_histogram(result)
def map_func(op: cirq.Operation, _: int) -> cirq.OP_TREE: if op.gate == cirq.CX: yield cirq.Z.on_each(*op.qubits) yield cirq.CX(*op.qubits) yield cirq.Z.on_each(*op.qubits) return op
def test_repeat(add_measurements, use_default_ids_for_initial_rep): a, b = cirq.LineQubit.range(2) circuit = cirq.Circuit(cirq.H(a), cirq.CX(a, b)) if add_measurements: circuit.append([cirq.measure(b, key='mb'), cirq.measure(a, key='ma')]) op_base = cirq.CircuitOperation(circuit.freeze()) assert op_base.repeat(1) is op_base assert op_base.repeat(1, ['0']) != op_base assert op_base.repeat(1, ['0']) == op_base.repeat(repetition_ids=['0']) assert op_base.repeat(1, ['0']) == op_base.with_repetition_ids(['0']) initial_repetitions = -3 if add_measurements: with pytest.raises(ValueError, match='circuit is not invertible'): _ = op_base.repeat(initial_repetitions) initial_repetitions = abs(initial_repetitions) op_with_reps: Optional[cirq.CircuitOperation] = None rep_ids = [] if use_default_ids_for_initial_rep: op_with_reps = op_base.repeat(initial_repetitions) rep_ids = ['0', '1', '2'] assert op_base**initial_repetitions == op_with_reps else: rep_ids = ['a', 'b', 'c'] op_with_reps = op_base.repeat(initial_repetitions, rep_ids) assert op_base**initial_repetitions != op_with_reps assert (op_base**initial_repetitions).replace( repetition_ids=rep_ids) == op_with_reps assert op_with_reps.repetitions == initial_repetitions assert op_with_reps.repetition_ids == rep_ids assert op_with_reps.repeat(1) is op_with_reps final_repetitions = 2 * initial_repetitions op_with_consecutive_reps = op_with_reps.repeat(2) assert op_with_consecutive_reps.repetitions == final_repetitions assert op_with_consecutive_reps.repetition_ids == _full_join_string_lists( ['0', '1'], rep_ids) assert op_base**final_repetitions != op_with_consecutive_reps op_with_consecutive_reps = op_with_reps.repeat(2, ['a', 'b']) assert op_with_reps.repeat( repetition_ids=['a', 'b']) == op_with_consecutive_reps assert op_with_consecutive_reps.repetitions == final_repetitions assert op_with_consecutive_reps.repetition_ids == _full_join_string_lists( ['a', 'b'], rep_ids) with pytest.raises(ValueError, match='length to be 2'): _ = op_with_reps.repeat(2, ['a', 'b', 'c']) with pytest.raises( ValueError, match='At least one of repetitions and repetition_ids must be set' ): _ = op_base.repeat() with pytest.raises(TypeError, match='Only integer or sympy repetitions are allowed'): _ = op_base.repeat(1.3) assert op_base.repeat(3.00000000001).repetitions == 3 assert op_base.repeat(2.99999999999).repetitions == 3
def test_circuit_0(): qusetta_circuit = [ "H(0)", "H(1)", "CX(0, 1)", "CX(1, 0)", "CZ(2, 0)", "I(1)", "SWAP(0, 3)", "RY(PI)(1)", "X(2)", "S(0)", "Z(2)", "Y(3)", "RX(0.4*PI)(0)", "T(2)", "RZ(-0.3*PI)(2)", "CCX(0, 1, 2)" ] cirq_circuit = cirq.Circuit() q = [cirq.LineQubit(i) for i in range(4)] cirq_circuit.append(cirq.H(q[0])) cirq_circuit.append(cirq.H(q[1])) cirq_circuit.append(cirq.CX(q[0], q[1])) cirq_circuit.append(cirq.CX(q[1], q[0])) cirq_circuit.append(cirq.CZ(q[2], q[0])) cirq_circuit.append(cirq.I(q[1])) cirq_circuit.append(cirq.SWAP(q[0], q[3])) cirq_circuit.append(cirq.ry(pi)(q[1])) cirq_circuit.append(cirq.X(q[2])) cirq_circuit.append(cirq.S(q[0])) cirq_circuit.append(cirq.Z(q[2])) cirq_circuit.append(cirq.Y(q[3])) cirq_circuit.append(cirq.rx(.4 * pi)(q[0])) cirq_circuit.append(cirq.T(q[2])) cirq_circuit.append(cirq.rz(-.3 * pi)(q[2])) cirq_circuit.append(cirq.CCX(q[0], q[1], q[2])) # ibm is weird so we flip all of the qubits here qiskit_circuit = qiskit.QuantumCircuit(4) qiskit_circuit.h(3 - 0) qiskit_circuit.h(3 - 1) qiskit_circuit.cx(3 - 0, 3 - 1) qiskit_circuit.cx(3 - 1, 3 - 0) qiskit_circuit.cz(3 - 2, 3 - 0) qiskit_circuit.i(3 - 1) qiskit_circuit.swap(3 - 0, 3 - 3) qiskit_circuit.ry(pi, 3 - 1) qiskit_circuit.x(3 - 2) qiskit_circuit.s(3 - 0) qiskit_circuit.z(3 - 2) qiskit_circuit.y(3 - 3) qiskit_circuit.rx(.4 * pi, 3 - 0) qiskit_circuit.t(3 - 2) qiskit_circuit.rz(-.3 * pi, 3 - 2) qiskit_circuit.ccx(3 - 0, 3 - 1, 3 - 2) quasar_circuit = quasar.Circuit() quasar_circuit.H(0) quasar_circuit.H(1) quasar_circuit.CX(0, 1) quasar_circuit.CX(1, 0) quasar_circuit.CZ(2, 0) quasar_circuit.I(1) quasar_circuit.SWAP(0, 3) quasar_circuit.Ry(1, pi) quasar_circuit.X(2) quasar_circuit.S(0) quasar_circuit.Z(2) quasar_circuit.Y(3) quasar_circuit.Rx(0, .2 * pi) quasar_circuit.T(2) quasar_circuit.Rz(2, -.15 * pi) quasar_circuit.CCX(0, 1, 2) # tests all_tests(qusetta_circuit, cirq_circuit, qiskit_circuit, quasar_circuit)
import cirq import matplotlib.pyplot as plt import numpy as np qubits = cirq.LineQubit.range(10) c = cirq.Circuit() q_qft = [qubits[0], qubits[1], qubits[2], qubits[3], qubits[4]] c.append(cirq.H(qubits[0])) c.append(cirq.H(qubits[1])) c.append(cirq.H(qubits[2])) c.append(cirq.H(qubits[3])) c.append(cirq.H(qubits[4])) c.append(cirq.X(qubits[5])) c.append(cirq.CX(qubits[0], qubits[7])) c.append(cirq.CCX(qubits[1], qubits[8], qubits[9])) c.append(cirq.CCX(qubits[8], qubits[1], qubits[6])) c.append(cirq.CSWAP(qubits[1], qubits[6], qubits[8])) c.append(cirq.CSWAP(qubits[1], qubits[7], qubits[9])) c.append(cirq.CSWAP(qubits[1], qubits[5], qubits[7])) c.append(cirq.CSWAP(qubits[2], qubits[5], qubits[7])) c.append(cirq.CSWAP(qubits[2], qubits[7], qubits[9])) c.append(cirq.CSWAP(qubits[2], qubits[6], qubits[8])) c.append(cirq.CCX(qubits[2], qubits[6], qubits[8])) c.append(cirq.CCX(qubits[2], qubits[8], qubits[9])) c.append(cirq.CCX(qubits[3], qubits[8], qubits[9])) c.append(cirq.CCX(qubits[6], qubits[3], qubits[8]))
def balanced_mod2(qubits: List[cirq.Qid]) -> cirq.OP_TREE: return cirq.CX(qubits[0], qubits[len(qubits) - 1])
def balanced_parity(qubits: List[cirq.Qid]) -> cirq.OP_TREE: n = len(qubits) - 1 return [cirq.CX(qubits[i], qubits[n]) for i in range(n)]
def oracle_op(qubits: List[cirq.Qid]) -> cirq.OP_TREE: if len(qubits) != len(s) + 1: raise ValueError(f'{len(qubits)} qubits passed to oracle expecting {len(s) + 1}') n = len(qubits) - 1 return [cirq.CX(qubits[i], qubits[n]) for i in range(n) if s[i]]