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