In my last post, I shared five questions to help you get really good at the linear algebra needed for quantum computing. Let’s dive in and solve the fourth one step by step.

Subscribe now

Question 4

Given two matrices A and B:

• Compute the commutator [A,B] = AB − BA

• Check if A and B commute.

Solution 4

A commutator tells us whether the order of multiplying two matrices matters.

For two matrices A and B, it is defined as:

[A,B] = AB − BA

If the result is zero, or AB = BA, we say that A and B commute.

Let’s first calculate AB as follows:

Next, we calculate BA as follows:

The commutator is calculated as follows:

Since [A,B] ≠ 0, A and B do not commute.

Thanks for being a curious reader of ‘Into Quantum’, a publication that teaches essential concepts in quantum computing from the ground up. To get even more value from this publication, consider becoming a paid subscriber.

Join the paid tier today

In the last post, I shared with you 5 questions that will help you become great at linear algebra and ace Quantum computing.

Let’s dive in and solve the third one step by step.

Question 3

Given two quantum states as follows:

1. Compute their inner product

2. Compute their Fidelity

Solution 3

3.1: Computing the inner product

The inner product of two qubits |ψ> and |ϕ> is represented as <ϕ|ψ>.

This means that we first need to write |ψ> in its bra form as <ψ|.

Next:

From previous lessons, we know that:

This simplifies the above equation to:

This is the inner product of these two qubits.

3.2: Computing the Fidelity

Fidelity is a measure of how similar two quantum states/ qubits are.

Fidelity tells how closely a practical, noisy quantum state/ operation matches its ideal theoretical counterpart. This helps to benchmark quantum computers and evaluate quantum state preparation.

The value of Fidelity lies between 0 and 1, where:

• 1 means that the two qubits are the same or their state is identical

• 0 means that the states are completely different or orthogonal

For two qubits |ψ> and |ϕ>, the Fidelity is calculated as:

This means that we:

1. First, compute the inner product of the two qubits

2. Then, square the absolute value of this result

We already calculated the inner product of the two qubits as follows.

The Fidelity is calculated by taking the square of the absolute value of this result.

This is approximately equal to 0.933.

This tells us that these states are quite similar to one another (close to 1).

Thanks for being a curious reader of ‘Into Quantum’, a publication that teaches essential concepts in Quantum Computing from the ground up.

To get even more value from this publication, consider becoming a paid subscriber.

Join the paid tier today!

In the last post, I shared with you 5 questions that will help you become great at linear algebra and ace Quantum computing.

Let’s dive into the solution to the second one.

Subscribe now

Question 2

Given the following matrix A:

1. Prove that it is Hermitian

2. Find its eigenvalues and eigenvectors

Solution 2

2.1: Proving that the matrix is Hermitian

We learned in previous lessons that a Hermitian matrix is a square matrix equal to its conjugate transpose.

The given matrix A is a 2 x 2 square matrix.

Next, we need to find its conjugate transpose, which is a combination of the transpose and complex conjugate operations.

The transpose of A is calculated as:

Next, the complex conjugate is calculated as:

This is the same as A.

This means that A is a Hermitian matrix.

2.2: Finding the eigenvalues and eigenvectors of the matrix

To find the eigenvalues of a square matrix, we need to solve the characteristic equation, defined as follows, where I is the identity matrix.

where

The determinant of this term is calculated as:

Using the quadratic formula on this equation results in:

Hermitian matrices represent observables (physical quantities that can be measured, such as spin, position, momentum, energy, and more) in quantum mechanics.

A core mathematical property of a Hermitian matrix is that all its eigenvalues are real, which we see in this case.

Given a square matrix A of size n x n, an Eigenvector is a non-zero vector v that, when multiplied by A, results in a scalar multiple of itself.

Eigenvectors multiplied by A just scales (stretches or compresses) them without rotation or change in direction.

Let’s next find the eigenvectors using the following equation (derived by rearranging the characteristic equation):

where:

Next:

Choosing x = 1 (Since eigenvectors can be multiplied by any non-zero scalar, we chose the simplest value), the eigenvector is:

Putting eigenvalue λ₁, we get eigenvector v₁:

For eigenvalue λ₂, we get eigenvector v₂:

Thanks for being a curious reader of ‘Into Quantum’, a publication that teaches essential concepts in Quantum Computing from the ground up.

To get even more value from this publication, consider becoming a paid subscriber.

Join the paid tier today!

