🎁 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 orthonormal 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.

This week’s newsletter is written by Serena Krejci-Papa from .

She is an author who transforms complex topics in quantum science, physics & chemistry into compelling stories for all audiences.

She graduated from Case Western Reserve University with a B.S. in Chemistry and is currently pursuing my masters in Theoretical and Computational Chemistry in the Erasmus Mundus Joint Master Program in Barcelona.

Follow and connect with her through the links below:

• Website

• LinkedIn

• Substack newsletter

• Medium blog

Let’s get started!

Wait!

Before you call me a nerd and click out of this article because I said linear algebra, hear me out.

Linear algebra is more than just a type of math; it’s the secret to the wonder and uniqueness of all the subjects you know and love, like quantum mechanics, machine learning, artificial intelligence, or computer science.

That’s right!

Linear algebra was the first person to be nice to these guys on freshman orientation day, and now they’re inseparable. So, if you want to get to know one, you’re going to have to get to know the other.

Relax. In the end, they’ll both be your friends.

Let’s get into it.

Why Linear Algebra?

Linear algebra is like algebra except we perform operations with lines and multi-dimensional spaces instead of 2D points on a grid.

It’s extremely cool and an extremely powerful mathematical lens we can use to make sense of the world when it doesn’t make sense.

For example, it can explain why electrons don’t behave like tennis balls.

Tennis balls can be modelled with continuous, single-valued functions because they behave like continuous single-valued functions: they go up, make an arch, and then come back down.

They never disappear and reappear somewhere else, or exist in two places at once.

Since we can see this behavior with our eyes, it’s only natural to presume that the entire world works like this, with continuous, single-valued functions.

Electrons don’t follow this rule.

They don’t release energy continuously like a tennis ball, but release energy in discrete values at specific but random intervals that are different every time. There is some rhyme and reason to it, but only the fact that some discrete energy values are more likely than others.

What function can describe this?

Functions — hell no, but linear algebra — hell yes!

Linear Combinations

Linear combinations are a concept in linear algebra and the perfect mathematical tool to represent an electron.

They can represent one state as a combination of many, which is exactly what we need. Here’s what it looks like:

While that may look a tinge confusing now, it’s a concept you’re already familiar with.

Think of linear combinations like a compass: by labeling four directions or “states,” we can get anywhere we want to go.

Here are our states:

And here are some possible combinations:

If we wanted to get more specific, we could do so as well.

That’s what the little letters up front are for. If we replace them with percentages, we can know exactly how much more of one direction we need than the other.

Linear Combinations for Electrons

We can use the same idea for our electron’s energy states. Instead of considering our electron as one continuous release of energy, like a tennis ball, we can represent it as a combination of all the energy states it is likely to have.

Let’s call the total energy E and the energy states it can have E₁, E_2, and E₃.

To take care of the randomness problem, we can simply follow the same approach as we did for the compass. We put a little percentage up front that lets us know how likely each energy value is.

Since those are constants and we don’t know what they are yet, we can call them a₁, a₂, and a₃. They are also called Coefficients.

Finally, our electron needs to have discrete energy values. We need a mathematical tool that converts them into physical quantities, but allows us to count only specific numbers.

How about… Matrices?

Matrices are fancy tables that let us turn one set of numbers into another. They work to represent an electron’s energy states because only certain outcomes are allowed (which makes them discrete).

There’s a bit more to them, but that’s all you need for now.

Put it all together, and what do we get? An accurate representation of an electron!

The Best Part

Linear algebra is so important because it’s not just how we do quantum mechanics, but it is quantum mechanics.

What you might know as superposition is really just a linear combination of an electron’s energy states.

That’s also why it’s so important to learn the fundamentals of linear algebra if you want to dive into any of the subjects I mentioned at the beginning.

Machine learning, quantum mechanics, or computer science will become a lot easier once you know what they’re built on.

That’s because, just like in life, the answer to your problems usually isn’t in what you’re looking at, but how you’re thinking about them.

Alright, that’s enough philosophy from me. I’ve got science to do.

See you next time!

I want to thank Serena again for writing this valuable article!

Don’t forget to subscribe to by .

The Quantum Notebook

Covering interesting news, science topics, and a lot of quantum physics.

By Science with Serena

Unlock access to every article on ‘Into Quantum’ by becoming a paid subscriber:

Join today

Hope you’re doing well!

I’ve got some good news for you.

As you’re already part of my incredible community, I wanted to offer you an additional 10% discount on my Visual Tech bundle.

You know how learning technology can feel overwhelming sometimes?

Well, this bundle is designed to make it simple and visual, just the way your brain loves to learn.

Here’s what you get:

• 4 Tech learning visual guides that actually make sense

• Instant access to everything

• Also, no PhD required (I promise!)

Just head over to the following link and you’re done!

https://bamaniaashish.gumroad.com/l/visualtech/VISUALTECH10

This extra discount is only available for the next 24 hours, so don’t miss out!

Cheers,
Ashish

Superdense coding is a fascinating quantum communication protocol.

It involves transmitting two classical bits of information using only one qubit.

This is very different from classical computing, where if you want to send 2 bits of information, you will need to transmit 2 bits through a channel.

Read more