Exploring Qiskit Pulse For Custom Quantum Gates

Introduction

Quantum computing has witnessed rapid advancements in the past few years, with hardware improvements and the development of new high-level software libraries. One of the essential software packages for quantum computing is Qiskit, an open-source framework by IBM to facilitate the design, simulation, and execution of quantum algorithms.

In this blog post, we will explore Qiskit Pulse, a powerful feature within Qiskit's architecture that enables the creation of custom quantum gates by directly manipulating the hardware. We will create an example custom gate by controlling the microwave pulses sent to the qubits and then verify its correctness using a quantum circuit.

Installation and Initialization

To get started, we first need to install the Qiskit library. You can do this using pip:

pip install qiskit

Now, we'll import the necessary packages and establish a connection to IBM Quantum's hardware by providing our API key:

from qiskit import IBMQ

IBMQ.save_account('your_api_key')
IBMQ.load_account()

Creating a Custom Quantum Gate with Qiskit Pulse

To create a custom quantum gate, we'll first define a function custom_gate_schedule that takes in the qubit index and returns a pulse schedule for the desired transformation.

Let's create a custom gate that flips the sign of the phase angle of a single qubit. We'll call this gate "PHASE_FLIP".

import numpy as np
from qiskit import pulse
from qiskit.pulse import Play, Schedule

backend = IBMQ.get_provider().get_backend('ibmq_armonk')

def custom_gate_schedule(qubit):

    # Obtain backend configurations
    config = backend.configuration()
    inst_sched_map = backend.defaults().instruction_schedule_map
    
    # Retrieve native gate properties
    u3_params = inst_sched_map.get('u3', qubits=[qubit]).instructions[0][1].pulse_shape.parameters
    
    # Generate custom gate pulse
    amp = u3_params['amp']
    beta = u3_params['beta']
    duration = u3_params['duration']
    sigma = u3_params['sigma']
    custom_pulse = pulse.drag(duration, 2*amp, sigma, (beta*sigma))

    # Configure pulse and schedule
    chan = pulse.DriveChannel(qubit)
    custom_schedule = Schedule(name="PHASE_FLIP")
    
    custom_schedule = custom_schedule.insert(0, Play(custom_pulse, chan))
    
    return custom_schedule

Verifying the Custom Gate

To verify the correctness of the custom gate, we'll create a quantum circuit and examine the statevector after applying our PHASE_FLIP gate to a simplistic initial state.

from qiskit import QuantumCircuit, transpile, schedule, execute, Aer
from qiskit.pulse import Schedule, DriveChannel

# Initialize a quantum circuit with single qubit
qc = QuantumCircuit(1)

# Apply a Hadamard gate followed by the custom PHASE_FLIP gate
qc.h(0)
qc.append(custom_gate_schedule(0), [0])

# Obtain pulse schedule for the quantum circuit
qc = transpile(qc, backend)
sched = schedule(qc, backend)

# Execute statevector simulation
backend_sim = Aer.get_backend('statevector_simulator')
result = execute(qc, backend_sim).result()
statevector = result.get_statevector(qc)

print("Statevector after PHASE_FLIP gate:", statevector)

For a correctly working PHASE_FLIP gate, the statevector after applying the gate should be [0.70710678+0.j, -0.70710678+0.j].

Conclusion

In this blog post, we have explored Qiskit Pulse and its capability to create custom quantum gates by directly controlling the hardware. We designed a custom PHASE_FLIP gate and verified its correctness by examining the statevector of a simple quantum circuit. As quantum computing technology continues to advance, Qiskit Pulse will play an increasingly vital role in enabling experimentation and fine-tuning quantum hardware for optimal performance.