🎁 A flash sale just went live for “LLMs In 100 Images”!

I am offering you a 40% discount on the book for the NEXT 24 hours! (It’s actually 22 hours now.)

It won’t be a better time to get the book if you’ve been thinking about it.

Here’s your link:

Grab your 40% discount

⏰ This offer ends in the next 22 hours, so don’t wait too long.

Cheers,
Ashish

In the last post, I shared with you 5 questions that will help you become great at linear algebra and ace Quantum computing.

Let’s dive into the solution to the first one.

Question 1

Given the following matrix U:

1. Prove that U is a Unitary matrix.

2. Next, apply U to the state |0> and express the resulting state in Dirac notation and vector form.

3. Finally, compute the measurement probabilities in the computational basis.

Solution 1

1.1: Prove that U is a unitary matrix.

A Unitary matrix is a square matrix whose conjugate transpose is its inverse.

Or, a Unitary matrix multiplied with its conjugate transpose returns the Identity matrix.

Let’s start with finding the conjugate transpose (U†) of U.

To compute it, we:

• Take the complex conjugate of each entry in the matrix

• Transpose the matrix

This is shown mathematically as follows:

Since all entries in U are real, the complex conjugate of it is the same as the original matrix.

Next, we transpose U:

This means that the conjugate transpose of U equals the original matrix.

Followed by this, we compute U†U as follows:

Since we obtain the Identity matrix, this proves that U is a Unitary matrix.

1.2: Apply U to the state |0> and express the resulting state in Dirac notation and vector form.

In the vector form:

Applying U to |0> results in the following vector:

This vector in the Dirac notation is as follows:

1.3: Compute the measurement probabilities in the computational basis.

The computational basis is { |0> , |1> } and the resulting state is as follows:

The measurement probabilities are the squared magnitudes of the amplitudes of this state, as follows:

Quick question: Would you like to guess which quantum gate U represents? Let me know in the comments below!

Thanks for being a curious reader of ‘Into Quantum’, a publication that teaches essential concepts in Quantum Computing from the ground up.

To get even more value from this publication, consider becoming a paid subscriber.

Join the paid tier today!

Here are 5 questions to strengthen your linear algebra skills and make you a better quantum engineer.

Solve them by hand and share their solutions in the community chat.

1

Given the following matrix U:

1. Prove that U is a unitary matrix.

2. Next, apply U to the state |0> and express the resulting state in Dirac notation and vector form.

3. Finally, compute the measurement probabilities in the computational basis.

2

Given the following matrix A:

1. Prove that it is Hermitian

2. Find its eigenvalues and eigenvectors

3

Given two quantum states as follows:

1. Compute their inner product

2. Compute their Fidelity

4

Given two matrices A and B:

• Compute the commutator [A,B] = AB − BA

• Check if A and B commute.

5

For the given matrix M:

• Compute M † M

• Find the eigenvalues of M † M

• Determine the singular values of M.

I’ll see you soon with detailed solutions to the questions.

Thanks for being a curious reader of ‘Into Quantum’, a publication that teaches essential concepts in Quantum Computing from the ground up.

To get even more value from this publication, consider becoming a paid subscriber.

Join the paid tier today!

In the previous lessons on ‘Into Quantum’, we have explored multi-qubit quantum gates, such as the CNOT gate.

The CNOT gate is a two-qubit quantum gate where the control qubit determines whether the target qubit is flipped or not.

In this lesson, we will discuss another multi-qubit quantum gate called the Toffoli gate, which extends the CNOT gate by adding a second control qubit.

Let’s begin!

Subscribe now

What is the Toffoli gate?

The Toffoli gate is also called the Controlled-Controlled-NOT (CCNOT) gate.

It is a three-qubit gate that receives three inputs and returns three outputs. The first two inputs are ‘Control qubits’, and the third input is the 'Target qubit’.

The gate flips the target qubit if and only if both control qubits are in the |1> state. Otherwise, it returns the target qubit unchanged. Also, the two control qubits are always returned unchanged.

There are two properties of the gate that you must know about:

• It is reversible, which means that it is its own inverse.
  If we apply the gate again to its outputs, we get the original inputs back, without losing any information.

• It is universal for classical computing, which means that we can build any logic circuit we want by connecting many Toffoli gates.
  But in quantum computing, we need to combine the Toffoli with other gates to make it universal.

The gate was invented by and named after Tommaso Toffoli, an Italian-American professor of electrical and computer engineering at Boston University.

