Example #1
0
def insert_identities_into_dd_protected_program(program: "Program",
                                                interval_time: float = None
                                                ) -> "Program":
    """
    
    :param program: A program with DD-protected Gates
    :param interval time : The duration of the free evolution (gate time of the I gates). 
    :return : A Program with inserted Identity gates
    
    For instance- each G.Z-X-Z-X sequence becomes G.Z-I-X-I-Z-I-X-I
    """
    p_new = Program()
    for g in program:
        if len(g.qubits) == 2:
            interval_I1 = gates_with_time('I', [], [g.qubits[0]])
            interval_I2 = gates_with_time('I', [], [g.qubits[1]])
            interval_I1.gate_time = interval_time
            interval_I2.gate_time = interval_time
            p_new += interval_I1
            p_new += interval_I2
            p_new += g
        else:
            interval_I = gates_with_time('I', [], g.qubits)
            interval_I.gate_time = interval_time
            p_new += interval_I
            p_new += g
    return p_new
Example #2
0
    def get_decoupling_sequence(self,
                                gate: Gate,
                                dd_pulse_time: float = None) -> "Program":
        if isinstance(gate, Gate):
            angle = None
            combined_gate = get_combined_gate(
                *get_combined_gate_representation(gate.name, 'Y', gate.params))

            if len(gate.qubits) != 1:
                p = Program(RX(pi, gate.qubits[0]), RX(pi, gate.qubits[1]),
                            RY(pi, gate.qubits[0]), RY(pi, gate.qubits[1]),
                            RX(pi, gate.qubits[0]), RX(pi, gate.qubits[1]))

            else:
                p = Program(RX(pi, *gate.qubits), RY(pi, *gate.qubits),
                            RX(pi, *gate.qubits))

            seq = set_gate_time(p, dd_pulse_time)
            GY = combined_gate(
                angle, *gate.qubits) if angle is not None else combined_gate(
                    *gate.qubits)
            GY = gates_with_time(GY.name, GY.params, GY.qubits)
            GY.dd = False
            seq += GY

            return seq
Example #3
0
    def get_decoupling_sequence(self,
                                gate: Gate,
                                dd_pulse_time: float = None) -> "Program":
        if isinstance(gate, Gate):
            angle = None

            if gate.name == "RZ":
                combined_gate = RZ
                angle, = gate.params
                angle += pi
            else:
                combined_gate = get_combined_gate(
                    *get_combined_gate_representation(gate.name, 'Z',
                                                      gate.params))

            if len(gate.qubits) != 1:
                p = Program(RY(pi, gate.qubits[0]), RY(pi, gate.qubits[1]),
                            RZ(pi, gate.qubits[0]), RZ(pi, gate.qubits[1]),
                            RY(pi, gate.qubits[0]), RY(pi, gate.qubits[1]))

            else:
                p = Program(RY(pi, *gate.qubits), RZ(pi, *gate.qubits),
                            RY(pi, *gate.qubits))

            seq = set_gate_time(p, dd_pulse_time)
            GZ = combined_gate(
                angle, *gate.qubits) if angle is not None else combined_gate(
                    *gate.qubits)
            GZ = gates_with_time(GZ.name, GZ.params, GZ.qubits)
            GZ.dd = False
            seq += GZ

            return seq
Example #4
0
    def get_decoupling_sequence(self,
                                gate: Gate,
                                dd_pulse_time: float = None) -> "Program":
        if isinstance(gate, Gate):
            combined_gate = get_combined_gate(
                *get_combined_gate_representation(gate.name, 'X', gate.params))
            if len(gate.qubits) != 1:
                p = Program(RY(pi, gate.qubits[0]), RY(pi, gate.qubits[1]),
                            RX(pi, gate.qubits[0]), RX(pi, gate.qubits[1]),
                            RY(pi, gate.qubits[0]), RY(pi, gate.qubits[1]))

            else:
                p = Program(RY(pi, *gate.qubits), RX(pi, *gate.qubits),
                            RY(pi, *gate.qubits))

            seq = set_gate_time(p, dd_pulse_time)
            GX = combined_gate(*gate.qubits)
            GX = gates_with_time(GX.name, GX.params, GX.qubits)
            GX.dd = False
            seq += GX

            return seq