IQM becomes the first European quantum company to list on a major US exchange

Introduction

In a groundbreaking move for European quantum computing, IQM became the first European quantum company to list on the major US exchange Nasdaq. While this represents a significant milestone in the commercialization of quantum technology, it also highlights the growing importance of quantum computing in the global tech landscape. In this tutorial, we'll explore how to start working with quantum computing concepts using the open-source Qiskit library, which is one of the most popular tools for quantum programming. This tutorial will give you a hands-on introduction to quantum computing that mirrors the kind of work being done by companies like IQM.

Prerequisites

Before diving into quantum computing, you'll need a few things:

• A computer with internet access
• Basic Python knowledge (we'll use Python 3.8+)
• Python installed on your system
• Some understanding of linear algebra and basic quantum concepts (we'll explain as we go)

Don't worry if you're new to quantum computing – we'll start from the basics and build up to more complex concepts.

Step-by-Step Instructions

1. Install Required Software

First, we need to install Python and the Qiskit library. If you don't have Python installed, download it from python.org.

Once Python is installed, open your terminal or command prompt and run:

pip install qiskit

This command installs the Qiskit library, which provides everything we need to start experimenting with quantum circuits.

2. Create Your First Quantum Circuit

Now let's create a simple quantum circuit. This is like creating a blueprint for a quantum computer to follow.

Open a Python file (e.g., quantum_demo.py) and add the following code:

from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister

# Create a quantum circuit with 2 qubits and 2 classical bits
qc = QuantumCircuit(2, 2)

# Add a Hadamard gate to the first qubit
qc.h(0)

# Add a CNOT gate (controlled NOT) to entangle the qubits
qc.cx(0, 1)

# Measure both qubits
qc.measure_all()

# Print the circuit
print(qc.draw())

Why this matters: The Hadamard gate puts a qubit into a superposition state, where it exists in both 0 and 1 simultaneously. The CNOT gate creates entanglement between qubits, which is a key feature of quantum computing. Together, they form the foundation of many quantum algorithms.

3. Simulate the Quantum Circuit

Quantum computers are expensive and not widely available, so we simulate them using classical computers. This is where Qiskit shines – it allows us to test quantum circuits before running them on actual quantum hardware.

Add the following code to your Python file:

from qiskit import Aer, execute

# Get the quantum simulator
simulator = Aer.get_backend('qasm_simulator')

# Execute the circuit on the simulator
job = execute(qc, simulator, shots=1000)

# Get the results
results = job.result()

# Print the counts
print(results.get_counts(qc))

Why this matters: The simulation shows us what happens when we run our quantum circuit. The 'shots' parameter determines how many times we run the circuit. Each run will give us a random result, but over many runs, we can see the probability distribution of outcomes.

4. Run on Real Quantum Hardware (Optional)

Qiskit also allows you to run your circuits on real quantum computers via IBM Quantum Experience. First, you need to get an API token from the IBM Quantum website.

Add this code to your file:

from qiskit import IBMQ

# Load your IBM Quantum API token
IBMQ.load_account()

# Get the least busy backend
provider = IBMQ.get_provider(group='open')
backend = provider.get_backend('ibmq_qasm_simulator')

# Run the circuit on the real backend
job = execute(qc, backend, shots=1000)
results = job.result()
print(results.get_counts(qc))

Why this matters: This step shows how quantum computing is moving from theory to practice. Companies like IQM are working to make quantum computing accessible through both simulation and real hardware.

5. Understanding the Results

When you run the simulation, you'll see output like:

{'00': 502, '11': 498}

This shows that about 50% of the time, we get '00' and 50% of the time, we get '11'. This is because the entangled qubits will always be in the same state – a fundamental property of quantum entanglement.

6. Experiment with More Gates

Try modifying your circuit by adding more quantum gates:

# Add more gates to the circuit
qc.x(0)  # Apply a NOT gate
qc.y(1)  # Apply a Y gate
qc.z(0)  # Apply a Z gate

Each gate performs a specific quantum operation. The X gate flips a qubit, Y and Z gates perform rotations in different ways. These are the building blocks of quantum algorithms.

7. Visualize Your Circuit

Qiskit can also create visual representations of your circuits:

# Create a visual representation
from qiskit.tools.visualization import plot_histogram

# Run the simulation again
job = execute(qc, simulator, shots=1000)
results = job.result()

# Plot the results
plot_histogram(results.get_counts(qc))

This creates a bar chart showing the frequency of each result, making it easy to understand the quantum behavior.

Summary

In this tutorial, we've taken our first steps into quantum computing using Qiskit. We've learned how to:

1. Install the Qiskit library
2. Create a quantum circuit with qubits and quantum gates
3. Simulate quantum circuits on classical computers
4. Run circuits on real quantum hardware
5. Visualize and interpret quantum results

While this is just the beginning, understanding these fundamentals is crucial as companies like IQM continue to bring quantum computing closer to commercial reality. The technology is advancing rapidly, and tools like Qiskit are democratizing access to quantum computing for developers and researchers worldwide.

Remember, quantum computing is still in its early stages, but with each step we take, we're building the foundation for a future where quantum computers solve problems that are impossible for classical computers.