Toffoli Gate In Action

Take an example of the three qubits |A>,|B>,|C> input to the Toffoli gate, as shown below:

When the Toffoli gate is applied with |A> and |B> as the control qubits, and |C> as the target qubit, the outputs returned are:

• Output 1 is |1>
  (Control qubit |A> is returned unchanged.)

• Output 2 is |1>
  (Control qubit |B> is returned unchanged.)

• Output 3 is |1>
  (|C>, previously |0>, is flipped because both control qubits |A> and |B> are |1>.)

This operation is represented as:

Subscribe now

Truth Table

The truth table for the Toffoli gate is as follows.

Since each qubit can be |0> or |1>, there are 2³ = 8 possible inputs.

Circuit Symbol

In a quantum circuit, the Toffoli gate is represented using the following symbol, where:

• The ● symbol represents the control qubits.

• The ⊕ symbol represents the target qubit and indicates that a NOT operation (Pauli-X) is applied to it conditionally.

Algebraic Representation

The operation performed by the Toffoli gate can be represented as:

where:

• ⊕ is the XOR (exclusive OR) operation, and

• · is the multiplication (AND) operation

This means that the Toffoli gate computes the AND of the two control qubits and XORs the result with the target.

Matrix Representation

The Toffoli gate acts on a 3-qubit system, and is represented by a 2³ × 2³ = 8 × 8 unitary matrix as follows:

Note how only the last two rows (and columns) are swapped.

Consider the three qubits |A>,|B>,|C> again, which represent the inputs to the gate:

The combined input state to the Toffoli gate is:

The computational basis states for a 3-qubit system are:

On this basis:

When we apply the Toffoli gate to it, the following matrix multiplication takes place:

This result is equal to |111>.

That’s everything for this article.

Thanks for being a curious reader of ‘Into Quantum’, a publication that teaches essential concepts in Quantum Computing from the ground up.

To get even more value from this publication, consider becoming a paid subscriber.

Join the paid tier today!

Hello! 👋🏻

I recently published a challenge with 6 Qiskit questions to get started with Quantum Computing.

Here is the solution to the 6th question from the challenge.

Question 6

Create a three-qubit W-state in Qiskit. Measure and simulate the circuit using a Qiskit simulator.

What is the W state?

Read more

Hey there!

I recently published a challenge with 6 Qiskit questions to get started with Quantum Computing.

Here is the solution to the 5th question from the challenge.

Subscribe now

Question 5

Create a three-qubit Greenberger-Horne-Zeilinger (GHZ) state in Qiskit.

Measure and simulate the circuit using a Qiskit simulator.

What is the Greenberger–Horne–Zeilinger (GHZ) State?

A GHZ state (Greenberger–Horne–Zeilinger state), named after the three authors who first described this state, is a multi-qubit entangled quantum state that involves three or more qubits.

For the 3-qubit case, it is mathematically described as:

For n > 3 qubits, it is mathematically described using the general form:

GHZ states are used to demonstrate quantum non-locality among multiple parties and in secure quantum communication protocols such as multi-party quantum secret sharing (QSS).

Subscribe now

Solution

Let’s create a three-qubit Greenberger-Horne-Zeilinger (GHZ) state in Qiskit.

• We start by creating a circuit with 3 qubits and 3 classical bits to store measurement results.

from qiskit import QuantumCircuit

circuit = QuantumCircuit(3, 3)

At this point, all qubits (q(0), q(1) and q(2)) are in state |0>.

• Next, we put qubit 0 or q(0) into an equal superposition state using the Hadamard gate.

circuit.h(0)

Qubit 0 now looks as follows:

• Next, we consider the joint state of q(0) and q(1) and apply the CNOT gate to it, with q(0) as the control and q(1) as the target.

The CNOT (Controlled-NOT) gate flips the target qubit if and only if the control qubit is in state |1>.

Applying CNOT results in:

This is the Bell state |Φ+>.

We perform these operations in Qiskit as follows:

circuit.cx(0, 1)

• Then, we consider the 3rd qubit along with the previously created Bell state and apply the CNOT gate using q(0) as the control and q(2) as the target.

Apply CNOT results in:

We perform these operations in Qiskit as follows:

circuit.cx(0, 2)

This results in the GHZ state.

• Finally, we measure all qubits and store their results in the corresponding classical bits

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

This is how the circuit and all its operations look.

print(circuit.draw())

     ┌───┐             ┌─┐   
