def test_teleportation_diagram(): ali = cirq.NamedQubit('alice') car = cirq.NamedQubit('carrier') bob = cirq.NamedQubit('bob') circuit = cirq.Circuit.from_ops( cirq.H(car), cirq.CNOT(car, bob), cirq.X(ali)**0.5, cirq.CNOT(ali, car), cirq.H(ali), [cirq.measure(ali), cirq.measure(car)], cirq.CNOT(car, bob), cirq.CZ(ali, bob)) diagram = circuit_to_latex_using_qcircuit( circuit, qubit_order=cirq.QubitOrder.explicit([ali, car, bob])) assert diagram.strip() == """ \\Qcircuit @R=1em @C=0.75em { \\\\ \\lstick{\\text{alice}}& \\qw &\\qw & \\gate{\\text{X}^{0.5}} \\qw & \\control \\qw & \\gate{\\text{H}} \\qw & \\meter \\qw &\\qw & \\control \\qw &\\qw\\\\ \\lstick{\\text{carrier}}& \\qw & \\gate{\\text{H}} \\qw & \\control \\qw & \\targ \\qw \\qwx &\\qw & \\meter \\qw & \\control \\qw &\\qw \\qwx &\\qw\\\\ \\lstick{\\text{bob}}& \\qw &\\qw & \\targ \\qw \\qwx &\\qw &\\qw &\\qw & \\targ \\qw \\qwx & \\control \\qw \\qwx &\\qw \\\\ \\\\ } """.strip()
def test_simulator_implied_measurement_key(): q = cirq.GridQubit(0, 0) circuit = cirq.Circuit.from_ops( cirq.X(q), cirq.measure(q), cirq.measure(q, key='other'), ) result = cirq.google.XmonSimulator().run(circuit, repetitions=5) assert str(result) == "(0, 0)=11111\nother=11111"
def test_simulator_trial_repeated_result(): a = cirq.GridQubit(0, 0) b = cirq.GridQubit(0, 1) c = cirq.GridQubit(0, 2) circuit = cirq.Circuit.from_ops( cirq.X(b), cirq.measure(a, b, key='ab'), cirq.measure(c, key='c') ) result = cirq.google.XmonSimulator().run(circuit, repetitions=5) assert str(result) == 'ab=00000, 11111\nc=00000'
def test_simulator_trial_result(): a = cirq.GridQubit(0, 0) b = cirq.GridQubit(0, 1) c = cirq.GridQubit(0, 2) circuit = cirq.Circuit.from_ops( cirq.X(a), cirq.CNOT(a, b), cirq.measure(a, key='a'), cirq.measure(b, key='b'), cirq.measure(c, key='c') ) result = cirq.google.XmonSimulator().run(circuit) assert str(result) == 'a=1\nb=1\nc=0'
def test_random_same_matrix(circuit): a, b = cirq.LineQubit.range(2) same = cirq.Circuit.from_ops( cirq.TwoQubitMatrixGate(circuit.to_unitary_matrix( qubits_that_should_be_present=[a, b])).on(a, b)) cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent( circuit, same, atol=1e-8) circuit.append(cirq.measure(a)) same.append(cirq.measure(a)) cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent( circuit, same, atol=1e-8)
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_init(): d = square_device(2, 2, holes=[cirq.GridQubit(1, 1)]) ns = cirq.Duration(nanos=1) q00 = cirq.GridQubit(0, 0) q01 = cirq.GridQubit(0, 1) q10 = cirq.GridQubit(1, 0) assert d.qubits == {q00, q01, q10} assert d.duration_of(cg.ExpZGate().on(q00)) == 0 * ns assert d.duration_of(cirq.measure(q00)) == ns assert d.duration_of(cirq.measure(q00, q01)) == ns assert d.duration_of(cg.ExpWGate().on(q00)) == 2 * ns assert d.duration_of(cg.Exp11Gate().on(q00, q01)) == 3 * ns with pytest.raises(ValueError): _ = d.duration_of(cirq.Gate().on(q00))
def make_grover_circuit(input_qubits, output_qubit, oracle): """Find the value recognized by the oracle in sqrt(N) attempts.""" # For 2 input qubits, that means using Grover operator only once. c = cirq.Circuit() # Initialize qubits. c.append([ cirq.X(output_qubit), cirq.H(output_qubit), cirq.H.on_each(input_qubits), ]) # Query oracle. c.append(oracle) # Construct Grover operator. c.append(cirq.H.on_each(input_qubits)) c.append(cirq.X.on_each(input_qubits)) c.append(cirq.H.on(input_qubits[1])) c.append(cirq.CNOT(input_qubits[0], input_qubits[1])) c.append(cirq.H.on(input_qubits[1])) c.append(cirq.X.on_each(input_qubits)) c.append(cirq.H.on_each(input_qubits)) # Measure the result. c.append(cirq.measure(*input_qubits, key='result')) return c
def test_inverse(): with pytest.raises(TypeError): _ = cirq.inverse( cirq.measure(cirq.NamedQubit('q'))) def rev_freeze(root): return cirq.freeze_op_tree(cirq.inverse(root)) operations = [ cirq.GateOperation(_FlipGate(i), [cirq.NamedQubit(str(i))]) for i in range(10) ] expected = [ cirq.GateOperation(_FlipGate(~i), [cirq.NamedQubit(str(i))]) for i in range(10) ] # Just an item. assert rev_freeze(operations[0]) == expected[0] # Flat list. assert rev_freeze(operations) == tuple(expected[::-1]) # Tree. assert ( rev_freeze((operations[1:5], operations[0], operations[5:])) == (tuple(expected[5:][::-1]), expected[0], tuple(expected[1:5][::-1]))) # Flattening after reversing is equivalent to reversing then flattening. t = (operations[1:5], operations[0], operations[5:]) assert ( tuple(cirq.flatten_op_tree(rev_freeze(t))) == tuple(rev_freeze(cirq.flatten_op_tree(t))))
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)]) ]), atol=1e-8) 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))]) ]), atol=1e-8) 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)]) ]), atol=1e-8)
def test_various_known_gate_types(): a = cirq.NamedQubit('a') b = cirq.NamedQubit('b') circuit = cirq.Circuit.from_ops( cirq.google.ExpWGate(axis_half_turns=0).on(a), cirq.google.ExpWGate(axis_half_turns=0.5).on(a), cirq.X(a), cirq.X(a)**0.25, cirq.X(a)**-0.5, cirq.Z(a), cirq.Z(a)**0.5, cirq.Y(a), cirq.Y(a)**-0.25, cirq.RotYGate(half_turns=cirq.Symbol('t')).on(a), cirq.H(a), cirq.measure(a), cirq.measure(a, b, key='not-relevant'), cirq.SWAP(a, b), cirq.CNOT(a, b), cirq.CNOT(b, a), cirq.CZ(a, b), ) assert circuit_to_quirk_url(circuit, escape_url=False) == """ http://algassert.com/quirk#circuit={"cols":[ ["X"], ["Y"], ["X"], ["X^¼"], ["X^-½"], ["Z"], ["Z^½"], ["Y"], ["Y^-¼"], ["Y^t"], ["H"], ["Measure"], ["Measure","Measure"], ["Swap","Swap"], ["•","X"], ["X","•"], ["•","Z"]]} """.replace('\n', '').replace(' ', '')
def test_sensitive_to_measurement_but_not_measured_phase(): q = cirq.NamedQubit('q') with pytest.raises(AssertionError): cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent( cirq.Circuit([ cirq.Moment([cirq.measure(q)]) ]), cirq.Circuit(), atol=1e-8) cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent( cirq.Circuit([ cirq.Moment([cirq.measure(q)]) ]), cirq.Circuit([ cirq.Moment([cirq.Z(q)]), cirq.Moment([cirq.measure(q)]), ]), atol=1e-8)
def test_sensitive_to_measurement_toggle(): q = cirq.NamedQubit('q') with pytest.raises(AssertionError): cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent( cirq.Circuit([ cirq.Moment([cirq.measure(q)]) ]), cirq.Circuit([ cirq.Moment([cirq.X(q)]), cirq.Moment([cirq.measure(q)]), ]), atol=1e-8) with pytest.raises(AssertionError): cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent( cirq.Circuit([ cirq.Moment([cirq.measure(q)]) ]), cirq.Circuit([ cirq.Moment([cirq.measure(q, invert_mask=(True,))]), ]), atol=1e-8) cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent( cirq.Circuit([ cirq.Moment([cirq.measure(q)]) ]), cirq.Circuit([ cirq.Moment([cirq.X(q)]), cirq.Moment([cirq.measure(q, invert_mask=(True,))]), ]), atol=1e-8)
def test_swap_field(n: int, d: int): before = cirq.Circuit.from_ops( cirq.ISWAP(cirq.LineQubit(j), cirq.LineQubit(j + 1)) for i in range(d) for j in range(i % 2, n - 1, 2) ) before.append(cirq.measure(*before.all_qubits())) after = cg.optimized_for_xmon(before) assert len(after) == d*4 + 2 if n <= 5: assert_circuits_with_terminal_measurements_are_equivalent( before, after, atol=1e-4)
def test_removes_zs(): a = cirq.NamedQubit('a') b = cirq.NamedQubit('b') assert_removes_all_z_gates(cirq.Circuit.from_ops( cirq.Z(a), cirq.measure(a))) assert_removes_all_z_gates(cirq.Circuit.from_ops( cirq.Z(a), cirq.measure(a, b))) assert_removes_all_z_gates(cirq.Circuit.from_ops( cirq.Z(a), cirq.Z(a), cirq.measure(a))) assert_removes_all_z_gates(cirq.Circuit.from_ops( cirq.Z(a), cirq.google.XmonMeasurementGate('k').on(a))) assert_removes_all_z_gates(cirq.Circuit.from_ops( cirq.google.ExpZGate().on(a), cirq.measure(a))) assert_removes_all_z_gates(cirq.Circuit.from_ops( cirq.Z(a), cirq.google.ExpZGate().on(a), cirq.measure(a))) assert_removes_all_z_gates(cirq.Circuit.from_ops( cirq.Z(a), cirq.google.ExpWGate().on(a), cirq.measure(a))) assert_removes_all_z_gates(cirq.Circuit.from_ops( cirq.Z(a), cirq.google.ExpWGate().on(a), cirq.google.ExpWGate().on(a), cirq.measure(a))) assert_removes_all_z_gates(cirq.Circuit.from_ops( cirq.Z(a), cirq.Z(b), cirq.CZ(a, b), cirq.google.Exp11Gate().on(a, b), cirq.measure(a, b)))
def make_bell_test_circuit(): alice = cirq.GridQubit(0, 0) bob = cirq.GridQubit(1, 0) alice_referee = cirq.GridQubit(0, 1) bob_referee = cirq.GridQubit(1, 1) circuit = cirq.Circuit() # Prepare shared entangled state. circuit.append([ cirq.H(alice), cirq.CNOT(alice, bob), cirq.X(alice)**-0.25, ]) # Referees flip coins. circuit.append([ cirq.H(alice_referee), cirq.H(bob_referee), ]) # Players do a sqrt(X) based on their referee's coin. circuit.append([ cirq.CNOT(alice_referee, alice)**0.5, cirq.CNOT(bob_referee, bob)**0.5, ]) # Then results are recorded. circuit.append([ cirq.measure(alice, key='a'), cirq.measure(bob, key='b'), cirq.measure(alice_referee, key='x'), cirq.measure(bob_referee, key='y'), ]) return circuit
def main(): # Pick a qubit. qubit = cirq.GridQubit(0, 0) # Create a circuit circuit = cirq.Circuit.from_ops( cirq.X(qubit)**0.5, # Square root of NOT. cirq.measure(qubit, key='m') # Measurement. ) print("Circuit:") print(circuit) # Simulate the circuit several times. simulator = cirq.google.XmonSimulator() result = simulator.run(circuit, repetitions=20) print("Results:") print(result)
def test_known_matrix(): a = cirq.NamedQubit('a') b = cirq.NamedQubit('b') # If the gate has no matrix, you get a type error. op0 = cirq.measure(a) assert not cirq.can_cast(cirq.KnownMatrix, op0) with pytest.raises(TypeError): _ = op0.matrix() op1 = cirq.X(a) assert cirq.can_cast(cirq.KnownMatrix, op1) np.testing.assert_allclose(op1.matrix(), np.array([[0, 1], [1, 0]]), atol=1e-8) op2 = cirq.CNOT(a, b) op3 = cirq.CNOT(a, b) np.testing.assert_allclose(op2.matrix(), cirq.CNOT.matrix(), atol=1e-8) np.testing.assert_allclose(op3.matrix(), cirq.CNOT.matrix(), atol=1e-8)
def test_toggles_measurements(): a = cirq.NamedQubit('a') b = cirq.NamedQubit('b') # Single. assert_optimizes( before=quick_circuit( [cg.ExpWGate(axis_half_turns=0.25).on(a)], [cirq.measure(a, b)], ), expected=quick_circuit( [], [cirq.measure(a, b, invert_mask=(True,))], )) assert_optimizes( before=quick_circuit( [cg.ExpWGate(axis_half_turns=0.25).on(b)], [cirq.measure(a, b)], ), expected=quick_circuit( [], [cirq.measure(a, b, invert_mask=(False, True))], )) # Multiple. assert_optimizes( before=quick_circuit( [cg.ExpWGate(axis_half_turns=0.25).on(a)], [cg.ExpWGate(axis_half_turns=0.25).on(b)], [cirq.measure(a, b)], ), expected=quick_circuit( [], [], [cirq.measure(a, b, invert_mask=(True, True))], )) # Xmon. assert_optimizes( before=quick_circuit( [cg.ExpWGate(axis_half_turns=0.25).on(a)], [cg.XmonMeasurementGate(key='t').on(a, b)], ), expected=quick_circuit( [], [cg.XmonMeasurementGate(key='t', invert_mask=(True,)).on(a, b)], ))
def make_bernstein_vazirani_circuit(input_qubits, output_qubit, oracle): """Solves for factors in f(a) = a·factors + bias (mod 2) with one query.""" c = cirq.Circuit() # Initialize qubits. c.append([ cirq.X(output_qubit), cirq.H(output_qubit), cirq.H.on_each(input_qubits), ]) # Query oracle. c.append(oracle) # Measure in X basis. c.append([ cirq.H.on_each(input_qubits), cirq.measure(*input_qubits, key='result') ]) return c
def main(): print("Length 10 line on Bristlecone:") line = cirq.line_on_device(cirq.google.Bristlecone, length=10) print(line) print("Initial circuit:") n = 10 depth = 2 circuit = cirq.Circuit.from_ops( cirq.SWAP(cirq.LineQubit(j), cirq.LineQubit(j + 1)) for i in range(depth) for j in range(i % 2, n - 1, 2) ) circuit.append(cirq.measure(*cirq.LineQubit.range(n), key='all')) print(circuit) print() print("Xmon circuit:") translated = cirq.google.optimized_for_xmon( circuit=circuit, new_device=cirq.google.Bristlecone, qubit_map=lambda q: line[q.x]) print(translated)
def test_parameterized_repeat_side_effects(): q = cirq.LineQubit(0) op = cirq.CircuitOperation( cirq.FrozenCircuit( cirq.X(q).with_classical_controls('c'), cirq.measure(q, key='m')), repetitions=sympy.Symbol('a'), ) # Control keys can be calculated because they only "lift" if there's a matching # measurement, in which case they're not returned here. assert cirq.control_keys(op) == {cirq.MeasurementKey('c')} # "local" params do not bind to the repetition param. assert cirq.parameter_names(op.with_params({'a': 1})) == {'a'} # Check errors that require unrolling the circuit. with pytest.raises( ValueError, match='Cannot unroll circuit due to nondeterministic repetitions'): cirq.measurement_key_objs(op) with pytest.raises( ValueError, match='Cannot unroll circuit due to nondeterministic repetitions'): cirq.measurement_key_names(op) with pytest.raises( ValueError, match='Cannot unroll circuit due to nondeterministic repetitions'): op.mapped_circuit() with pytest.raises( ValueError, match='Cannot unroll circuit due to nondeterministic repetitions'): cirq.decompose(op) # Not compatible with repetition ids with pytest.raises(ValueError, match='repetition ids with parameterized repetitions'): op.with_repetition_ids(['x', 'y']) with pytest.raises(ValueError, match='repetition ids with parameterized repetitions'): op.repeat(repetition_ids=['x', 'y']) # TODO(daxfohl): This should work, but likely requires a new protocol that returns *just* the # name of the measurement keys. (measurement_key_names returns the full serialized string). with pytest.raises( ValueError, match='Cannot unroll circuit due to nondeterministic repetitions'): cirq.with_measurement_key_mapping(op, {'m': 'm2'}) # Everything should work once resolved op = cirq.resolve_parameters(op, {'a': 2}) assert set(map(str, cirq.measurement_key_objs(op))) == {'0:m', '1:m'} assert op.mapped_circuit() == cirq.Circuit( cirq.X(q).with_classical_controls('c'), cirq.measure(q, key=cirq.MeasurementKey.parse_serialized('0:m')), cirq.X(q).with_classical_controls('c'), cirq.measure(q, key=cirq.MeasurementKey.parse_serialized('1:m')), ) assert cirq.decompose(op) == cirq.decompose( cirq.Circuit( cirq.X(q).with_classical_controls('c'), cirq.measure(q, key=cirq.MeasurementKey.parse_serialized('0:m')), cirq.X(q).with_classical_controls('c'), cirq.measure(q, key=cirq.MeasurementKey.parse_serialized('1:m')), ))
def test_per_qubit_combined_noise_from_data(): # Generate the combined noise model from calibration data. calibration = cirq.google.Calibration(_CALIBRATION_DATA) noise_model = simple_noise_from_calibration_metrics( calibration=calibration, depol_noise=True, readout_error_noise=True, readout_decay_noise=True, ) # Create the circuit and apply the noise model. qubits = [cirq.GridQubit(0, 0), cirq.GridQubit(0, 1), cirq.GridQubit(1, 0)] program = cirq.Circuit( cirq.Moment([cirq.H(qubits[0])]), cirq.Moment([cirq.CNOT(qubits[0], qubits[1])]), cirq.Moment([cirq.CNOT(qubits[0], qubits[2])]), cirq.Moment( [ cirq.measure(qubits[0], key='q0'), cirq.measure(qubits[1], key='q1'), cirq.measure(qubits[2], key='q2'), ] ), ) noisy_circuit = cirq.Circuit(noise_model.noisy_moments(program, qubits)) # Insert channels explicitly to construct expected output. decay_prob = [1 - exp(-1 / 0.007), 1 - exp(-1 / 0.008), 1 - exp(-1 / 0.009)] expected_program = cirq.Circuit( cirq.Moment([cirq.H(qubits[0])]), cirq.Moment([cirq.DepolarizingChannel(DEPOL_001).on(qubits[0])]), cirq.Moment([cirq.CNOT(qubits[0], qubits[1])]), cirq.Moment( [ cirq.DepolarizingChannel(DEPOL_001).on(qubits[0]), cirq.DepolarizingChannel(DEPOL_002).on(qubits[1]), ] ), cirq.Moment([cirq.CNOT(qubits[0], qubits[2])]), cirq.Moment( [ cirq.DepolarizingChannel(DEPOL_001).on(qubits[0]), cirq.DepolarizingChannel(DEPOL_003).on(qubits[2]), ] ), cirq.Moment([cirq.AmplitudeDampingChannel(decay_prob[i]).on(qubits[i]) for i in range(3)]), cirq.Moment( [ cirq.BitFlipChannel(0.004).on(qubits[0]), cirq.BitFlipChannel(0.005).on(qubits[1]), cirq.BitFlipChannel(0.006).on(qubits[2]), ] ), cirq.Moment( [ cirq.measure(qubits[0], key='q0'), cirq.measure(qubits[1], key='q1'), cirq.measure(qubits[2], key='q2'), ] ), ) _assert_equivalent_op_tree(expected_program, noisy_circuit)
def test_random_seed_non_terminal_measurements_deterministic(): a = cirq.NamedQubit('a') circuit = cirq.Circuit( cirq.X(a) ** 0.5, cirq.measure(a, key='a'), cirq.X(a) ** 0.5, cirq.measure(a, key='b') ) sim = cirq.Simulator(seed=1234) result = sim.run(circuit, repetitions=30) assert np.all( result.measurements['a'] == [ [0], [0], [1], [0], [1], [0], [1], [0], [1], [1], [0], [0], [1], [0], [0], [1], [1], [1], [0], [0], [0], [0], [1], [0], [0], [0], [1], [1], [1], [1], ] ) assert np.all( result.measurements['b'] == [ [1], [1], [0], [1], [1], [1], [1], [1], [0], [1], [1], [0], [1], [1], [1], [0], [0], [1], [1], [1], [0], [1], [1], [1], [1], [1], [0], [1], [1], [1], ] )
def test_run_mixture(dtype): q0 = cirq.LineQubit(0) simulator = cirq.Simulator(dtype=dtype) circuit = cirq.Circuit(cirq.bit_flip(0.5)(q0), cirq.measure(q0)) result = simulator.run(circuit, repetitions=100) assert 20 < sum(result.measurements['0'])[0] < 80
def make_circuit(n: int, input_qubit): c = cirq.Circuit() # circuit begin c.append(cirq.H.on(input_qubit[0])) # number=1 c.append(cirq.rx(-0.09738937226128368).on(input_qubit[2])) # number=2 c.append(cirq.H.on(input_qubit[1])) # number=33 c.append(cirq.Y.on(input_qubit[2])) # number=56 c.append(cirq.CZ.on(input_qubit[2],input_qubit[1])) # number=34 c.append(cirq.H.on(input_qubit[1])) # number=35 c.append(cirq.H.on(input_qubit[1])) # number=3 c.append(cirq.H.on(input_qubit[0])) # number=45 c.append(cirq.CNOT.on(input_qubit[2],input_qubit[1])) # number=60 c.append(cirq.CZ.on(input_qubit[1],input_qubit[0])) # number=46 c.append(cirq.H.on(input_qubit[0])) # number=47 c.append(cirq.Y.on(input_qubit[1])) # number=15 c.append(cirq.H.on(input_qubit[0])) # number=66 c.append(cirq.CZ.on(input_qubit[1],input_qubit[0])) # number=67 c.append(cirq.H.on(input_qubit[0])) # number=68 c.append(cirq.H.on(input_qubit[1])) # number=19 c.append(cirq.CZ.on(input_qubit[0],input_qubit[1])) # number=20 c.append(cirq.rx(-0.6000441968356504).on(input_qubit[1])) # number=28 c.append(cirq.H.on(input_qubit[1])) # number=21 c.append(cirq.H.on(input_qubit[1])) # number=30 c.append(cirq.CZ.on(input_qubit[0],input_qubit[1])) # number=31 c.append(cirq.H.on(input_qubit[1])) # number=32 c.append(cirq.H.on(input_qubit[1])) # number=57 c.append(cirq.CZ.on(input_qubit[0],input_qubit[1])) # number=58 c.append(cirq.H.on(input_qubit[1])) # number=59 c.append(cirq.CNOT.on(input_qubit[0],input_qubit[1])) # number=51 c.append(cirq.X.on(input_qubit[1])) # number=52 c.append(cirq.CNOT.on(input_qubit[0],input_qubit[1])) # number=53 c.append(cirq.CNOT.on(input_qubit[0],input_qubit[1])) # number=50 c.append(cirq.H.on(input_qubit[2])) # number=29 c.append(cirq.H.on(input_qubit[1])) # number=36 c.append(cirq.X.on(input_qubit[1])) # number=64 c.append(cirq.CZ.on(input_qubit[0],input_qubit[1])) # number=37 c.append(cirq.Y.on(input_qubit[2])) # number=44 c.append(cirq.H.on(input_qubit[1])) # number=38 c.append(cirq.Z.on(input_qubit[1])) # number=55 c.append(cirq.H.on(input_qubit[1])) # number=61 c.append(cirq.CZ.on(input_qubit[0],input_qubit[1])) # number=62 c.append(cirq.Z.on(input_qubit[2])) # number=65 c.append(cirq.H.on(input_qubit[1])) # number=63 c.append(cirq.Z.on(input_qubit[1])) # number=11 c.append(cirq.rx(-1.1780972450961724).on(input_qubit[2])) # number=54 c.append(cirq.H.on(input_qubit[1])) # number=42 c.append(cirq.H.on(input_qubit[0])) # number=39 c.append(cirq.CZ.on(input_qubit[1],input_qubit[0])) # number=40 c.append(cirq.H.on(input_qubit[0])) # number=41 c.append(cirq.CNOT.on(input_qubit[2],input_qubit[1])) # number=26 c.append(cirq.Y.on(input_qubit[1])) # number=14 c.append(cirq.CNOT.on(input_qubit[1],input_qubit[0])) # number=5 c.append(cirq.X.on(input_qubit[1])) # number=6 c.append(cirq.Z.on(input_qubit[1])) # number=8 c.append(cirq.X.on(input_qubit[1])) # number=7 c.append(cirq.H.on(input_qubit[2])) # number=43 c.append(cirq.rx(-2.42845112122491).on(input_qubit[1])) # number=25 # circuit end c.append(cirq.measure(*input_qubit, key='result')) return c
def read(self, target_mask=~0, key=None): if key is None: key = 'result' target = self.mask_to_list(target_mask) self.circuit.append(cirq.measure(*target, key=key))
(cirq.Z(q0), cirq.SingleQubitCliffordGate.Z(q0)), (cirq.X(q0)**0.5, cirq.SingleQubitCliffordGate.X_sqrt(q0)), (cirq.Y(q0)**0.5, cirq.SingleQubitCliffordGate.Y_sqrt(q0)), (cirq.Z(q0)**0.5, cirq.SingleQubitCliffordGate.Z_sqrt(q0)), (cirq.X(q0)**-0.5, cirq.SingleQubitCliffordGate.X_nsqrt(q0)), (cirq.Y(q0)**-0.5, cirq.SingleQubitCliffordGate.Y_nsqrt(q0)), (cirq.Z(q0)**-0.5, cirq.SingleQubitCliffordGate.Z_nsqrt(q0)), (cirq.X(q0)**0.25, cirq.PauliStringPhasor(cirq.PauliString.from_single(q0, cirq.X))**0.25), (cirq.Y(q0)**0.25, cirq.PauliStringPhasor(cirq.PauliString.from_single(q0, cirq.Y))**0.25), (cirq.Z(q0)**0.25, cirq.PauliStringPhasor(cirq.PauliString.from_single(q0, cirq.Z))**0.25), (cirq.X(q0)**0, ()), (cirq.CZ(q0, q1), cirq.CZ(q0, q1)), (cirq.measure(q0, q1, key='key'), cirq.measure(q0, q1, key='key')), ))(cirq.LineQubit(0), cirq.LineQubit(1))) def test_converts_various_ops(op, expected_ops): before = cirq.Circuit.from_ops(op) expected = cirq.Circuit.from_ops(expected_ops, strategy=cirq.InsertStrategy.EARLIEST) after = converted_gate_set(before) assert after == expected cirq.testing.assert_allclose_up_to_global_phase( before.unitary(), after.unitary(qubits_that_should_be_present=op.qubits), atol=1e-7) cirq.testing.assert_allclose_up_to_global_phase( after.unitary(qubits_that_should_be_present=op.qubits), expected.unitary(qubits_that_should_be_present=op.qubits),
def make_circuit(n: int, input_qubit): c = cirq.Circuit() # circuit begin c.append(cirq.H.on(input_qubit[0])) # number=3 c.append(cirq.rx(-1.3603096190043806).on(input_qubit[2])) # number=28 c.append(cirq.H.on(input_qubit[1])) # number=4 c.append(cirq.H.on(input_qubit[2])) # number=5 c.append(cirq.H.on(input_qubit[3])) # number=6 c.append(cirq.H.on(input_qubit[4])) # number=21 for i in range(2): c.append(cirq.H.on(input_qubit[0])) # number=1 c.append(cirq.H.on(input_qubit[1])) # number=2 c.append(cirq.H.on(input_qubit[2])) # number=7 c.append(cirq.H.on(input_qubit[3])) # number=8 c.append(cirq.H.on(input_qubit[3])) # number=34 c.append(cirq.CZ.on(input_qubit[4], input_qubit[3])) # number=35 c.append(cirq.H.on(input_qubit[3])) # number=36 c.append(cirq.H.on(input_qubit[0])) # number=17 c.append(cirq.H.on(input_qubit[1])) # number=18 c.append(cirq.H.on(input_qubit[2])) # number=53 c.append(cirq.CZ.on(input_qubit[0], input_qubit[2])) # number=54 c.append(cirq.H.on(input_qubit[2])) # number=55 c.append(cirq.X.on(input_qubit[2])) # number=44 c.append(cirq.H.on(input_qubit[2])) # number=47 c.append(cirq.CZ.on(input_qubit[0], input_qubit[2])) # number=48 c.append(cirq.H.on(input_qubit[2])) # number=49 c.append(cirq.rx(-1.9697785938008003).on(input_qubit[1])) # number=37 c.append(cirq.H.on(input_qubit[2])) # number=19 c.append(cirq.H.on(input_qubit[3])) # number=20 c.append(cirq.H.on(input_qubit[0])) # number=38 c.append(cirq.CZ.on(input_qubit[1], input_qubit[0])) # number=39 c.append(cirq.H.on(input_qubit[0])) # number=40 c.append(cirq.X.on(input_qubit[0])) # number=32 c.append(cirq.CNOT.on(input_qubit[1], input_qubit[0])) # number=33 c.append(cirq.CNOT.on(input_qubit[0], input_qubit[1])) # number=24 c.append(cirq.X.on(input_qubit[1])) # number=25 c.append(cirq.CNOT.on(input_qubit[0], input_qubit[1])) # number=56 c.append(cirq.X.on(input_qubit[1])) # number=57 c.append(cirq.CNOT.on(input_qubit[0], input_qubit[1])) # number=58 c.append(cirq.H.on(input_qubit[1])) # number=50 c.append(cirq.CZ.on(input_qubit[0], input_qubit[1])) # number=51 c.append(cirq.H.on(input_qubit[1])) # number=52 c.append(cirq.X.on(input_qubit[2])) # number=11 c.append(cirq.CNOT.on(input_qubit[2], input_qubit[3])) # number=30 c.append(cirq.X.on(input_qubit[3])) # number=12 c.append(cirq.H.on(input_qubit[2])) # number=42 c.append(cirq.X.on(input_qubit[0])) # number=13 c.append(cirq.X.on(input_qubit[1])) # number=14 c.append(cirq.X.on(input_qubit[2])) # number=15 c.append(cirq.X.on(input_qubit[4])) # number=46 c.append(cirq.X.on(input_qubit[3])) # number=16 c.append(cirq.X.on(input_qubit[1])) # number=22 c.append(cirq.X.on(input_qubit[1])) # number=23 # circuit end c.append(cirq.measure(*input_qubit, key='result')) return c
def test_run_no_repetitions(): q0 = cirq.LineQubit(0) simulator = cirq.CliffordSimulator() circuit = cirq.Circuit(cirq.H(q0), cirq.measure(q0)) result = simulator.run(circuit, repetitions=0) assert sum(result.measurements['0']) == 0
def test_measurement_in_single_qubit_circuit_passes(): args = create_container([q0]) assert len(set(args.values())) == 2 args.apply_operation(cirq.measure(q0)) assert len(set(args.values())) == 2 assert args[q0] is not args[None]
def test_get_circuit_v2(get_program): circuit = cirq.Circuit( cirq.X(cirq.GridQubit(5, 2))**0.5, cirq.measure(cirq.GridQubit(5, 2), key='result')) program_proto = Merge( """language { gate_set: "xmon" } circuit { scheduling_strategy: MOMENT_BY_MOMENT moments { operations { gate { id: "xy" } args { key: "axis_half_turns" value { arg_value { float_value: 0.0 } } } args { key: "half_turns" value { arg_value { float_value: 0.5 } } } qubits { id: "5_2" } } } moments { operations { gate { id: "meas" } args { key: "invert_mask" value { arg_value { bool_values { } } } } args { key: "key" value { arg_value { string_value: "result" } } } qubits { id: "5_2" } } } } """, v2.program_pb2.Program()) program = cg.EngineProgram('a', 'b', EngineContext()) get_program.return_value = qtypes.QuantumProgram( code=_to_any(program_proto)) assert program.get_circuit() == circuit get_program.assert_called_once_with('a', 'b', True)
import cirq as c # Create a qubit qubit = c.GridQubit(0, 0) # Create a quantum circuit q_circuit = c.Circuit( c.X(qubit)**0.5, # Square root of the NOT gate. c.measure(qubit, key='m') # Define it as a measurement. ) print("Circuit:") print(q_circuit) # Run a simulation of the circuit n-times n_times = 2000 simulator = c.Simulator() result = simulator.run(q_circuit, repetitions = n_times) print("Results:") print(result)
def make_circuit(n: int, input_qubit): c = cirq.Circuit() # circuit begin c.append(cirq.H.on(input_qubit[0])) # number=3 c.append(cirq.X.on(input_qubit[4])) # number=53 c.append(cirq.H.on(input_qubit[0])) # number=57 c.append(cirq.CZ.on(input_qubit[2],input_qubit[0])) # number=58 c.append(cirq.H.on(input_qubit[0])) # number=59 c.append(cirq.Z.on(input_qubit[2])) # number=46 c.append(cirq.H.on(input_qubit[0])) # number=54 c.append(cirq.CZ.on(input_qubit[2],input_qubit[0])) # number=55 c.append(cirq.H.on(input_qubit[0])) # number=56 c.append(cirq.H.on(input_qubit[1])) # number=4 c.append(cirq.rx(2.664070570244145).on(input_qubit[1])) # number=39 c.append(cirq.H.on(input_qubit[2])) # number=5 c.append(cirq.H.on(input_qubit[3])) # number=6 c.append(cirq.H.on(input_qubit[2])) # number=49 c.append(cirq.CZ.on(input_qubit[3],input_qubit[2])) # number=50 c.append(cirq.H.on(input_qubit[2])) # number=51 c.append(cirq.H.on(input_qubit[4])) # number=21 for i in range(2): c.append(cirq.H.on(input_qubit[0])) # number=1 c.append(cirq.H.on(input_qubit[3])) # number=40 c.append(cirq.Y.on(input_qubit[4])) # number=35 c.append(cirq.H.on(input_qubit[1])) # number=2 c.append(cirq.H.on(input_qubit[2])) # number=7 c.append(cirq.H.on(input_qubit[3])) # number=8 c.append(cirq.H.on(input_qubit[0])) # number=17 c.append(cirq.H.on(input_qubit[1])) # number=18 c.append(cirq.H.on(input_qubit[2])) # number=19 c.append(cirq.H.on(input_qubit[3])) # number=20 c.append(cirq.Z.on(input_qubit[1])) # number=52 c.append(cirq.H.on(input_qubit[0])) # number=25 c.append(cirq.CZ.on(input_qubit[1],input_qubit[0])) # number=26 c.append(cirq.H.on(input_qubit[0])) # number=27 c.append(cirq.H.on(input_qubit[0])) # number=36 c.append(cirq.CZ.on(input_qubit[1],input_qubit[0])) # number=37 c.append(cirq.H.on(input_qubit[0])) # number=38 c.append(cirq.CNOT.on(input_qubit[1],input_qubit[0])) # number=41 c.append(cirq.X.on(input_qubit[0])) # number=42 c.append(cirq.CNOT.on(input_qubit[1],input_qubit[0])) # number=43 c.append(cirq.CNOT.on(input_qubit[1],input_qubit[0])) # number=34 c.append(cirq.CNOT.on(input_qubit[1],input_qubit[0])) # number=24 c.append(cirq.CNOT.on(input_qubit[0],input_qubit[1])) # number=29 c.append(cirq.CNOT.on(input_qubit[2],input_qubit[3])) # number=44 c.append(cirq.X.on(input_qubit[1])) # number=30 c.append(cirq.CNOT.on(input_qubit[0],input_qubit[1])) # number=31 c.append(cirq.X.on(input_qubit[2])) # number=11 c.append(cirq.X.on(input_qubit[3])) # number=12 c.append(cirq.X.on(input_qubit[0])) # number=13 c.append(cirq.X.on(input_qubit[1])) # number=14 c.append(cirq.X.on(input_qubit[2])) # number=15 c.append(cirq.X.on(input_qubit[3])) # number=16 # circuit end c.append(cirq.measure(*input_qubit, key='result')) return c
def test_decompose_nested(): a, b, c, d = cirq.LineQubit.range(4) exp1 = sympy.Symbol('exp1') exp_half = sympy.Symbol('exp_half') exp_one = sympy.Symbol('exp_one') exp_two = sympy.Symbol('exp_two') circuit1 = cirq.FrozenCircuit(cirq.X(a)**exp1, cirq.measure(a, key='m1')) op1 = cirq.CircuitOperation(circuit1) circuit2 = cirq.FrozenCircuit( op1.with_qubits(a).with_measurement_key_mapping({'m1': 'ma'}), op1.with_qubits(b).with_measurement_key_mapping({'m1': 'mb'}), op1.with_qubits(c).with_measurement_key_mapping({'m1': 'mc'}), op1.with_qubits(d).with_measurement_key_mapping({'m1': 'md'}), ) op2 = cirq.CircuitOperation(circuit2) circuit3 = cirq.FrozenCircuit( op2.with_params({exp1: exp_half}), op2.with_params({ exp1: exp_one }).with_measurement_key_mapping({ 'ma': 'ma1' }).with_measurement_key_mapping({ 'mb': 'mb1' }).with_measurement_key_mapping({ 'mc': 'mc1' }).with_measurement_key_mapping({'md': 'md1'}), op2.with_params({ exp1: exp_two }).with_measurement_key_mapping({ 'ma': 'ma2' }).with_measurement_key_mapping({ 'mb': 'mb2' }).with_measurement_key_mapping({ 'mc': 'mc2' }).with_measurement_key_mapping({'md': 'md2'}), ) op3 = cirq.CircuitOperation(circuit3) final_op = op3.with_params({exp_half: 0.5, exp_one: 1.0, exp_two: 2.0}) expected_circuit1 = cirq.Circuit( op2.with_params({ exp1: 0.5, exp_half: 0.5, exp_one: 1.0, exp_two: 2.0 }), op2.with_params({ exp1: 1.0, exp_half: 0.5, exp_one: 1.0, exp_two: 2.0 }).with_measurement_key_mapping({ 'ma': 'ma1' }).with_measurement_key_mapping({ 'mb': 'mb1' }).with_measurement_key_mapping({ 'mc': 'mc1' }).with_measurement_key_mapping({'md': 'md1'}), op2.with_params({ exp1: 2.0, exp_half: 0.5, exp_one: 1.0, exp_two: 2.0 }).with_measurement_key_mapping({ 'ma': 'ma2' }).with_measurement_key_mapping({ 'mb': 'mb2' }).with_measurement_key_mapping({ 'mc': 'mc2' }).with_measurement_key_mapping({'md': 'md2'}), ) result_ops1 = cirq.decompose_once(final_op) assert cirq.Circuit(result_ops1) == expected_circuit1 expected_circuit = cirq.Circuit( cirq.X(a)**0.5, cirq.measure(a, key='ma'), cirq.X(b)**0.5, cirq.measure(b, key='mb'), cirq.X(c)**0.5, cirq.measure(c, key='mc'), cirq.X(d)**0.5, cirq.measure(d, key='md'), cirq.X(a)**1.0, cirq.measure(a, key='ma1'), cirq.X(b)**1.0, cirq.measure(b, key='mb1'), cirq.X(c)**1.0, cirq.measure(c, key='mc1'), cirq.X(d)**1.0, cirq.measure(d, key='md1'), cirq.X(a)**2.0, cirq.measure(a, key='ma2'), cirq.X(b)**2.0, cirq.measure(b, key='mb2'), cirq.X(c)**2.0, cirq.measure(c, key='mc2'), cirq.X(d)**2.0, cirq.measure(d, key='md2'), ) assert cirq.Circuit(cirq.decompose(final_op)) == expected_circuit # Verify that mapped_circuit gives the same operations. assert final_op.mapped_circuit(deep=True) == expected_circuit
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={{1: 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={{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) == """\ 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')), )""")
def make_circuit(n: int, input_qubit): c = cirq.Circuit() # circuit begin c.append(cirq.H.on(input_qubit[0])) # number=3 c.append(cirq.H.on(input_qubit[1])) # number=4 c.append(cirq.H.on(input_qubit[2])) # number=5 c.append(cirq.H.on(input_qubit[3])) # number=6 c.append(cirq.H.on(input_qubit[4])) # number=21 c.append(cirq.H.on(input_qubit[0])) # number=43 c.append(cirq.CZ.on(input_qubit[4], input_qubit[0])) # number=44 c.append(cirq.H.on(input_qubit[0])) # number=45 c.append(cirq.CNOT.on(input_qubit[4], input_qubit[0])) # number=46 c.append(cirq.CNOT.on(input_qubit[4], input_qubit[0])) # number=56 c.append(cirq.Z.on(input_qubit[4])) # number=57 c.append(cirq.CNOT.on(input_qubit[4], input_qubit[0])) # number=58 c.append(cirq.CNOT.on(input_qubit[4], input_qubit[0])) # number=48 c.append(cirq.H.on(input_qubit[0])) # number=37 c.append(cirq.CZ.on(input_qubit[4], input_qubit[0])) # number=38 c.append(cirq.H.on(input_qubit[0])) # number=39 for i in range(2): c.append(cirq.H.on(input_qubit[0])) # number=1 c.append(cirq.rx(-1.0430087609918113).on(input_qubit[4])) # number=36 c.append(cirq.H.on(input_qubit[1])) # number=2 c.append(cirq.H.on(input_qubit[2])) # number=7 c.append(cirq.H.on(input_qubit[3])) # number=8 c.append(cirq.H.on(input_qubit[0])) # number=17 c.append(cirq.rx(2.4912829742967055).on(input_qubit[2])) # number=26 c.append(cirq.H.on(input_qubit[1])) # number=18 c.append(cirq.H.on(input_qubit[2])) # number=19 c.append(cirq.H.on(input_qubit[2])) # number=55 c.append(cirq.H.on(input_qubit[2])) # number=25 c.append(cirq.H.on(input_qubit[3])) # number=20 c.append(cirq.CNOT.on(input_qubit[1], input_qubit[0])) # number=40 c.append(cirq.CNOT.on(input_qubit[1], input_qubit[0])) # number=52 c.append(cirq.X.on(input_qubit[0])) # number=53 c.append(cirq.CNOT.on(input_qubit[1], input_qubit[0])) # number=54 c.append(cirq.H.on(input_qubit[0])) # number=49 c.append(cirq.CZ.on(input_qubit[1], input_qubit[0])) # number=50 c.append(cirq.H.on(input_qubit[0])) # number=51 c.append(cirq.X.on(input_qubit[1])) # number=10 c.append(cirq.rx(-0.06597344572538572).on(input_qubit[3])) # number=27 c.append(cirq.CNOT.on(input_qubit[0], input_qubit[2])) # number=22 c.append(cirq.X.on(input_qubit[2])) # number=23 c.append(cirq.H.on(input_qubit[2])) # number=28 c.append(cirq.CZ.on(input_qubit[0], input_qubit[2])) # number=29 c.append(cirq.H.on(input_qubit[2])) # number=30 c.append(cirq.X.on(input_qubit[3])) # number=12 c.append(cirq.X.on(input_qubit[0])) # number=13 c.append(cirq.X.on(input_qubit[1])) # number=14 c.append(cirq.X.on(input_qubit[2])) # number=15 c.append(cirq.X.on(input_qubit[3])) # number=16 c.append(cirq.H.on(input_qubit[4])) # number=35 # circuit end c.append(cirq.measure(*input_qubit, key='result')) return c
import cirq qbits = [cirq.GridQubit(0, i) for i in range(4)] print (qbits) circuit = cirq.Circuit() circuit.append(cirq.X(qbits[0])) # Set initial value of a circuit.append(cirq.X(qbits[1])) # Set initial value of b circuit.append(cirq.CCX.on(qbits[0], qbits[1], qbits[3])) circuit.append(cirq.CNOT.on(qbits[0], qbits[1])) circuit.append(cirq.CCX.on(qbits[1], qbits[2], qbits[3])) circuit.append(cirq.CNOT.on(qbits[1], qbits[2])) circuit.append(cirq.CNOT.on(qbits[0], qbits[1])) print(circuit) simulator = cirq.google.XmonSimulator() circuit.append(cirq.measure(qbits[2], key='s')) circuit.append(cirq.measure(qbits[3], key='c')) print(circuit) results = simulator.run(circuit, repetitions=100, qubit_order=qbits) print (results.histogram(key='s')) print (results.histogram(key='c'))
def test_classical_control(): q0, q1 = cirq.LineQubit.range(2) circuit = cirq.Circuit(cirq.H(q0), cirq.measure(q0, key='m'), cirq.X(q1).with_classical_controls('m')) cirq.testing.assert_same_circuits(cirq.align_left(circuit), circuit) cirq.testing.assert_same_circuits(cirq.align_right(circuit), circuit)
def test_measure_at_end_invert_mask_partial(): simulator = cirq.Simulator() a, _, c = cirq.LineQubit.range(3) circuit = cirq.Circuit(cirq.measure(a, c, key='ac', invert_mask=(True,))) result = simulator.run(circuit, repetitions=4) np.testing.assert_equal(result.measurements['ac'], np.array([[1, 0]] * 4))
def make_circuit(n: int, input_qubit): c = cirq.Circuit() # circuit begin c.append(cirq.H.on(input_qubit[0])) # number=1 c.append(cirq.H.on(input_qubit[2])) # number=38 c.append(cirq.CZ.on(input_qubit[0],input_qubit[2])) # number=39 c.append(cirq.H.on(input_qubit[2])) # number=40 c.append(cirq.H.on(input_qubit[2])) # number=59 c.append(cirq.CZ.on(input_qubit[0],input_qubit[2])) # number=60 c.append(cirq.H.on(input_qubit[2])) # number=61 c.append(cirq.H.on(input_qubit[2])) # number=42 c.append(cirq.CZ.on(input_qubit[0],input_qubit[2])) # number=43 c.append(cirq.H.on(input_qubit[2])) # number=44 c.append(cirq.H.on(input_qubit[2])) # number=48 c.append(cirq.CZ.on(input_qubit[0],input_qubit[2])) # number=49 c.append(cirq.H.on(input_qubit[2])) # number=50 c.append(cirq.CNOT.on(input_qubit[0],input_qubit[2])) # number=54 c.append(cirq.X.on(input_qubit[2])) # number=55 c.append(cirq.H.on(input_qubit[2])) # number=67 c.append(cirq.CZ.on(input_qubit[0],input_qubit[2])) # number=68 c.append(cirq.H.on(input_qubit[2])) # number=69 c.append(cirq.H.on(input_qubit[2])) # number=64 c.append(cirq.CZ.on(input_qubit[0],input_qubit[2])) # number=65 c.append(cirq.H.on(input_qubit[2])) # number=66 c.append(cirq.H.on(input_qubit[2])) # number=71 c.append(cirq.CZ.on(input_qubit[0],input_qubit[2])) # number=72 c.append(cirq.H.on(input_qubit[2])) # number=73 c.append(cirq.H.on(input_qubit[2])) # number=51 c.append(cirq.CZ.on(input_qubit[0],input_qubit[2])) # number=52 c.append(cirq.H.on(input_qubit[2])) # number=53 c.append(cirq.H.on(input_qubit[2])) # number=25 c.append(cirq.CZ.on(input_qubit[0],input_qubit[2])) # number=26 c.append(cirq.H.on(input_qubit[2])) # number=27 c.append(cirq.H.on(input_qubit[1])) # number=7 c.append(cirq.CZ.on(input_qubit[2],input_qubit[1])) # number=8 c.append(cirq.rx(0.17592918860102857).on(input_qubit[2])) # number=34 c.append(cirq.rx(-0.3989822670059037).on(input_qubit[1])) # number=30 c.append(cirq.H.on(input_qubit[1])) # number=9 c.append(cirq.H.on(input_qubit[1])) # number=18 c.append(cirq.rx(2.3310617489636263).on(input_qubit[2])) # number=58 c.append(cirq.CZ.on(input_qubit[2],input_qubit[1])) # number=19 c.append(cirq.H.on(input_qubit[1])) # number=20 c.append(cirq.X.on(input_qubit[1])) # number=62 c.append(cirq.Y.on(input_qubit[1])) # number=14 c.append(cirq.H.on(input_qubit[1])) # number=22 c.append(cirq.CZ.on(input_qubit[2],input_qubit[1])) # number=23 c.append(cirq.rx(-0.9173450548482197).on(input_qubit[1])) # number=57 c.append(cirq.CNOT.on(input_qubit[2],input_qubit[1])) # number=63 c.append(cirq.H.on(input_qubit[1])) # number=24 c.append(cirq.Z.on(input_qubit[2])) # number=3 c.append(cirq.CNOT.on(input_qubit[2],input_qubit[1])) # number=70 c.append(cirq.Z.on(input_qubit[1])) # number=41 c.append(cirq.X.on(input_qubit[1])) # number=17 c.append(cirq.Y.on(input_qubit[2])) # number=5 c.append(cirq.X.on(input_qubit[2])) # number=21 c.append(cirq.CNOT.on(input_qubit[1],input_qubit[0])) # number=15 c.append(cirq.CNOT.on(input_qubit[1],input_qubit[0])) # number=16 c.append(cirq.X.on(input_qubit[2])) # number=28 c.append(cirq.X.on(input_qubit[2])) # number=29 # circuit end c.append(cirq.measure(*input_qubit, key='result')) return c
import cirq # Pick a qubit. qubit = cirq.GridQubit(0, 0) # Create a circuit circuit = cirq.Circuit.from_ops( cirq.X(qubit)**0.5, # Square root of NOT. cirq.measure(qubit, key='m') # Measurement. ) print("Circuit:") print(circuit) # Simulate the circuit several times. simulator = cirq.google.XmonSimulator() result = simulator.run(circuit, repetitions=20) print("Results:") print(result)
def make_circuit(n: int, input_qubit): c = cirq.Circuit() # circuit begin c.append(cirq.H.on(input_qubit[0])) # number=3 c.append(cirq.H.on(input_qubit[1])) # number=4 c.append(cirq.H.on(input_qubit[0])) # number=57 c.append(cirq.CZ.on(input_qubit[4], input_qubit[0])) # number=58 c.append(cirq.H.on(input_qubit[0])) # number=59 c.append(cirq.Z.on(input_qubit[4])) # number=55 c.append(cirq.CNOT.on(input_qubit[4], input_qubit[0])) # number=56 c.append(cirq.H.on(input_qubit[2])) # number=50 c.append(cirq.CZ.on(input_qubit[4], input_qubit[2])) # number=51 c.append(cirq.H.on(input_qubit[2])) # number=52 c.append(cirq.H.on(input_qubit[2])) # number=5 c.append(cirq.H.on(input_qubit[3])) # number=6 c.append(cirq.H.on(input_qubit[4])) # number=21 for i in range(2): c.append(cirq.H.on(input_qubit[0])) # number=1 c.append(cirq.H.on(input_qubit[1])) # number=2 c.append(cirq.H.on(input_qubit[2])) # number=7 c.append(cirq.H.on(input_qubit[3])) # number=8 c.append(cirq.H.on(input_qubit[0])) # number=17 c.append(cirq.H.on(input_qubit[1])) # number=18 c.append(cirq.H.on(input_qubit[2])) # number=19 c.append(cirq.H.on(input_qubit[3])) # number=20 c.append(cirq.H.on(input_qubit[0])) # number=28 c.append(cirq.Z.on(input_qubit[3])) # number=42 c.append(cirq.CZ.on(input_qubit[1], input_qubit[0])) # number=29 c.append(cirq.H.on(input_qubit[0])) # number=30 c.append(cirq.H.on(input_qubit[0])) # number=43 c.append(cirq.CZ.on(input_qubit[1], input_qubit[0])) # number=44 c.append(cirq.H.on(input_qubit[0])) # number=45 c.append(cirq.CNOT.on(input_qubit[1], input_qubit[0])) # number=35 c.append(cirq.CNOT.on(input_qubit[1], input_qubit[0])) # number=38 c.append(cirq.X.on(input_qubit[0])) # number=39 c.append(cirq.CNOT.on(input_qubit[1], input_qubit[0])) # number=40 c.append(cirq.CNOT.on(input_qubit[1], input_qubit[0])) # number=37 c.append(cirq.H.on(input_qubit[0])) # number=46 c.append(cirq.CZ.on(input_qubit[1], input_qubit[0])) # number=47 c.append(cirq.H.on(input_qubit[0])) # number=48 c.append(cirq.CNOT.on(input_qubit[1], input_qubit[0])) # number=27 c.append(cirq.X.on(input_qubit[1])) # number=10 c.append(cirq.X.on(input_qubit[2])) # number=11 c.append(cirq.X.on(input_qubit[3])) # number=12 c.append(cirq.X.on(input_qubit[0])) # number=13 c.append(cirq.CNOT.on(input_qubit[0], input_qubit[1])) # number=22 c.append(cirq.Y.on(input_qubit[2])) # number=41 c.append(cirq.X.on(input_qubit[1])) # number=23 c.append(cirq.CNOT.on(input_qubit[0], input_qubit[1])) # number=24 c.append(cirq.rx(1.0398671683382215).on(input_qubit[2])) # number=31 c.append(cirq.X.on(input_qubit[2])) # number=15 c.append(cirq.X.on(input_qubit[3])) # number=16 # circuit end c.append(cirq.measure(*input_qubit, key='result')) return c
def make_circuit(n: int, input_qubit): c = cirq.Circuit() # circuit begin c.append(cirq.H.on(input_qubit[0])) # number=3 c.append(cirq.H.on(input_qubit[1])) # number=4 c.append(cirq.H.on(input_qubit[2])) # number=5 c.append(cirq.H.on(input_qubit[1])) # number=29 c.append(cirq.CZ.on(input_qubit[3], input_qubit[1])) # number=30 c.append(cirq.H.on(input_qubit[1])) # number=31 c.append(cirq.H.on(input_qubit[3])) # number=6 c.append(cirq.H.on(input_qubit[4])) # number=21 for i in range(2): c.append(cirq.H.on(input_qubit[0])) # number=1 c.append(cirq.H.on(input_qubit[1])) # number=2 c.append(cirq.H.on(input_qubit[2])) # number=7 c.append(cirq.H.on(input_qubit[3])) # number=8 c.append(cirq.H.on(input_qubit[0])) # number=17 c.append(cirq.H.on(input_qubit[1])) # number=18 c.append(cirq.H.on(input_qubit[2])) # number=19 c.append(cirq.H.on(input_qubit[3])) # number=20 c.append(cirq.H.on(input_qubit[0])) # number=38 c.append(cirq.CZ.on(input_qubit[1], input_qubit[0])) # number=39 c.append(cirq.H.on(input_qubit[0])) # number=40 c.append(cirq.H.on(input_qubit[0])) # number=51 c.append(cirq.CZ.on(input_qubit[1], input_qubit[0])) # number=52 c.append(cirq.H.on(input_qubit[0])) # number=53 c.append(cirq.H.on(input_qubit[0])) # number=64 c.append(cirq.CZ.on(input_qubit[1], input_qubit[0])) # number=65 c.append(cirq.H.on(input_qubit[0])) # number=66 c.append(cirq.X.on(input_qubit[0])) # number=49 c.append(cirq.H.on(input_qubit[0])) # number=57 c.append(cirq.CZ.on(input_qubit[1], input_qubit[0])) # number=58 c.append(cirq.H.on(input_qubit[0])) # number=59 c.append(cirq.H.on(input_qubit[0])) # number=54 c.append(cirq.CZ.on(input_qubit[1], input_qubit[0])) # number=55 c.append(cirq.H.on(input_qubit[0])) # number=56 c.append(cirq.H.on(input_qubit[4])) # number=41 c.append(cirq.H.on(input_qubit[0])) # number=61 c.append(cirq.CZ.on(input_qubit[1], input_qubit[0])) # number=62 c.append(cirq.H.on(input_qubit[0])) # number=63 c.append(cirq.X.on(input_qubit[1])) # number=10 c.append(cirq.H.on(input_qubit[2])) # number=25 c.append(cirq.CZ.on(input_qubit[0], input_qubit[2])) # number=26 c.append(cirq.H.on(input_qubit[2])) # number=27 c.append(cirq.X.on(input_qubit[2])) # number=23 c.append(cirq.H.on(input_qubit[2])) # number=67 c.append(cirq.CZ.on(input_qubit[0], input_qubit[2])) # number=68 c.append(cirq.H.on(input_qubit[2])) # number=69 c.append(cirq.CNOT.on(input_qubit[0], input_qubit[3])) # number=32 c.append(cirq.X.on(input_qubit[3])) # number=33 c.append(cirq.H.on(input_qubit[3])) # number=42 c.append(cirq.CZ.on(input_qubit[0], input_qubit[3])) # number=43 c.append(cirq.H.on(input_qubit[3])) # number=44 c.append(cirq.X.on(input_qubit[0])) # number=13 c.append(cirq.rx(0.6157521601035993).on(input_qubit[1])) # number=60 c.append(cirq.X.on(input_qubit[1])) # number=14 c.append(cirq.X.on(input_qubit[2])) # number=15 c.append(cirq.X.on(input_qubit[3])) # number=16 # circuit end c.append(cirq.measure(*input_qubit, key='result')) return c
def test_stabilizer_supports_probability(): q = cirq.LineQubit(0) c = cirq.Circuit(cirq.X(q).with_probability(0.5), cirq.measure(q, key='m')) m = np.sum(cirq.StabilizerSampler().sample(c, repetitions=100)['m']) assert 5 < m < 95
import cirq import numpy as np from functools import reduce q = [cirq.NamedQubit('q' + str(i)) for i in range(11)] circuit = cirq.Circuit(cirq.Z(q[0]), cirq.H(q[9]), cirq.H(q[0]), cirq.CNOT(q[9], q[10]), cirq.CNOT(q[0], q[3]), cirq.CNOT(q[0], q[6]), cirq.CZ(q[0], q[3]), cirq.CZ(q[0], q[6]), cirq.H(q[0]), cirq.H(q[3]), cirq.H(q[6]), cirq.Z(q[0]), cirq.Z(q[3]), cirq.Z(q[6]), cirq.CNOT(q[0], q[1]), cirq.CNOT(q[3], q[4]), cirq.CNOT(q[6], q[7]), cirq.CNOT(q[0], q[2]), cirq.CNOT(q[3], q[5]), cirq.CNOT(q[6], q[8]), cirq.CZ(q[0], q[1]), cirq.CZ(q[3], q[4]), cirq.CZ(q[6], q[7]), cirq.CZ(q[0], q[2]), cirq.CZ(q[3], q[5]), cirq.CZ(q[6], q[8]), cirq.CNOT(q[0], q[9]), cirq.measure(q[9], key='c9'), cirq.H(q[0]), cirq.CNOT(q[9], q[10]), cirq.measure(q[0], key='c0'), cirq.CZ(q[0], q[10]), cirq.CNOT(q[10], q[1]), cirq.CNOT(q[10], q[2]), cirq.CNOT(q[3], q[4]), cirq.CNOT(q[6], q[7]), cirq.CNOT(q[3], q[5]), cirq.CNOT(q[6], q[8]), cirq.CZ(q[10], q[1]), cirq.CZ(q[10], q[2]), cirq.CZ(q[3], q[4]), cirq.CZ(q[6], q[7]), cirq.CZ(q[3], q[5]), cirq.CZ(q[6], q[8]), cirq.CCX(q[1], q[2], q[10]), cirq.CCX(q[5], q[4], q[3]), cirq.CCX(q[8], q[7], q[6]), cirq.H(q[10]), cirq.CCX(q[1], q[2], q[10]), cirq.H(q[3]), cirq.H(q[6]), cirq.H(q[10]), cirq.CCX(q[5], q[4], q[3]), cirq.CCX(q[8], q[7], q[6]), cirq.H(q[10]), cirq.H(q[3]), cirq.H(q[6]), cirq.Z(q[10]), cirq.H(q[3]), cirq.H(q[6]), cirq.Z(q[3]), cirq.Z(q[6]), cirq.CNOT(q[10], q[3]),
def test_run_repetitions_terminal_measurement_stochastic(): q = cirq.LineQubit(0) c = cirq.Circuit(cirq.H(q), cirq.measure(q, key='q')) results = cirq.Simulator().run(c, repetitions=10000) assert 1000 <= sum(v[0] for v in results.measurements['q']) < 9000
def test_moment_is_measurements(): q = cirq.LineQubit.range(2) circ = cirq.Circuit([cirq.X(q[0]), cirq.X(q[1]), cirq.measure(*q, key='z')]) assert not _homogeneous_moment_is_measurements(circ[0]) assert _homogeneous_moment_is_measurements(circ[1])
def test_measure_at_end_invert_mask(): simulator = cirq.Simulator() a = cirq.NamedQubit('a') circuit = cirq.Circuit(cirq.measure(a, key='a', invert_mask=(True,))) result = simulator.run(circuit, repetitions=4) np.testing.assert_equal(result.measurements['a'], np.array([[1]] * 4))
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_simulate_sweep_parameters_not_resolved(): a = cirq.LineQubit(0) simulator = cirq.Simulator() circuit = cirq.Circuit(cirq.XPowGate(exponent=sympy.Symbol('a'))(a), cirq.measure(a)) with pytest.raises(ValueError, match='symbols were not specified'): _ = simulator.simulate_sweep(circuit, cirq.ParamResolver({}))
def test_measurement_key(): a = cirq.NamedQubit('a') assert cirq.measurement_key(cirq.measure(a, key='lock')) == 'lock'
def test_clifford_step_result_str(): q0 = cirq.LineQubit(0) result = next(cirq.CliffordSimulator().simulate_moment_steps( cirq.Circuit(cirq.measure(q0, key='m')))) assert str(result) == "m=0\n" "|0⟩"
def FullAdder(a_qbit, b_qbit, c0_qbit, c1_qbit): circuit.append(cirq.CCX.on(a_qbit, b_qbit, c1_qbit)) circuit.append(cirq.CNOT.on(a_qbit, b_qbit)) circuit.append(cirq.CCX.on(b_qbit, c0_qbit, c1_qbit)) circuit.append(cirq.CNOT.on(b_qbit, c0_qbit)) circuit.append(cirq.CNOT.on(a_qbit, b_qbit)) qbits = [cirq.GridQubit(j, i) for j in range(3) for i in range(3)] qbits.append(cirq.GridQubit(2, 3)) print (qbits) circuit = cirq.Circuit() FullAdder(qbits[0], qbits[3], qbits[6], qbits[7]) FullAdder(qbits[1], qbits[4], qbits[7], qbits[8]) FullAdder(qbits[2], qbits[5], qbits[8], qbits[9]) print(circuit) simulator = cirq.google.XmonSimulator() circuit.append(cirq.measure(qbits[6], key='s0'), strategy = cirq.InsertStrategy.EARLIEST) circuit.append(cirq.measure(qbits[7], key='s1'), strategy = cirq.InsertStrategy.EARLIEST) circuit.append(cirq.measure(qbits[8], key='s2'), strategy = cirq.InsertStrategy.EARLIEST) circuit.append(cirq.measure(qbits[9], key='s3'), strategy = cirq.InsertStrategy.EARLIEST) print(circuit) results = simulator.run(circuit, repetitions=100, qubit_order=qbits) print (results.histogram(key='s0')) print (results.histogram(key='s1')) print (results.histogram(key='s2')) print (results.histogram(key='s3'))