def test_copy(): a = cirq.QubitId() b = cirq.QubitId() original = Moment([cirq.CZ(a, b)]) copy = original.__copy__() assert original == copy assert id(original) != id(copy)
def test_depolarizer_different_gate(): q1 = cirq.QubitId() q2 = cirq.QubitId() cnot = Job(cirq.Circuit([ cirq.Moment([cirq.CNOT(q1, q2)]), ])) allerrors = DepolarizerChannel(probability=1.0, depolarizing_gates= [xmon_gates.ExpZGate(), xmon_gates.ExpWGate()]) p0 = cirq.Symbol(DepolarizerChannel._parameter_name + '0') p1 = cirq.Symbol(DepolarizerChannel._parameter_name + '1') p2 = cirq.Symbol(DepolarizerChannel._parameter_name + '2') p3 = cirq.Symbol(DepolarizerChannel._parameter_name + '3') error_sweep = (cirq.Points(p0.name, [1.0]) + cirq.Points(p1.name, [1.0]) + cirq.Points(p2.name, [1.0]) + cirq.Points(p3.name, [1.0])) cnot_then_z = Job( cirq.Circuit([ cirq.Moment([cirq.CNOT(q1, q2)]), cirq.Moment([xmon_gates.ExpZGate(half_turns=p0).on(q1), xmon_gates.ExpZGate(half_turns=p1).on(q2)]), cirq.Moment([xmon_gates.ExpWGate(half_turns=p2).on(q1), xmon_gates.ExpWGate(half_turns=p3).on(q2)]) ]), cnot.sweep * error_sweep) assert allerrors.transform_job(cnot) == cnot_then_z
def test_equality(): a = cirq.QubitId() b = cirq.QubitId() eq = cirq.testing.EqualsTester() # Default is empty. Iterables get listed. eq.add_equality_group(Circuit(), Circuit([]), Circuit(())) eq.add_equality_group(Circuit([Moment()]), Circuit((Moment(), ))) # Equality depends on structure and contents. eq.add_equality_group(Circuit([Moment([cirq.X(a)])])) eq.add_equality_group(Circuit([Moment([cirq.X(b)])])) eq.add_equality_group(Circuit([Moment([cirq.X(a)]), Moment([cirq.X(b)])])) eq.add_equality_group(Circuit([Moment([cirq.X(a), cirq.X(b)])])) # Big case. eq.add_equality_group( Circuit([ Moment([cirq.H(a), cirq.H(b)]), Moment([cirq.CZ(a, b)]), Moment([cirq.H(b)]), ])) eq.add_equality_group( Circuit([ Moment([cirq.H(a)]), Moment([cirq.CNOT(a, b)]), ]))
def test_insert_inline_near_start(): a = cirq.QubitId() b = cirq.QubitId() c = Circuit([ Moment(), Moment(), ]) c.insert(1, cirq.X(a), strategy=InsertStrategy.INLINE) assert c == Circuit([ Moment([cirq.X(a)]), Moment(), ]) c.insert(1, cirq.Y(a), strategy=InsertStrategy.INLINE) assert c == Circuit([ Moment([cirq.X(a)]), Moment([cirq.Y(a)]), Moment(), ]) c.insert(0, cirq.Z(b), strategy=InsertStrategy.INLINE) assert c == Circuit([ Moment([cirq.Z(b)]), Moment([cirq.X(a)]), Moment([cirq.Y(a)]), Moment(), ])
def test_operation_eq(): g1 = cirq.Gate() g2 = cirq.Gate() r1 = [cirq.QubitId()] r2 = [cirq.QubitId()] r12 = r1 + r2 r21 = r2 + r1 eq = cirq.testing.EqualsTester() eq.make_equality_pair(lambda: cirq.Operation(g1, r1)) eq.make_equality_pair(lambda: cirq.Operation(g2, r1)) eq.make_equality_pair(lambda: cirq.Operation(g1, r2)) eq.make_equality_pair(lambda: cirq.Operation(g1, r12)) eq.make_equality_pair(lambda: cirq.Operation(g1, r21)) eq.add_equality_group(cirq.Operation(cirq.CZ, r21), cirq.Operation(cirq.CZ, r12)) # Interchangeable subsets. class PairGate(cirq.Gate, cirq.InterchangeableQubitsGate): def qubit_index_to_equivalence_group_key(self, index: int): return index // 2 p = PairGate() a0, a1, b0, b1, c0 = cirq.LineQubit.range(5) eq.add_equality_group(p(a0, a1, b0, b1), p(a1, a0, b1, b0)) eq.add_equality_group(p(b0, b1, a0, a1)) eq.add_equality_group(p(a0, a1, b0, b1, c0), p(a1, a0, b1, b0, c0)) eq.add_equality_group(p(a0, b0, a1, b1, c0)) eq.add_equality_group(p(a0, c0, b0, b1, a1)) eq.add_equality_group(p(b0, a1, a0, b1, c0))
def test_append_strategies(): a = cirq.QubitId() b = cirq.QubitId() stream = [cirq.X(a), cirq.CZ(a, b), cirq.X(b), cirq.X(b), cirq.X(a)] c = Circuit() c.append(stream, InsertStrategy.NEW) assert c == Circuit([ Moment([cirq.X(a)]), Moment([cirq.CZ(a, b)]), Moment([cirq.X(b)]), Moment([cirq.X(b)]), Moment([cirq.X(a)]), ]) c = Circuit() c.append(stream, InsertStrategy.INLINE) assert c == Circuit([ Moment([cirq.X(a)]), Moment([cirq.CZ(a, b)]), Moment([cirq.X(b)]), Moment([cirq.X(b), cirq.X(a)]), ]) c = Circuit() c.append(stream, InsertStrategy.EARLIEST) assert c == Circuit([ Moment([cirq.X(a)]), Moment([cirq.CZ(a, b)]), Moment([cirq.X(b), cirq.X(a)]), Moment([cirq.X(b)]), ])
def test_concatenate(): a = cirq.QubitId() b = cirq.QubitId() c = Circuit() d = Circuit([Moment([cirq.X(b)])]) e = Circuit([Moment([cirq.X(a), cirq.X(b)])]) assert c + d == Circuit([Moment([cirq.X(b)])]) assert d + c == Circuit([Moment([cirq.X(b)])]) assert e + d == Circuit( [Moment([cirq.X(a), cirq.X(b)]), Moment([cirq.X(b)])]) d += c assert d == Circuit([Moment([cirq.X(b)])]) c += d assert c == Circuit([Moment([cirq.X(b)])]) f = e + d f += e assert f == Circuit([ Moment([cirq.X(a), cirq.X(b)]), Moment([cirq.X(b)]), Moment([cirq.X(a), cirq.X(b)]) ]) with pytest.raises(TypeError): _ = c + 'a' with pytest.raises(TypeError): c += 'a'
def test_controlled_op_to_gates_omits_negligible_global_phase(): qc = cirq.QubitId() qt = cirq.QubitId() operations = decompositions.controlled_op_to_native_gates( control=qc, target=qt, operation=cirq.H.matrix(), tolerance=0.0001) assert operations == [cirq.Y(qt)**-0.25, cirq.CZ(qc, qt), cirq.Y(qt)**0.25]
def test_operates_on(): a = cirq.QubitId() b = cirq.QubitId() c = cirq.QubitId() # Empty case. assert not Moment().operates_on([]) assert not Moment().operates_on([a]) assert not Moment().operates_on([b]) assert not Moment().operates_on([a, b]) # One-qubit operation case. assert not Moment([cirq.X(a)]).operates_on([]) assert Moment([cirq.X(a)]).operates_on([a]) assert not Moment([cirq.X(a)]).operates_on([b]) assert Moment([cirq.X(a)]).operates_on([a, b]) # Two-qubit operation case. assert not Moment([cirq.CZ(a, b)]).operates_on([]) assert Moment([cirq.CZ(a, b)]).operates_on([a]) assert Moment([cirq.CZ(a, b)]).operates_on([b]) assert Moment([cirq.CZ(a, b)]).operates_on([a, b]) assert not Moment([cirq.CZ(a, b)]).operates_on([c]) assert Moment([cirq.CZ(a, b)]).operates_on([a, c]) assert Moment([cirq.CZ(a, b)]).operates_on([a, b, c]) # Multiple operations case. assert not Moment([cirq.X(a), cirq.X(b)]).operates_on([]) assert Moment([cirq.X(a), cirq.X(b)]).operates_on([a]) assert Moment([cirq.X(a), cirq.X(b)]).operates_on([b]) assert Moment([cirq.X(a), cirq.X(b)]).operates_on([a, b]) assert not Moment([cirq.X(a), cirq.X(b)]).operates_on([c]) assert Moment([cirq.X(a), cirq.X(b)]).operates_on([a, c]) assert Moment([cirq.X(a), cirq.X(b)]).operates_on([a, b, c])
def test_equality(): a = cirq.QubitId() b = cirq.QubitId() c = cirq.QubitId() d = cirq.QubitId() eq = cirq.testing.EqualsTester() # Default is empty. Iterables get frozen into tuples. eq.add_equality_group(Moment(), Moment([]), Moment(())) eq.add_equality_group(Moment([cirq.X(d)]), Moment((cirq.X(d), ))) # Equality depends on gate and qubits. eq.add_equality_group(Moment([cirq.X(a)])) eq.add_equality_group(Moment([cirq.X(b)])) eq.add_equality_group(Moment([cirq.Y(a)])) # Equality depends on order. eq.add_equality_group(Moment([cirq.X(a), cirq.X(b)])) eq.add_equality_group(Moment([cirq.X(b), cirq.X(a)])) # Two qubit gates. eq.make_equality_group(lambda: Moment([cirq.CZ(c, d)])) eq.make_equality_group(lambda: Moment([cirq.CZ(a, c)])) eq.make_equality_group(lambda: Moment([cirq.CZ(a, b), cirq.CZ(c, d)])) eq.make_equality_group(lambda: Moment([cirq.CZ(a, c), cirq.CZ(b, d)]))
def test_qubits(): a = cirq.QubitId() b = cirq.QubitId() assert Moment([cirq.X(a), cirq.X(b)]).qubits == {a, b} assert Moment([cirq.X(a)]).qubits == {a} assert Moment([cirq.CZ(a, b)]).qubits == {a, b}
def test_trivial_parity_interaction_corner_case(): q0 = cirq.QubitId() q1 = cirq.QubitId() nearPi4 = np.pi / 4 * 0.99 tolerance = 1e-2 circuit = cirq.Circuit.from_ops( decompositions._parity_interaction(q0, q1, -nearPi4, tolerance)) assert len(circuit) == 2
def test_controlled_op_to_gates_equivalent_on_known_and_random(mat): qc = cirq.QubitId() qt = cirq.QubitId() operations = decompositions.controlled_op_to_native_gates( control=qc, target=qt, operation=mat) actual_effect = _operations_to_matrix(operations, (qc, qt)) intended_effect = linalg.kron_with_controls(linalg.CONTROL_TAG, mat) assert linalg.allclose_up_to_global_phase(actual_effect, intended_effect)
def test_depolarizer_no_errors(): q1 = cirq.QubitId() q2 = cirq.QubitId() cnot = Job(cirq.Circuit([ cirq.Moment([cirq.CNOT(q1, q2)]), ])) no_errors = DepolarizerChannel(probability=0.0) assert no_errors.transform_job(cnot) == cnot
def test_controlled_op_to_operations_omits_negligible_global_phase(): qc = cirq.QubitId() qt = cirq.QubitId() operations = cirq.controlled_op_to_operations(control=qc, target=qt, operation=cirq.unitary( cirq.H), tolerance=0.0001) assert operations == [cirq.Y(qt)**-0.25, cirq.CZ(qc, qt), cirq.Y(qt)**0.25]
def test_ignores_2qubit_target(): m = cirq.google.MergeRotations(0.000001) q = cirq.QubitId() q2 = cirq.QubitId() c = cirq.Circuit([ cirq.Moment([cirq.CZ(q, q2)]), ]) m.optimization_at(c, 0, c.operation_at(q, 0)) assert c == cirq.Circuit([cirq.Moment([cirq.CZ(q, q2)])])
def test_with_operation(): a = cirq.QubitId() b = cirq.QubitId() assert Moment().with_operation(cirq.X(a)) == Moment([cirq.X(a)]) assert (Moment([cirq.X(a)]).with_operation(cirq.X(b)) == Moment( [cirq.X(a), cirq.X(b)])) with pytest.raises(ValueError): _ = Moment([cirq.X(a)]).with_operation(cirq.X(a))
def test_ignores_2qubit_target(): m = cirq.MergeSingleQubitGates() q = cirq.QubitId() q2 = cirq.QubitId() c = cirq.Circuit([ cirq.Moment([cirq.CZ(q, q2)]), ]) m.optimization_at(c, 0, c.operation_at(q, 0)) assert c == cirq.Circuit([cirq.Moment([cirq.CZ(q, q2)])])
def test_drop(): q1 = cirq.QubitId() q2 = cirq.QubitId() assert_optimizes(before=cirq.Circuit([ cirq.Moment(), cirq.Moment(), cirq.Moment([cirq.CNOT(q1, q2)]), cirq.Moment(), ]), after=cirq.Circuit([ cirq.Moment([cirq.CNOT(q1, q2)]), ]))
def test_clear_operations_touching(): a = cirq.QubitId() b = cirq.QubitId() c = Circuit() c.clear_operations_touching([a, b], range(10)) assert c == Circuit() c = Circuit([ Moment(), Moment([cirq.X(a), cirq.X(b)]), Moment([cirq.X(a)]), Moment([cirq.X(a)]), Moment([cirq.CZ(a, b)]), Moment(), Moment([cirq.X(b)]), Moment(), ]) c.clear_operations_touching([a], [1, 3, 4, 6, 7]) assert c == Circuit([ Moment(), Moment([cirq.X(b)]), Moment([cirq.X(a)]), Moment(), Moment(), Moment(), Moment([cirq.X(b)]), Moment(), ]) c = Circuit([ Moment(), Moment([cirq.X(a), cirq.X(b)]), Moment([cirq.X(a)]), Moment([cirq.X(a)]), Moment([cirq.CZ(a, b)]), Moment(), Moment([cirq.X(b)]), Moment(), ]) c.clear_operations_touching([a, b], [1, 3, 4, 6, 7]) assert c == Circuit([ Moment(), Moment(), Moment([cirq.X(a)]), Moment(), Moment(), Moment(), Moment(), Moment(), ])
def test_two_to_native_equivalent_and_bounded_for_known_and_random( max_partial_cz_depth, max_full_cz_depth, effect): q0 = cirq.QubitId() q1 = cirq.QubitId() operations_with_partial = decompositions.two_qubit_matrix_to_native_gates( q0, q1, effect, True) operations_with_full = decompositions.two_qubit_matrix_to_native_gates( q0, q1, effect, False) assert_ops_implement_unitary(q0, q1, operations_with_partial, effect) assert_ops_implement_unitary(q0, q1, operations_with_full, effect) assert_cz_depth_below(operations_with_partial, max_partial_cz_depth, False) assert_cz_depth_below(operations_with_full, max_full_cz_depth, True)
def test_query_point_operation_inclusive(): q = cirq.QubitId() zero = cirq.Timestamp(picos=0) ps = cirq.Duration(picos=1) op = cirq.ScheduledOperation(zero, cirq.Duration(), cirq.H(q)) schedule = cirq.Schedule(device=UnconstrainedDevice, scheduled_operations=[op]) def query(t, d=cirq.Duration(), qubits=None): return schedule.query(time=t, duration=d, qubits=qubits, include_query_end_time=True, include_op_end_times=True) assert query(zero) == [op] assert query(zero + ps) == [] assert query(zero - ps) == [] assert query(zero, qubits=[]) == [] assert query(zero, qubits=[q]) == [op] assert query(zero, ps) == [op] assert query(zero - 0.5 * ps, ps) == [op] assert query(zero - ps, ps) == [op] assert query(zero - 2 * ps, ps) == [] assert query(zero - ps, 3 * ps) == [op] assert query(zero + ps, ps) == []
def test_multiply(): a = cirq.QubitId() c = Circuit() d = Circuit([Moment([cirq.X(a)])]) assert c * 0 == Circuit() assert d * 0 == Circuit() assert d * 2 == Circuit([Moment([cirq.X(a)]), Moment([cirq.X(a)])]) assert 1 * c == Circuit() assert -1 * d == Circuit() assert 1 * d == Circuit([Moment([cirq.X(a)])]) d *= 3 assert d == Circuit( [Moment([cirq.X(a)]), Moment([cirq.X(a)]), Moment([cirq.X(a)])]) with pytest.raises(TypeError): _ = c * 'a' with pytest.raises(TypeError): _ = 'a' * c with pytest.raises(TypeError): c *= 'a'
def test_prev_moment_operating_on_distance(): a = cirq.QubitId() c = Circuit([ Moment(), Moment([cirq.X(a)]), Moment(), Moment(), Moment(), Moment(), ]) assert c.prev_moment_operating_on([a], max_distance=4) is None assert c.prev_moment_operating_on([a], 6, max_distance=4) is None assert c.prev_moment_operating_on([a], 5, max_distance=3) is None assert c.prev_moment_operating_on([a], 4, max_distance=2) is None assert c.prev_moment_operating_on([a], 3, max_distance=1) is None assert c.prev_moment_operating_on([a], 2, max_distance=0) is None assert c.prev_moment_operating_on([a], 1, max_distance=0) is None assert c.prev_moment_operating_on([a], 0, max_distance=0) is None assert c.prev_moment_operating_on([a], 6, max_distance=5) == 1 assert c.prev_moment_operating_on([a], 5, max_distance=4) == 1 assert c.prev_moment_operating_on([a], 4, max_distance=3) == 1 assert c.prev_moment_operating_on([a], 3, max_distance=2) == 1 assert c.prev_moment_operating_on([a], 2, max_distance=1) == 1 assert c.prev_moment_operating_on([a], 6, max_distance=10) == 1 assert c.prev_moment_operating_on([a], 6, max_distance=100) == 1 assert c.prev_moment_operating_on([a], 13, max_distance=500) == 1 # Huge max distances should be handled quickly due to capping. assert c.prev_moment_operating_on([a], 1, max_distance=10**100) is None
def test_query_overlapping_operations_inclusive(): q = cirq.QubitId() zero = cirq.Timestamp(picos=0) ps = cirq.Duration(picos=1) op1 = cirq.ScheduledOperation(zero, 2 * ps, cirq.H(q)) op2 = cirq.ScheduledOperation(zero + ps, 2 * ps, cirq.H(q)) schedule = cirq.Schedule(device=UnconstrainedDevice, scheduled_operations=[op2, op1]) def query(t, d=cirq.Duration(), qubits=None): return schedule.query(time=t, duration=d, qubits=qubits, include_query_end_time=True, include_op_end_times=True) assert query(zero - 0.5 * ps, ps) == [op1] assert query(zero - 0.5 * ps, 2 * ps) == [op1, op2] assert query(zero, ps) == [op1, op2] assert query(zero + 0.5 * ps, ps) == [op1, op2] assert query(zero + ps, ps) == [op1, op2] assert query(zero + 1.5 * ps, ps) == [op1, op2] assert query(zero + 2.0 * ps, ps) == [op1, op2] assert query(zero + 2.5 * ps, ps) == [op2] assert query(zero + 3.0 * ps, ps) == [op2] assert query(zero + 3.5 * ps, ps) == []
def test_query_point_operation_exclusive(): q = cirq.QubitId() zero = cirq.Timestamp(picos=0) ps = cirq.Duration(picos=1) op = cirq.ScheduledOperation(zero, cirq.Duration(), cirq.H(q)) schedule = cirq.Schedule(device=UnconstrainedDevice, scheduled_operations=[op]) assert schedule.query(time=zero, include_query_end_time=False, include_op_end_times=False) == [] assert schedule.query(time=zero + ps, include_query_end_time=False, include_op_end_times=False) == [] assert schedule.query(time=zero - ps, include_query_end_time=False, include_op_end_times=False) == [] assert schedule.query(time=zero) == [] assert schedule.query(time=zero + ps) == [] assert schedule.query(time=zero - ps) == [] assert schedule.query(time=zero, qubits=[]) == [] assert schedule.query(time=zero, qubits=[q]) == [] assert schedule.query(time=zero, duration=ps) == [] assert schedule.query(time=zero - 0.5 * ps, duration=ps) == [op] assert schedule.query(time=zero - ps, duration=ps) == [] assert schedule.query(time=zero - 2 * ps, duration=ps) == [] assert schedule.query(time=zero - ps, duration=3 * ps) == [op] assert schedule.query(time=zero + ps, duration=ps) == []
def test_stopped_at_2qubit(): m = cirq.google.MergeRotations(0.000001) q = cirq.QubitId() q2 = cirq.QubitId() c = cirq.Circuit([ cirq.Moment([cirq.Z(q)]), cirq.Moment([cirq.H(q)]), cirq.Moment([cirq.X(q)]), cirq.Moment([cirq.H(q)]), cirq.Moment([cirq.CZ(q, q2)]), cirq.Moment([cirq.H(q)]), ]) assert (m.optimization_at(c, 0, c.operation_at( q, 0)) == cirq.PointOptimizationSummary(clear_span=4, clear_qubits=[q], new_operations=[]))
def test_leaves_singleton(): m = cirq.google.MergeRotations(0.000001) q = cirq.QubitId() c = cirq.Circuit([cirq.Moment([cirq.X(q)])]) m.optimization_at(c, 0, c.operation_at(q, 0)) assert c == cirq.Circuit([cirq.Moment([cirq.X(q)])])
def test_container_methods(): a = cirq.QubitId() b = cirq.QubitId() c = Circuit([ Moment([cirq.H(a), cirq.H(b)]), Moment([cirq.CZ(a, b)]), Moment([cirq.H(b)]), ]) assert list(c) == list(c.moments) # __iter__ assert list(iter(c)) == list(c.moments) # __reversed__ for free. assert list(reversed(c)) == list(reversed(c.moments)) # __contains__ for free. assert Moment([cirq.H(b)]) in c assert len(c) == 3
def test_leaves_singleton(): m = cirq.MergeSingleQubitGates() q = cirq.QubitId() c = cirq.Circuit([cirq.Moment([cirq.X(q)])]) m.optimization_at(c, 0, c.operation_at(q, 0)) assert c == cirq.Circuit([cirq.Moment([cirq.X(q)])])