q_0: ┤ H ├──■────■─────┤M├───
     └───┘┌─┴─┐  │  ┌─┐└╥┘   
q_1: ─────┤ X ├──┼──┤M├─╫────
          └───┘┌─┴─┐└╥┘ ║ ┌─┐
q_2: ──────────┤ X ├─╫──╫─┤M├
               └───┘ ║  ║ └╥┘
c: 3/════════════════╩══╩══╩═
                     1  0  2 

The numbers at the bottom show which classical bit each qubit’s measurement is stored in. Note that this sequence does not represent the time order of measurements. It simply shows how each qubit’s measurement is mapped to a classical bit.

Now that we have created the quantum circuit, it is time to simulate it on the quantum simulator.

from qiskit_aer import AerSimulator
from qiskit import transpile

# Instantiate Qiskit quantum simulator
simulator = AerSimulator()

# Transpilation
transpiled_circuit = transpile(circuit, simulator)

# Execute the circuit on the simulator for 1024 repetitions
result = simulator.run(transpiled_circuit, shots=1024).result()

# Get the measurement results
counts = result.get_counts()

print("Counts:", counts)
# Counts: {'111': 507, '000': 517}

We run the simulations for 1024 independent shots. The counts value represents how many times each outcome occurred during these shots.

These outcomes are visualised as follows.

from qiskit.visualization import plot_histogram

plot_histogram(counts)

We calculate the probabilities for each outcome as follows.

# Calculate probabilities
total_shots = sum(counts.values())

for outcome, count in counts.items():
    probability = (count / total_shots) * 100
    print(f"|{outcome}⟩: {count} counts ({probability:.1f}%)")

"""
Output:
|111⟩: 507 counts (49.5%)
|000⟩: 517 counts (50.5%)
"""

When we measure all three qubits, we observe 000 and 111 with each occurring about 50% of the time as expected.

That’s everything for this article.

Thanks for being a curious reader of ‘Into Quantum’, a publication that teaches essential concepts in Quantum Computing from the ground up.

To get even more value from this publication, consider becoming a paid subscriber.

Join the paid tier today!

Hey everyone!

I recently published a challenge with 6 Qiskit questions to get started with Quantum Computing.

Here is the solution to the fourth question from the challenge.

Subscribe now

Before we move forward, I want to introduce you to the Visual Tech Bundle.

It is a collection of visual guides that explain core AI, LLM, Systems design, and Computer science concepts via image-first lessons.

Others are already loving these books.

This includes Dharmesh Shah, the co-founder and CEO of HubSpot.

Why not give them a try?

Link to the Visual Tech Bundle

Now back to our lesson!

Question 4

Find the sequence of X, Y, and Z gates that transforms the quantum state |+⟩ to i|-⟩ . Verify the results using a Qiskit simulator.

Solution 4

|+> and |-> can be written as follows:

And, our target i|-> can be written as:

We know from previous lessons that the Pauli-Z gate causes a phase flip for a qubit in the state |1> but leaves |0⟩ unchanged.

Applying Pauli-Z to |+> results in:

From here, to get i|->, we can simply multiply both sides by i as follows:

Note the iZ term on the LHS. We know from a previous lesson on Quantum gate relations, that:

To apply XY to a state, the circuit must do:

• Apply Y first

• Then apply X

(Read it again!)

Following this, applying Pauli-Y to |+> results in:

Next, applying Pauli-X to this state results in our desired state.

Subscribe now

Verifying the Result with a Quantum Simulator

Here is a program that checks whether our results are correct using the Qiskit simulator.

We start by importing the necessary libraries.

from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector
import numpy as np

Next, we create a quantum circuit with one qubit and apply our gate sequence.

The Hadamard gate (H) creates the |+> state from the default |0> state, which is followed by applying the Y and X gates.

# Create circuit
circuit = QuantumCircuit(1)

circuit.h(0)   # Convert |0> to |+>
circuit.y(0)   # Apply Y
circuit.x(0)   # Apply X

We can visualize the circuit as follows.

# Visualise the circuit
print(circuit)

"""
Output:
   ┌───┐┌───┐┌───┐
q: ┤ H ├┤ Y ├┤ X ├
   └───┘└───┘└───┘
"""

Next, we use the Statevector class to simulate the circuit and compute the final quantum state after all gates have been applied.

sv = Statevector(circuit)
print(sv)

"""
Output:
Statevector([0.+0.70710678j, 0.-0.70710678j],
            dims=(2,))
"""

