Esempio n. 1
0
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(),
    ])
Esempio n. 2
0
    def optimize_circuit(self, circuit: Circuit):
        moment_new_ops = defaultdict(
            list)  # type: Dict[int, List['cirq.Operation']]
        circuit_len = len(circuit)
        for i in range(circuit_len):
            moment_new_ops[i] = []
            for op in circuit[i].operations:
                opt = self.optimization_at(circuit, i, op)
                if opt is None:
                    # keep the old operation if the optimization did nothing.
                    moment_new_ops[i].append(op)
                    circuit.clear_operations_touching(op.qubits, [i])
                else:
                    # Clear target area, and insert new operations.
                    circuit.clear_operations_touching(
                        opt.clear_qubits,
                        [e for e in range(i, i + opt.clear_span)])
                    new_operations = self.post_clean_up(
                        cast(Tuple[ops.Operation], opt.new_operations))

                    flat_new_operations = tuple(
                        ops.flatten_to_ops(new_operations))

                    new_qubits = set()
                    for flat_op in flat_new_operations:
                        for q in flat_op.qubits:
                            new_qubits.add(q)

                    if not new_qubits.issubset(set(opt.clear_qubits)):
                        raise ValueError(
                            'New operations in PointOptimizer should not act on new'
                            ' qubits.')
                    moment_new_ops[i].extend(flat_new_operations)
        frontier = 0
        for i in range(circuit_len):
            new_frontier = circuit.insert(frontier, moment_new_ops[i],
                                          InsertStrategy.EARLIEST_AFTER)
            if frontier < new_frontier:
                frontier = new_frontier
Esempio n. 3
0
def test_insert():
    a = cirq.QubitId()
    b = cirq.QubitId()

    c = Circuit()

    c.insert(0, ())
    assert c == Circuit()

    with pytest.raises(IndexError):
        c.insert(-1, ())
    with pytest.raises(IndexError):
        c.insert(1, ())

    c.insert(0, [cirq.X(a), cirq.CZ(a, b), cirq.X(b)])
    assert c == Circuit([
        Moment([cirq.X(a)]),
        Moment([cirq.CZ(a, b)]),
        Moment([cirq.X(b)]),
    ])

    with pytest.raises(IndexError):
        c.insert(550, ())

    c.insert(1, cirq.H(b), strategy=InsertStrategy.NEW)
    assert c == Circuit([
        Moment([cirq.X(a)]),
        Moment([cirq.H(b)]),
        Moment([cirq.CZ(a, b)]),
        Moment([cirq.X(b)]),
    ])

    c.insert(0, cirq.H(b), strategy=InsertStrategy.EARLIEST)
    assert c == Circuit([
        Moment([cirq.X(a), cirq.H(b)]),
        Moment([cirq.H(b)]),
        Moment([cirq.CZ(a, b)]),
        Moment([cirq.X(b)]),
    ])