Jump Starting Quantum Computing on Azure

Why Quantum, Why Now

Quantum mechanics already powers everyday tech: it explains semiconductors (transistors, LEDs) that drive modern electronics and communications, and it enables MRI through nuclear magnetic resonance. These successes show how quantum theory shapes technology — yet quantum computing is different. It brings quantum effects directly into computation itself.

In this article, we’ll first introduce the minimal math you need for quantum computing — just enough to build intuition. Then we’ll walk through the simplest signature protocol, quantum teleportation, and finish by running a working example on Azure Quantum.

Classical vs. Quantum: a quick view

Intuition. If a classical bit is a coin lying heads or tails, a qubit is like a coin spinning in the air until you catch it.

• Classical bit: always 0 or 1.
• Qubit: can be 0, 1, or a blend of both until measured; measuring “catches” it as 0 or 1.

How programs are built

• Classical stack: transistors → logic gates (AND/OR/NOT) → flip-flops & registers → instruction sets → high-level languages.
• Quantum stack: physical qubits (ions, superconducting circuits, photons) → quantum gates (H for superposition, CNOT for entangling) → circuits & algorithms → SDKs (Qiskit, Q#, Cirq, Braket).

Key difference

Classical gates manipulate definite bits. Quantum gates manipulate probability amplitudes and correlations (entanglement), enabling behaviors no classical circuit can replicate efficiently.

In this article we use the common convention: |0⟩≡[1,0]^T, |1⟩≡[0,1]^T. Some books swap the order; that just relabels 0 and 1 and doesn’t change any results.

What Is a Qubit?

A qubit is a physical system that has two distinguished states we call |0⟩ and |1⟩. These are the “reference” states used for preparation and measurement — just like 0 and 1 for a classical bit. In math, the same states are written as the column vectors [1,0]^T and [0,1]^T. When you measure a qubit, the device reports either 0 or 1 relative to these states. Everything else you’ll see later (superposition and entanglement) is built from these two building blocks.

Superposition & Entanglement

Example of superposition:
|+⟩ and |−⟩ are the eigenvectors of the Pauli-X operator (σx​, also written Sx​); shown here only as a typical example of superposed qubit states.

Example of Entanglement:

The order of qubits in a multi-qubit state can depend on the endianness convention. In some quantum-computing frameworks, the leftmost bit is the least significant qubit, so |01⟩ means “qubit 0 = 1, qubit 1 = 0.” Other texts (especially in physics) treat the leftmost symbol as the first particle.

Superposition

A qubit can be in a combination of |0⟩ and |1⟩ at the same time, parallel possibilities. 

Intuitively, you can picture a qubit as a tiny arrow on a sphere (the Bloch sphere).

• If the arrow points straight down, the qubit is in |0⟩.
• If it points straight up, it’s in |1⟩.
• Anywhere else on the sphere means the qubit is in some mix of 0 and 1.

Measuring the qubit is like “checking” which direction the arrow favors: you’ll get 0 or 1 with probabilities set by its position.

Entanglement

Entanglement is a strong correlation between qubits that defies everyday intuition. Measure one, and you learn something instantaneously about the other, even if they’re far apart. It's an incredibly useful resource for algorithms and quantum communication. 

The example of an entangled state is the Bell State, which is shown above. 
Here |00⟩ and |11⟩ are two of the four basis states of a two-qubit system (a 4-dimensional state space).

Bell state designates that the probability of being |00⟩ and |11⟩ are 50/50. Measuring both qubits gives:

• 00 with probability 1/2
• 11 with probability 1/2
• 01 and 10 with probability 0

Fundamentals of Quantum Gates and Circuits

Just as classical computers use logic gates such as AND or NAND, quantum computers also use quantum gates.
Consider a 2 qubit-system:  Operate Hadamard gate to the 1st qubit (creates H|0⟩), then operate CNOT creates an Entanglement state:

• Hadamard (H): used to create a superposition from a computational basis state |0⟩ or |1⟩
• CNOT: Flips the target qubit if the control qubit is |1⟩. This gate is essential for creating entanglement.
  For example, if you first apply a Hadamard gate to one qubit in a two-qubit system and then apply a CNOT (with the first qubit as control and the second as target), the two qubits become entangled.

Imagine you have two coins that can be heads (0) or tails (1).

1. You first “spin” the first coin (this is what the Hadamard gate does). While it’s spinning, it’s both heads and tails at once.
2. Then you use a special rule — the CNOT gate — that says:A Hadamard on the first qubit creates |+⟩; applying CNOT (control = first, target = second) turns |+⟩⊗|0⟩ into the entangled state 1/sqrt2(|00⟩+|11⟩).
   “If the first coin would land tails (1), flip the second coin; if it would land heads (0), leave the second coin alone.”

Because the first coin was spinning (0 and 1 at the same time), this rule makes the two coins become linked:

• If the first ends up heads, the second is heads.
• If the first ends up tails, the second is tails.

After this step, they are no longer independent. They’re in a single shared quantum state:

That’s what “entangled” means — even if you separate them, measuring one instantly tells you what the other will be, because they’re described by one joint state, not two separate ones.

Quantum Teleportation

What it does

Consider Alice who sends a qubit's state to Bob. To teleport a qubit’s state, Alice and Bob first create an entangled pair: start with two |0⟩ qubits, apply a Hadamard to the first, then a CNOT from the first to the second. Alice then takes the unknown qubit she wants to send, applies a CNOT from it to her half of the pair, and a Hadamard on it. Measuring these two qubits gives Alice two classical bits. She sends those bits to Bob, who uses them to decide whether to apply a Z and/or an X gate to his qubit. After that, Bob’s qubit ends up in exactly the same state Alice started with.

In this scenario, the teleportation protocol you see here moves only a single qubit’s state. To send larger quantum information, the process must be repeated — one entangled pair and two classical bits for each qubit to be teleported.

What This is Meant

Imagine Alice has a single qubit in some unknown quantum state — a fragile, special “arrow on a sphere” that she wants to send to Bob, who is far away.
She can’t just copy the qubit and email the file; quantum states can’t be cloned. She also can’t just measure it and tell Bob the result, because a measurement destroys the state and only gives her one bit of information.

So instead, Alice and Bob start with a clever trick: beforehand they share an entangled pair of qubits. Think of this pair as two perfectly correlated “quantum coins,” one with Alice and one with Bob. This shared entanglement is like a secret quantum bridge between them.

When Alice wants to send her qubit’s state:

1. Alice performs a special joint measurement on her unknown qubit and her half of the entangled pair.
   This step destroys her original qubit (so the state doesn’t exist twice) but produces two ordinary bits of classical information — just 0s and 1s.
2. Alice sends those two classical bits to Bob over a normal communication channel (email, phone, fiber optic cable — anything works, because these are just regular bits now).
3. Bob uses those two bits to decide which simple quantum operation to perform on his half of the entangled pair.
   After he does this, his qubit becomes an exact copy of the state Alice started with — even though the original qubit was destroyed.

Why It Matters

• It shows that superposition and entanglement aren’t just weird physics but can be turned into real information-handling protocols.
• It’s a key building block for a future “quantum internet”, where quantum states can be sent across long distances.
• It underpins secure quantum communication, since the original state is never copied and eavesdroppers can’t intercept without being noticed.

Try it on Azure Quantum

First, create an Azure Quantum workspace — the free Quick create option is fine.
Once the workspace is provisioned, open the Azure portal, navigate to your workspace, and copy its Resource ID.

If you’re comfortable with Python, we’ll use Qiskit to submit a job. In VS Code, install the Azure Quantum Development Kit (QDK) extension, then install the required Python packages for your environment. This combination lets you write, run, and submit quantum circuits directly from VS Code with minimal setup.

python -m pip install --upgrade azure-quantum[qiskit] qsharp ipykernel matplotlib pylatexenc

Start a notebook in VS Code

Open a new Jupyter notebook in VS Code and begin your Python setup.
In the first cell, import the packages and set your Resource ID (from the previous step) and the workspace location.

from azure.quantum import Workspace 
from qiskit import QuantumCircuit
from qiskit.visualization import plot_histogram
from azure.quantum.qiskit import AzureQuantumProvider
import os
from dotenv import load_dotenv
load_dotenv(override=True)

workspace = Workspace(  
    resource_id = os.getenv("RESOURCE_ID"), # Add the resourceID of your workspace
    location = os.getenv("LOCATION") # Add the location of your workspace (for example "westus")
    )

provider = AzureQuantumProvider(workspace)

2nd cell is to prepare the quantum circuit for Quantum Teleportation. 
Line1 creates a quantum circuit with 3 qubits and 3 classical bits. In quantum teleportation, we need:

• Qubit 0: The qubit whose state we want to teleport
• Qubit 1: Alice's part of the entangled pair
• Qubit 2: Bob's part of the entangled pair

Line 3 sets up the state to Teleport. This applies an X gate (NOT gate) to qubit 0, putting it in the |1⟩ state. This is the quantum state that Alice wants to teleport to Bob. The comment notes this is optional - you could teleport any quantum state, but |1⟩ is chosen as a simple example.

Line4 is just a separator for better readability.

The combination of Line6 and Line 7 creates an entanglement pair as explained in the previous paragraph. In these statements, "h(n)" means Hadamard gate, and "cx(n)" indicates CNOT gate.

Line 14; This line performs the measurement of Alice's two qubits (qubit 0 and qubit 1):

• First argument [0, 1]: List of quantum bits to measure (qubit 0 and qubit 1)
• Second argument [0, 1]: List of classical bits to store the results (classical bit 0 and classical bit 1)

circuit = QuantumCircuit(3,3)

circuit.x(0)
circuit.barrier()

circuit.h(1)
circuit.cx(1,2)
circuit.barrier()

circuit.cx(0,1)
circuit.h(0)
circuit.barrier()

circuit.measure([0, 1], [0, 1])
circuit.barrier()

circuit.cx(1, 2)
circuit.cz(0, 2)
circuit.measure([2], [2])
circuit.draw(output='mpl')

When you run the cell, it produces an output of the quantum circuit of Teleportation.

While Qiskit itself provides a simulator, I used the simulator provided by the quantum hardware providers.
By running the following cell, you can have a list of backend simulators.

print("This workspace's targets:")
for backend in provider.backends():
    print("- " + backend.name())

output

This workspace's targets:
- quantinuum.sim.h1-1sc
- quantinuum.sim.h1-1e
- rigetti.sim.qvm
- quantinuum.sim.h1-1sc
- quantinuum.sim.h1-1e
- rigetti.sim.qvm

As the list may vary depending on the region and the plan of the workspace, you need to confirm by yourself.
I chose and set "quantinuum.sim.h1-1e" to run a job.

simulator_backend = provider.get_backend("quantinuum.sim.h1-1e")

Finally submitting a job using the following cell code.

# Submit the circuit to run on Azure Quantum
job = simulator_backend.run(circuit, shots=1024)
job_id = job.id()
print("Job id", job_id)

# Get the job results (this method waits for the Job to complete):
result = job.result()
print(result)
counts = {format(n, "03b"): 0 for n in range(8)}
counts.update(result.get_counts(circuit))
print(counts)
plot_histogram(counts)

The output should show the graph similar to the following image. If your output showed different pattern, change the backend simulator.

In Qiskit endian format, 

• 1st digit (leftmost): Result of qubit 2 (Bob's qubit)
• 2nd digit (middle): Result of qubit 1 (Alice's entangled qubit)
• 3rd digit (rightmost): Result of qubit 0 (original state qubit)

Since we initially set qubit 0 to |1⟩ state and want to teleport it to qubit 2, we should see these measurement patterns:

• 100: Qubit 2 = |1⟩ (teleportation successful), Alice measured 00
• 101: Qubit 2 = |1⟩ (teleportation successful), Alice measured 01
• 110: Qubit 2 = |1⟩ (teleportation successful), Alice measured 10
• 111: Qubit 2 = |1⟩ (teleportation successful), Alice measured 11

Conclusion

Quantum computing turns superposition and entanglement into working tools. In this post you built intuition for qubits and gates, created a Bell state with H + CNOT, and walked through quantum teleportation, finishing with a run on Azure Quantum. Today’s devices are small and noisy, but capabilities are steadily improving.

Why watch this field? Algorithms like Shor’s Algorithm—which can factor large integers efficiently—strike at the foundation of widely used public-key cryptography (e.g., RSA). While fault-tolerant machines aren’t here yet, the prospect of breaking current encryption is a concrete, high-impact milestone that keeps quantum progress consequential. Add potential gains in optimization and materials discovery, and the direction is clear: as hardware and error-handling advance, practical breakthroughs will follow. Keep an eye on quantum computing—the next meaningful steps may arrive sooner than expected.