In the final step, we manually define our target state i|-> and compare it against the simulation result.

target = np.array([1j/np.sqrt(2), -1j/np.sqrt(2)]) # |->
print("Target:", target)

"""
Output: 
Target: [ 0.+0.70710678j -0.-0.70710678j]
"""

print("Result matches the target") if np.allclose(sv.data, target) else print("Result does not match the target")

"""
Output:
Result matches the target
"""

The simulation confirms that applying the gate sequence Pauli-Y followed by Pauli-X to the state |+> successfully produces the target state i|->.

That’s everything for this article.

Thanks for being a curious reader of ‘Into Quantum’, a publication that teaches essential concepts in Quantum Computing from the ground up.

To get even more value from this publication, consider becoming a paid subscriber.

Become a paid subscriber

Hey everyone!

I recently published a challenge with 6 Qiskit questions to get started with Quantum Computing.

Here is the solution to the third question from the challenge.

Subscribe now

Question 3

Create a 2-qubit circuit that prepares the following Bell state. Measure both qubits using a Qiskit simulator and show the results.

Solution 3

We start by installing Qiskit and the Qiskit Aer library.

Qiskit Aer is a high-performance library with realistic noise models to run quantum computing simulations on classical computers.

!uv pip install qiskit qiskit-aer 

Next, we import the necessary packages.

from qiskit import QuantumCircuit # To create and manipulate quantum circuits

from qiskit_aer import Aer # Qiskit simulator backend 

from qiskit.visualization import plot_histogram # To visualise measurement results 

We then create the quantum circuit using QuantumCircuit(2, 2) where:

• The first argument (2) represents two qubits, both starting in the state |0>, so the full initial state is |00>.

• The second argument represents (2) two classical bits used to store the measurement results of the two qubits.

# Create circuit
circuit = QuantumCircuit(2, 2)

Read more

Hey everyone!

Last week, I published a challenge with 6 Qiskit questions to get started with Quantum Computing.

Here are the solutions to the first two questions from the challenge.

Subscribe now

Question 1

Create a 1-qubit quantum circuit that:

1. Starts in the state |0>

2. Applies a Hadamard gate

3. Measures the qubit

Write the Qiskit code and simulate the circuit using a Qiskit simulator.

Solution 1

We start by installing Qiskit and the Qiskit Aer library.

Qiskit Aer is a high-performance library with realistic noise models to run quantum computing simulations on classical computers.

!uv pip install qiskit qiskit-aer 

If you’re interested in running the following code on a real quantum computer, refer to the following article.

Next, we import the necessary packages.

from qiskit import QuantumCircuit # To create and manipulate quantum circuits

from qiskit_aer import Aer # Qiskit simulator backend 

from qiskit.visualization import plot_histogram # To visualise measurement results 

We then create the quantum circuit using QuantumCircuit(1, 1) where the:

• First 1 represents one qubit. This qubit is in state |0>.

• Second 1 represents one classical bit used to store the measurement result.

# Create circuit 
circuit = QuantumCircuit(1, 1) 

Next, we apply the Hadamard gate to the qubit and then measure it.

# Apply Hadamard gate to qubit at index 0
circuit.h(0) 

# Measure qubit at index 0 and store in classical bit at index 0
circuit.measure(0, 0) 

This is how these operations look.

# Visualise the circuit operations
print(circuit)

     ┌───┐┌─┐
  q: ┤ H ├┤M├
     └───┘└╥┘
c: 1/══════╩═
           0 

In the above circuit visualisation:

• the single horizontal line (-) represents the qubit connections

• the double line (═) represents the classical connections

• q represents the quantum register

• c: 1/ represents the classical register where measurement results are stored, where 1/ means that we have 1 classical bit

• ┤ H ├ is the Hadamard gate applied to the qubit

• ┤M├ is the Measurement operation

• ╩ is where the measurement result gets written to the classical bit

• 0 below the double lines indicates that the classical bit is at index 0

Now that we have created a quantum circuit, it is time to simulate it on the quantum simulator.

# Instantiate Qiskit quantum simulator
simulator = Aer.get_backend("qasm_simulator")

# Executes the circuit on the simulator for 1024 repetitions
job = simulator.run(circuit, shots = 1024) 

# Get the measurement results
result = job.result()
counts = result.get_counts(circuit)

print(counts)
# Output: {'0': 507, '1': 517}

