Exploring the Basics of Quantum Computing: Practical Examples with OpenQAS and Python Based Implementation

Bloch Sphere

Basics of Quantum Computing with OpenQASM

Quantum computing is a revolutionary field that leverages the principles of quantum mechanics to perform computations that are infeasible for classical computers. In this blog, we will explore the basics of quantum computing using OpenQASM (Quantum Assembly Language) and understand some fundamental quantum gates through practical examples.

Quantum Gates: Building Blocks of Quantum Circuits

Dirac notation <bra | kat>

|0> this means up spin, and it’s vector is column vector
<0| this is also up spin but it’s row vector

(conjugate part of the column vector and vice versa.)

Pauli-X Gate: The Quantum NOT Rotation Gate

In classical computing, the NOT gate flips a bit: it turns 0 into 1 and 1 into 0. The quantum equivalent of this gate is the Pauli-X gate, also known as the X gate. This gate operates on a single qubit, flipping its state.

It performs a single-qubit rotation through π\piπ radians around the X-axis.

Pauli X Gate

X|0> (this is the Dot product of x and |0>)

In OpenQASM, the X gate can be implemented as follows:

// Declare a quantum register with 1 qubit
qreg q[1];

// Apply the X gate
x q[0];

Pauli X gate implimented by python using Qiskit Lib

PI rotation @ around the X-axis

from qiskit import *
from qiskit_aer import *
qcircuit=QuantumCircuit(1,1)
qcircuit.x(0)
qcircuit.draw('mpl')

Pauli-Y Gate: The Quantum Rotation Gate

The Pauli-Y gate is another fundamental gate in quantum computing. It performs a single-qubit rotation through π\piπ radians around the y-axis.

Definition

The Pauli-Y gate is represented by the following matrix:

Pauli Y Gate

In OpenQASM, the Y gate can be implemented as follows:

// Apply the Y gate
y q[0];

circuit diagram of Pauli X Gate

Pauli Y gate implimented by python using Qiskit Lib

PI rotation @ around the Y-axis

from qiskit import *
from qiskit_aer import *
qcircuit=QuantumCircuit(1,1)
qcircuit.y(0)
from qiskit.visualization import visualize_transition
visualize_transition(qcircuit)

Pauli-Z Gate: The Quantum Rotation Gate

The Pauli-Z gate is another fundamental gate in quantum computing. It performs a single-qubit rotation through π\piπ radians around the y-axis.

Definition

The Pauli-Z gate is represented by the following matrix:

// Apply the Zgate
z q[0];

Pauli Z Gate

In OpenQASM, the Z gate can be implemented as follows:

circuit diagram of Pauli X Gate

// Apply the Y gate
y q[0];

Pauli Z gate implimented by python using Qiskit Lib

PI rotation @ around the Z-axis

since the arrow is rotating on its own axis its seems not in motion

from qiskit import *
from qiskit_aer import *
qcircuit=QuantumCircuit(1,1)
qcircuit.z(0)
from qiskit.visualization import visualize_transition
visualize_transition(qcircuit)

Identity Gate: The Quantum Buffer Gate

The Identity gate in quantum computing is equivalent to the buffer gate in classical computing. It leaves the qubit state unchanged, effectively acting as a no-op operation. This can be useful for testing and calibration.

In OpenQASM, the Identity gate is represented as id:

// Declare a quantum register with 1 qubit
qreg q[1];

// Apply the Identity gate
id q[0];

Practical Example: Simulating a Qubit ON OpenQASM

Let’s start with a simple example where we use a qubit as a classical bit. In this case, the qubit is not in a superposition state and can only give one output.

Here is the simulated output of a qubit:

// Declare a quantum register with 1 qubit
qreg q[1];

// Measure the qubit
measure q[0] -> c[0];

The Power of Superposition: The Hadamard Gate

To truly harness the power of quantum computing, we need to explore superposition. This is where the Hadamard gate (H gate) comes into play. It puts a qubit into a superposition state, allowing it to be both 0 and 1 simultaneously.

Here’s how to implement the Hadamard gate:

// Declare a quantum register with 1 qubit
qreg q[1];

// Apply the Hadamard gate
h q[0];

// Measure the qubit
measure q[0] -> c[0];

Hadamard GATE implemented by python using Qiskit Lib

from qiskit import *
from qiskit_aer import *
qcircuit=QuantumCircuit(1,1)
qcircuit.y(0)
from qiskit.visualization import visualize_transition
visualize_transition(qcircuit)

Understanding Coherence Time

In quantum computing, coherence time refers to the duration for which a qubit retains its state before decoherence occurs. Maintaining coherence is crucial for reliable quantum computations. The Identity gate can help test coherence time by leaving the qubit state unchanged over time.

Conclusion

Every quantum gate has a corresponding matrix representation that dictates its operation on qubits. As we delve deeper into quantum computing, understanding these gates and their properties is essential for designing and implementing quantum algorithms.

Reach out to me at sksonukushwaha403@gmail.com or on LinkedIn