We run the simulations for 1024 independent shots. This means that the circuit resets to |0>, applies an H gate, measures, and records the result. That’s why we get a distribution of outcomes rather than just one answer.

The counts value represents how many times each outcome occurred.

These outcomes are visualised as follows.

plot_histogram(counts)

This is how we calculate the probabilities for each outcome.

# Calculate probabilities
total_shots = sum(counts.values())
for outcome, count in counts.items():
    probability = (count / total_shots) * 100
    print(f"|{outcome}⟩: {count} counts ({probability:.1f}%)")

"""
Output:
|0⟩: 507 counts (49.5%)
|1⟩: 517 counts (50.5%)
"""

To revise, the following operations take place in the above circuit:

• The qubit starts in the state |0>

• When the Hadamard gate is applied, it transforms the qubit into a quantum superposition (|0⟩ + |1⟩)/√2

  This means that the qubit simultaneously exists in both the |0⟩ and |1⟩ states with equal probability amplitudes.

• When we measure the qubit, this superposition instantly collapses to either |0⟩ or |1⟩, each with a 50% probability.

• Since we run the circuit 1024 times (shots), we observe approximately equal counts of “0” and “1”, confirming the equal superposition created by the Hadamard gate. With more shots, the counts would converge even closer to 50/50.

It’s time to move to solving question 2.

Question 2

Create a 1-qubit quantum circuit that:

1. Applies an X gate

2. Applies a Z gate

3. Measures the qubit

Write the Qiskit code and simulate the circuit using a Qiskit simulator.

Solution 2

from qiskit import QuantumCircuit
from qiskit_aer import Aer
from qiskit.visualization import plot_histogram

# Create circuit with 1 qubit and 1 classical bit
circuit = QuantumCircuit(1, 1)

# Apply X gate (flips |0> to |1>)
circuit.x(0)

# Apply Z gate (adds phase to |1>)
circuit.z(0)

# Measure qubit 0 and store in classical bit 0
circuit.measure(0, 0)

# Visualize the circuit
print(circuit)

     ┌───┐┌───┐┌─┐
  q: ┤ X ├┤ Z ├┤M├
     └───┘└───┘└╥┘
c: 1/═══════════╩═
                0

# Simulate
simulator = Aer.get_backend("qasm_simulator")
job = simulator.run(circuit, shots=1024)
result = job.result()
counts = result.get_counts(circuit)

print(counts) 
# Output: {'1': 1024}

# Calculate probabilities
total_shots = sum(counts.values())
for outcome, count in counts.items():
    probability = (count / total_shots) * 100
    print(f"|{outcome}⟩: {count} counts ({probability:.1f}%)")

# Output: |1⟩: 1024 counts (100.0%)

plot_histogram(counts)

The following operations take place in the above circuit:

• The qubit starts in the state |0⟩

• When the X gate is applied, it flips the qubit: X|0⟩ = |1⟩.

• When the Z gate is applied, it adds a phase factor: Z|1⟩ = -|1⟩. This global phase doesn’t affect measurement outcomes in the computational basis.

• When we measure the qubit, it collapses to |1⟩ with 100% probability.

• Since we run the circuit 1024 times (shots), we observe all 1024 measurements as “1” and none as “0.”

That’s everything for this article.

Thanks for being a curious reader of ‘Into Quantum’, a publication that teaches essential concepts in Quantum Computing from the ground up.

To get even more value from this publication, consider becoming a paid subscriber.

Become a paid subscriber

See you soon in the next lesson.

We just finished solving six important mathematical questions to understand Quantum computing better.

• How To Check Whether A Qubit State Is Normalized?

• How To Find The Tensor Product Of Two Qubits

• How To Find The Inner Product of Two Qubits

• How to Compute the Outcome Probabilities of Quantum Measurements

• How to Find the Eigenvalues and Eigenvectors of an Operator

• How to Measure a Qubit in the Hadamard Basis

It’s now time to get hands-on and code.

Here are six questions that we will solve in the coming weeks to learn Qiskit.

If you’re new to Qiskit, it is an open-source, Python-based, high-performance software stack for quantum computing developed by IBM Research.

Let’s begin!

Question 1

Create a 1-qubit quantum circuit that:

1. Starts in the state |0>

2. Applies a Hadamard gate

3. Measures the qubit

Write the Qiskit code and simulate the circuit using a Qiskit simulator.

Question 2

Create a 1-qubit quantum circuit that:

1. Applies an X gate

2. Applies a Z gate

3. Measures the qubit

Write the Qiskit code and simulate the circuit using a Qiskit simulator.

Question 3

Create a 2-qubit circuit that prepares the following Bell state. Measure both qubits using a Qiskit simulator and show the results.

Question 4

Find the sequence of X, Y, and Z gates that transforms the quantum state |+⟩ to i|-⟩ . Verify the results using a Qiskit simulator.

Question 5

Create a three-qubit Greenberger-Horne-Zeilinger (GHZ) state in Qiskit. Measure and simulate the circuit using a Qiskit simulator.

Question 6

Create a three-qubit W-state in Qiskit. Measure and simulate the circuit using a Qiskit simulator.

If you’re completely new to Qiskit, start with these lessons and then try solving these questions.

Stay tuned for the upcoming solutions. See you soon!

In my previous post, I challenged you with six questions to help you strengthen the mathematical concepts that you need to master Quantum computing.

Let’s discuss the 6th and last question and solve it step by step using everything we have learned previously.

The question goes like this:

Given a qubit in the following state:

If we measure it in the Hadamard basis, what is the probability of obtaining |+>?

Here goes the solution.

Become a paid subscriber

We are given the following qubit:

We are asked to measure it in the Hadamard basis {|+>, |−>} which has the following basis states:

Then, we have to find the probability of obtaining |+>.

When we measure a quantum state |ψ> in a basis state |b>, we determine how much of |b> is contained in |ψ>. This is done by projecting |ψ> onto |b>.

The projection amplitude is calculated as <b | ψ>, and the probability of obtaining the outcome associated with |b> is:

In our case, this is:

Let’s first calculate <+| ψ>.

The state |+>:

In its bra form, it is written as:

From here:

Based on the orthonormality of basis states in the computational basis:

• <0|0> = 1

• <1|1> = 1

• <0|1> = 0

• <1|0> = 0

  Subscribe now

Using these values:

Given that:

This leads to:

This is the probability amplitude for obtaining the outcome |+> when measuring the given qubit.

Next, the probability of obtaining the outcome |+> when measuring the given qubit is:

This is approximately 93.3%, and this is our answer.

That’s everything for this article.

Thanks for being a curious reader of Into Quantum, a publication that teaches essential concepts in Quantum Computing from the ground up.

To get even more value from this publication, consider becoming a paid subscriber.

Become a paid subscriber

See you soon in the next lesson.

In my previous post, I challenged you with six questions to help you strengthen the mathematical concepts that you need to master Quantum computing.

Let’s discuss the 5th question and solve it step by step using everything we have learned previously.

The question goes like this:

The Pauli-Y operator is defined as:

Find its eigenvalues and corresponding normalized eigenvectors.

Let’s solve this step by step.

Subscribe now

What Are Eigenvectors?

Given a square matrix A of size n x n, an Eigenvector is a non-zero vector v that, when multiplied by A, results in a scalar multiple of itself.

Eigenvectors multiplied by A just scales (stretches or compresses) them without rotation or change in direction.

Check out the following equation. The scalar λ in this equation is called the Eigenvalue.

Eigenvalue λ represents how much the eigenvector v is scaled (stretched or shrunk) by the transformation defined by the matrix A.

where:

• A is the square matrix

• v is the eigenvector of the matrix A

• λ is the eigenvalue of the matrix A

In quantum mechanics, the square matrix A can represent Operators.

Operators are mathematical transformations that act on a quantum state to produce another quantum state.

If you’re looking for a detailed introduction to Eigenvectors, Eigenvalues, and Operators, the following lesson will help.

How to Calculate the Eigenvalues of Pauli-Y

Read more

In my previous post, I challenged you with six questions to help you strengthen the mathematical concepts that you need to master Quantum computing.

Let’s discuss the 4th question and solve it step by step using everything we have learned previously.

The question goes like this:

Given a qubit in the following state:

If this qubit is measured in the computational basis, what is the probability of observing |0>?

This one is an easy one to solve. Let’s work on it!

On the computational basis {|0>, |1>}, a qubit is expressed in the form as follows:

For our given qubit, when expressed in this form, the probability amplitude of |0> is:

The probability of observing the state |0> is the squared magnitude of this amplitude α.

This is called Born’s rule.

Similarly, the probability of observing the state |1> is the squared magnitude of the amplitude β.

Both of these probabilities sum to 1, indicating that the quantum state is normalized correctly.

This is a short but very important calculation in Quantum computing, which you must know about.

See you soon in the next lesson!

Consider becoming a paid subscriber to ‘Into Quantum’ to master Quantum Computing from the ground up.

Subscribe now

In my previous post, I challenged you with six questions to help you strengthen the mathematical concepts that you need to master Quantum computing.

Let’s discuss the third question and solve it step by step using everything we have learned previously.

The question goes like this:

Given two qubits in the following states:

Find their inner product and tell whether the two states are orthogonal.

Let’s solve it step by step.

Read more

In the last post, I challenged you with six questions to help you strengthen the mathematical concepts that you need to master Quantum computing.

Let’s move on to the second question and solve it step by step using everything we have learned previously.

The question goes like this:

Given two qubits in the following states:

Find the tensor product between these states and express the result in the computational basis.

Tensor Product Of Two Qubits

We know from previous lessons that the tensor product of two vectors/ matrices combines them into a larger matrix.

For two ket vectors:

Their tensor product is:

The given states |a> and |b> are on the computational basis as follows.

And they can be written in the vector form as follows.

Next, the tensor product between them is calculated as:

This result, on the computational basis for a system of two qubits, which is a set of four orthonormal states {|00>, |01>, |10>, |11>}, is written as follows:

I hope that you were able to solve this question by hand. See you soon in the next lesson!

Consider becoming a paid subscriber to ‘Into Quantum’ to master Quantum Computing from the ground up.

In the last post, I challenged you with six questions to help you strengthen the mathematical concepts that you need to master Quantum computing.

Let’s go to the first question and solve it step by step using everything that we have learned previously.

The question goes like this:

A single qubit is in the state:

where α = 5/3​ and β = 4(i)/ 5.

Verify if this is a valid quantum state by showing that it is normalized.

Why Normalization?

We know from the previous lessons that the following equation represents a single qubit’s state:

where α and β are complex probability amplitudes.

The squares of these amplitudes represent the probability of obtaining either |0⟩ or |1⟩ when the qubit is measured.

Normalization means that the total probability of all possible outcomes of a qubit’s state (|0⟩ or |1⟩ in this case) equals 1.

A qubit’s state must be normalized for it to be valid and make sense.

(You don’t want them to sum to 0.6, and then wonder why there’s a void of the rest of the 0.4? The world doesn’t work like that.)

Checking For Normalization

Given the qubit has the probability amplitudes as α = 5/3​ and β = 4(i)/ 5.

The square of the first probability amplitude is:

This is the probability of obtaining |0> when the qubit is measured.

The square of the second probability amplitude is:

Adding them up results in:

This is not equal to 1.

This means the qubit isn’t normalized and isn’t a valid state.

I hope that you were able to solve this question by hand. See you soon in the next lesson!

Consider becoming a paid subscriber to ‘Into Quantum’ to master Quantum Computing from the ground up.

Most concepts in Quantum mechanics aren’t intuitive and might not have macroscopic world alternatives to rely on.

For example, in the macroscopic world, observing a car does not alter its state, but in the quantum world, observing a particle does change it.

This is the reason why Quantum phenomena are best described using mathematics, rather than English.

If you’re new to this publication, I would highly recommend learning about Quantum Mechanics/ Computing from a mathematical lens.

This week, we will revisit the mathematics of Quantum Computing and solidify our understanding of it through 6 questions.

I would love it if you could solve these by hand. I will reveal detailed solutions to them in the next post on this publication.

Let’s begin!

Question 1: Normalization

A single qubit is in the state:

where α = 5/ 3​ and β = 4(i)/ 5.

Verify if this is a valid quantum state by showing that it is normalized.

Question 2: Tensor Product of Qubits

Given two qubits in the following states:

Find the tensor product between these states and express the result in the computational basis.

Question 3: Inner Product of Qubits

Given two qubits in the following states:

Find their inner product and tell whether the two states are orthogonal.

Question 4: Probability Amplitudes in Quantum Measurement

Given a qubit in the following state:

If this qubit is measured in the computational basis, what is the probability of observing |0>?

Question 5: Eigenvalues of the Pauli-Y Operator

The Pauli-Y operator is defined as:

Find its eigenvalues and corresponding normalized eigenvectors.

Question 6: Measurement Probabilities in a Rotated Basis

Given a qubit in the following state:

If we measure it in the Hadamard basis, what is the probability of obtaining |+>?

Subscribe to Into Quantum, a publication where we learn the most essential concepts in Quantum Computing from the ground up.