mod04lec24 - Fixing quantum errors with quantum tricks: A brief introduction to QEC - Part 2

Summary

This educational segment delves into the framework of quantum error correction, focusing on the three-bit quantum code that mitigates quantum bit flip errors. It explains the concept of redundancy in quantum systems, transitioning from classical bit flip channels to quantum scenarios. The script introduces the tensor product and the no-cloning theorem, emphasizing the encoding of arbitrary superpositions. It outlines the encoding process using a quantum circuit with CNOT gates, creating logical qubits or code words. The discussion then shifts to error detection, highlighting how single qubit errors transform logical states into distinguishable states, crucial for error correction in quantum computing.

Takeaways

• 📚 The script discusses the framework of quantum error correction, focusing on the three-bit quantum code which corrects for the quantum bit flip channel.
• 🧬 Quantum bit flip noise is described, affecting the basis states |0⟩ and |1⟩ with different probabilities for flipping and remaining unchanged.
• 🔗 Redundancy is introduced in quantum systems by encoding a single qubit state into a three-qubit state, expanding from a 2-dimensional space to an 8-dimensional space.
• 🚫 The no-cloning theorem is highlighted, stating that arbitrary superpositions cannot be copied directly, which complicates simple redundancy techniques used in classical systems.
• 🔄 The concept of logical qubits or code words is introduced, representing the encoded states in a higher-dimensional space, distinct from the physical qubits.
• 🛠️ The encoding process is achieved through a quantum circuit using CNOT gates, which transform the input state into an entangled state without violating the no-cloning theorem.
• 🔎 The script explains how the three-qubit code can detect single qubit errors by transforming logical states into distinct, orthogonal states that can be identified.
• 🔄 The effect of noise on the three-qubit system is considered, with the assumption that noise acts independently and identically distributed (i.i.d) on each qubit.
• 📉 The probabilities of different error scenarios are outlined, with single qubit errors being the most likely, followed by two-qubit errors, and three-qubit errors being the least likely.
• 🛡️ The three-qubit code is effective in error detection and correction by identifying the distinct states resulting from single qubit errors, which are mutually orthogonal.

Q & A

What is the main focus of the final segment of the discussion?

The main focus is on the framework of quantum error correction, using the example of a three-bit quantum code designed to correct errors caused by the quantum bit flip channel.

What is the quantum bit flip channel and how does it affect quantum states?

The quantum bit flip channel flips the quantum state with a certain probability. For example, the state ket 0 remains ket 0 with probability 1 - p and flips to ket 1 with probability p, and similarly, ket 1 flips to ket 0 with probability p and remains ket 1 with probability 1 - p.

How is redundancy introduced in quantum error correction compared to classical error correction?

In classical error correction, redundancy is introduced by replicating bits, such as replacing a single bit 0 with three 0s. In quantum error correction, the process involves replacing a single qubit, like ket 0, with a three-qubit state (ket 0 0 0), thus moving from a two-dimensional vector space to an eight-dimensional complex vector space.

Why can’t arbitrary superpositions of quantum states be directly copied using the redundancy method?

Arbitrary superpositions of quantum states cannot be directly copied due to the no-cloning theorem, which forbids copying an arbitrary superposition of quantum states. This is a key difference from classical information encoding.

What is the correct way to encode quantum information to avoid violating the no-cloning theorem?

The correct encoding maps an arbitrary superposition, such as alpha ket 0 + beta ket 1, to a coherent superposition in the three-qubit space, resulting in a state like alpha ket 0 0 0 + beta ket 1 1 1.

What is the role of unitary transformations in quantum encoding?

Unitary transformations allow quantum encoding by ensuring that the transformation from a single qubit to a three-qubit state is done in a reversible and consistent manner, preserving the superposition and quantum information.

What are logical qubits and how are they represented in the three-qubit code?

Logical qubits represent the encoded qubits in the three-qubit code. They are denoted as ket 0 with a subscript l (for logical), representing the state ket 0 0 0, and ket 1 with a subscript l, representing the state ket 1 1 1.

How does the quantum encoding circuit work to create the three-qubit state?

The quantum encoding circuit uses CNOT gates to transform the input qubit (which contains the information) and two ancillary qubits (initialized to 0) into a three-qubit state that represents a superposition, such as alpha ket 0 0 0 + beta ket 1 1 1.

What type of errors does the three-qubit quantum code focus on correcting?

The three-qubit quantum code primarily focuses on correcting single qubit bit flip errors, which are more likely than two-qubit or three-qubit errors.

How does the three-qubit code help in detecting single qubit errors?

The three-qubit code helps detect single qubit errors because the logical qubits (such as ket 0 0 0 and ket 1 1 1) transform into distinct, mutually orthogonal states when errors occur, making them distinguishable and detectable.

Outlines

00:00

🧠 Introduction to Quantum Error Correction

The segment begins with an introduction to quantum error correction, focusing on the three-bit quantum code that addresses quantum bit flip errors. It explains the quantum bit flip channel and its effect on basis states, contrasting it with classical redundancy methods. The concept of encoding a single qubit into a three-qubit state is introduced, emphasizing the need to handle arbitrary superpositions due to the no-cloning theorem. The discussion sets the stage for understanding how redundancy is introduced in quantum systems to protect against errors.

05:02

🔄 Correct Encoding of Quantum Information

This paragraph delves into the correct procedure for encoding quantum information. It explains that arbitrary superpositions cannot be simply copied due to the no-cloning theorem, and instead, a coherent superposition must be created in the three-qubit space. The concept of logical qubits or code words is introduced, replacing physical qubits with a three-qubit state. The paragraph also discusses the encoding process using unitary transformations and the significance of entanglement in this context. A quantum circuit for encoding is briefly mentioned as a way to achieve this transformation.

10:03

🔗 Quantum Circuit for Encoding

The focus shifts to the practical implementation of the encoding process using a quantum circuit. The circuit involves a data qubit carrying the information and two ancillary qubits initialized to zero. The use of the CNOT gate is highlighted as a crucial element in the circuit, which, when applied, transforms the three-qubit state into the desired superposition. The output state is an entangled state of three qubits, which is essential for error detection and correction. This paragraph provides a detailed step-by-step analysis of the circuit's operation.

15:06

🌐 Effects of Noise on Three-Qubit Code

This paragraph discusses the impact of noise on the three-qubit code, considering the independent and identically distributed (iid) assumption. It outlines the set of possible errors that can occur in a three-qubit system, ranging from no error to single, double, and triple bit flip errors. The probabilities of these errors are explained, with a focus on the likelihood of single qubit errors. The paragraph concludes by emphasizing the need to detect and correct single qubit errors, setting the stage for further discussion on error detection.

20:07

🔍 Detecting Single Qubit Errors

The final paragraph examines how single qubit errors affect the logical states of the three-qubit code. It describes the transformation of the logical zero and one states under the influence of bit flip errors, resulting in distinct and mutually orthogonal three-qubit states. The importance of these states being distinguishable is highlighted, as it allows for error detection. The paragraph concludes by emphasizing the three-qubit code's ability to detect errors, which is a critical aspect of quantum error correction.

Keywords

💡Quantum Error Correction

Quantum Error Correction is a method used to protect quantum information from errors due to decoherence and other quantum noise. In the video, this concept is central as it discusses how to correct quantum bit flip errors using a three-bit quantum code. The technique is essential for the development of reliable quantum computing systems.

💡Quantum Bit Flip Channel

The Quantum Bit Flip Channel is a quantum noise model where the quantum state of a qubit can be flipped from |0> to |1> or vice versa with a certain probability. In the script, this channel is used to illustrate the type of errors that can occur in quantum systems and how they can be addressed by quantum error correction techniques.

💡Redundancy

Redundancy in the context of the video refers to the technique of repeating information in a system to provide backup copies that can be used to correct errors. This concept is applied in both classical and quantum error correction, where the script explains how redundancy is introduced by encoding a single qubit into a three-qubit state.

💡Tensor Product

The Tensor Product is a mathematical operation that combines vectors from multiple vector spaces into a single vector space. In the script, it is used to describe how qubits are combined in a quantum system, particularly when encoding a single qubit into a three-qubit state for error correction.

💡No Cloning Theorem

The No Cloning Theorem states that it is impossible to create an identical copy of an arbitrary unknown quantum state. This theorem is mentioned in the script to explain why simple redundancy by copying quantum states is not possible and why more sophisticated encoding methods are required for quantum error correction.

💡Unitary Transformations

Unitary Transformations are a type of linear transformation that preserves the inner product in quantum mechanics. They are used to describe quantum operations, including the encoding process in quantum error correction. The script explains how the encoding of quantum information is achieved via unitary transformations.

💡Logical Qubits

Logical Qubits are a concept introduced in the script to represent the encoded quantum states within a quantum error correction code. They are distinct from physical qubits and are used to show how information is preserved across multiple physical qubits, allowing for error detection and correction.

💡Code Words

Code Words in the context of quantum error correction refer to the specific states that represent logical qubits within an error correction code. The script uses the terms '0l' and '1l' to denote the logical zero and one states, which are encoded as specific three-qubit states.

💡Entanglement

Entanglement is a quantum phenomenon where the state of one particle is dependent on the state of another, even when separated by large distances. The script mentions entanglement as a key resource for quantum error correction, particularly in the context of the three-qubit code.

💡IID (Independent and Identically Distributed)

IID refers to the assumption that errors in quantum systems occur independently and with the same statistical distribution. This assumption is crucial for the analysis of error correction in the script, as it simplifies the modeling of noise in quantum systems.

💡Error Detection

Error Detection is the process of identifying that an error has occurred in a quantum system. The script explains how the three-qubit code allows for the detection of single-qubit errors by transforming logical states into distinct, orthogonal states that can be measured and distinguished.

Highlights

Introduction of quantum error correction using a three-bit quantum code to correct for quantum bit flip channel.

Explanation of the quantum bit flip noise: ket 0 remains ket 0 with probability 1-p and flips to ket 1 with probability p, and vice versa for ket 1.

Redundancy is introduced by replacing ket 0 with three ket 0s and ket 1 with three ket 1s in a three-qubit system, creating an 8-dimensional vector space.

No cloning theorem prohibits naive replication of arbitrary superpositions, preventing direct copying of quantum states.

Correct encoding procedure involves mapping alpha |0⟩ + beta |1⟩ to a coherent superposition: alpha |000⟩ + beta |111⟩.

Logical qubits are introduced, represented as logical 0 (|000⟩) and logical 1 (|111⟩), forming the basis for encoding.

Unitary transformations, particularly the use of CNOT gates, are applied to transform and encode qubits.

Encoding circuit uses CNOT gates to entangle the qubits, creating a coherent superposition state.

Single qubit bit-flip noise model explained: noise acts independently on each qubit, with identity or X errors occurring on one or more qubits.

Eight possible error states are identified, including identity, single qubit, two qubit, and three qubit bit flip errors, with varying probabilities.

Focus on detecting and correcting single qubit errors, as they are the most probable type of error.

Single qubit errors transform logical states (|000⟩ and |111⟩) into distinct and mutually orthogonal three-qubit states.

Orthogonality of error-transformed states enables distinguishability, making error detection possible.

Entangled states play a key role in quantum error correction, highlighting the importance of entanglement in error resilience.

The three-qubit code allows for error detection by transforming quantum states into distinct, orthogonal forms that can be measured and corrected.

Transcripts

[Music]

okay in this final segment we will now

discuss

the framework of quantum error

correction the technique of quantum

error correction using the simple

example of

the so called

three bit

quantum code

which

corrects for

the

quantum bit flip channel

so recall

in the last segment we had introduced

the idea of the quantum uh the quantum

bit flip channel right and

this was the effect of the channel

uh on the basis states that is sched0

and ket one remember that under the

action of the quantum bit flip noise cat

0 would remain kept 0 with probability 1

minus p and k 0 would flip to get 1 with

probability p

similarly get 1 would flip to get 0 with

probability p and it would remain

get 1

with probability 1 minus p

right

so this is the

single

quantum bit flip channel so

recall what we did for the classical

case where we said that we need to that

one way of dealing with big flip errors

would be to introduce redundancy so how

do we introduce redundancy

well this is the simplest thing to do

right which is to take cat 0

right

and

replace it with

let's say three

cad zeros

in the quantum case what does this

entail remember catch 0 is a state which

lives in a 2 dimensional

so this belongs to

c 2 which is a 2 dimensional complex

linear vector space

but now this becomes

a 3 qubit state

right and this is something which

belongs to

three

two dimensional complex linear vector

spaces so the whole thing is actually an

eight dimensional space

it's an eight dimensional complex linear

vector space or two to the three

dimensional complex linear vector space

right

similarly we can now think of

replacing the cat one

by

three cat ones

so when i write these three cat zeros

there is an implied tensor product here

so this

symbol denotes what is called a tensor

product

again we will not get too much into the

details of this but the idea is that

when you're putting together

multiple quantum systems and remember

we've spoken about

um multi-party multi-qubit systems in

week two right so this is essentially a

three qubit system

right and we are replacing a single

qubit system with a three qubit system

right and this

is how we would introduce redundancy or

how we would do the

encoding

right so we

replace the single cat 0 with three cad

zeros we replace the single cat one with

three kit once but now the question is

what happens to an arbitrary

superposition in the classical case this

was sufficient right a single zero

replaced by three zeros a single one

replaced by three ones but now arbitrary

superpositions of zero and one are

allowed in the quantum case so what do

we do with alpha zero plus beta one

can we do this operation where alpha

zero plus beta one

now becomes

we replace this by

alpha zero plus beta one

we replace this by alpha 0 plus beta 1

on 3 qubits

well this is the kind of operation that

is forbidden

by

the no cloning theorem

the point is that this can be an

arbitrary superposition any possible

superposition of 0 and 1 could occur in

our computation so when we encode

quantum information you're not just

encoding the ket 0 and the ket one

rather you have the you need to have the

ability to encode an arbitrary

superposition of get 0 and get 1 not a

fixed superposition if i am always going

to have only a fixed

state of the form 1 over root 2 0 plus 1

over root 2 1 which is the plus state

then of course i can find ways of making

three plus states on three different

qubits

but now we're talking about encoding

arbitrary superpositions

and this cannot happen in this naive way

of making three copies of an arbitrary

superposition arbitrary superpositions

cannot be copied this is forbidden by

the no cloning theorem which was

discussed in week two

so how do we work around this

so here's the way to work around it so

the correct way to encode

so

so let me call this the correct

encoding

procedure

is actually

that alpha 0 plus beta 1

gets mapped to alpha

0 0 0

plus

beta

1 1

1.

so we make a coherent superposition so

this is what i would call a coherent

superposition

right so we make

the same coherent superposition

in the three qubit space

and the claim is that this can somehow

happen

via unitary transformations because

remember what we are allowed to do

the gates that we are allowed to do are

all unitary transformations right so how

do we do this how can we

do this encoding procedure in a unitary

way i'll just show you the circuit but

before that i want to note that what we

are doing is actually replace

our

physical qubits

which are the single qubits

0 and 1

right

and in their place

we are introducing

the idea

of logical qubits

right

which i will now denote as 0 with a

subscript l and a ket 1 with a subscript

l

where

the 0 with the subscript l is simply

the 3 qubit state 0 0 0

and the one with the subscript l is the

three qubit state 1 1 1

right

if you want to quickly recall

what these three qubit states look like

remember

that get 0 suppose was denoted by the

column vector 1 0

so

if get 0 is this

then

this 3 qubit state

is simply

this outer product or tensor product

right

and

this

becomes an 8

dimensional vector

of the form

right because this

this outer product gives me a 4

dimensional vector column vector 1 0 0 0

and

taking the outer product again with

another one zero gives me

this eight dimensional column vector

with just one one and all zeros

similarly you can write down the state

corresponding to the three ones as an

eight dimensional column vector with all

zeros and just one one sitting at the

last entry right so this is what our

encoded

state looks like

okay and the other terminology that i

would like to introduce here is these

logical qubits are also called

code words

okay and just like how the single qubit

state lives in a two dimensional vector

space that is spanned by zero and one

our encoded states or logical states or

logical qubits live inside a two

dimensional space that is spanned by

zero logical and one logical and hence

an arbitrary superposition of the form

alpha zero plus beta one is to be

replaced by the encoded superposition

which is alpha zero zero zero plus beta

one one one

and now we address the question of how

do we actually realize

this encoding so i'm going to show you

the encoding circuit

while we show the encoding simply as

a map from

a single qubit state to

this

three qubit state

the fact that this is unitarily realized

means that this is actually a map or a

transformation from three qubits to

three qubits so it's actually a circuit

with three input qubits and three output

qubits right so the idea is

the first qubit is the qubit that is

carrying the information in the form of

the superposition

the second qubit

and the third qubit are

what are called

ancillary qubits or

ancillar qubits

these are additional qubits which are

initialized to zero

and then unitarily this three qubit

state is transformed to this

superposition

and the way this is done is basically

using a very important gate

namely the c naught gate okay so this is

what the circuit looks like

i have

three registers

the first qubit is

in the state alpha zero

the other two

are the

ancillar qubits

the first qubit is what we often call

the data qubit

because that is the one that contains

the information which is to be encoded

and now how do we proceed with the

circuit

well we simply apply a pair of c naught

gates

and the claim is that this output state

is now of the form

alpha 0 0 0

plus

beta 1 1 1.

so let's quickly check that so what

happens after the action of the first c

naught

so let's do this circuit analysis step

by step so after the first c naught

we have the three qubit state

alpha zero plus beta one

tensor

remember that the c naught gate flips

the target so this is the control and

this is the target and the c naught gate

flips the target whenever the control is

1. so

this becomes

alpha 0 0

plus

beta 1 1.

tensor get zero

right and this is the third ancillar

qubit the second nonselective rather the

third qubit in the circuit

and

after the second c naught

we end up with the state

now this zero gets flipped whenever the

second qubit is set to one the second

qubit has become the control qubit and

whenever the second qubit is one this

qubit has to get flipped so this becomes

alpha

0 0 0

plus

beta

1 1 1

as

desired right so this from just the

state some arbitrary state psi this has

become the logical state side

right so

this is the final state that we want and

this is how we've achieved the encoding

and we've achieved the encoding in a via

a quantum circuit right so this

is the encoding circuit for the three

qubit uh code

right

okay so now how does this help us

of course one final point to note is

that this final state that we have

written out here

this

alpha 0 0 0 plus beta 1 1 1 is actually

an entangled state

since we have introduced the idea of

entanglement briefly in week 2 this is

an entangled state

of

three qubits

right

and this is where entanglement comes to

our rescue

we will now look at what happens to the

state under the action of noise

okay so now that we've gone from a

single qubit to a three qubit scenario

what can we say about the noise so we

now have to look at

the properties of the

three qubit code

first of course we recall the assumption

that we make this was the assumption

that was made even in the classical case

that the noise is iid

right what does this mean this means

that the noise acts independently

so the noise acts independently on each

qubit

and second it is

identically distributed

which means that the error probabilities

are the same for every qubit

so in the single qubit case remember

that

for the single qubit bit flip noise

we could describe it in terms of

two operators right there was either the

x operator which happened with

probability p

and this is what we said you have the x

error with probability p or you have

identity

with probability 1 minus p

okay

but now

you have 3 cubit bit flip noise

so

what are the set of possible errors

now on each qubit you could have either

identity or x

right which means that you have a set of

eight possible errors now so what are

these eight possible errors we can write

them all down

right so you could have identity on all

three qubits and again i'm going to

denote this

by tensor product sometimes we can just

drop the tensor product and write this

as three identities because remember the

noise is acting independently on every

qubit

you could have

a single x error on the third qubit

you could have

a single x error on the second qubit

and you could have a single x error on

the first qubit

now these errors all occur with

probability p

right so these three errors which are

all the

so called so this set is what we would

call the set of

single qubit errors right because this

basically says there was an x error on

the third qubit or the second qubit or

the first qubit but only on one qubit

right so these are the set of single

qubit errors all of which occur

with probability

p

right

but the set of errors doesn't stop here

it is not simply identity or single

qubit errors you can of course have two

bit flip errors so let's complete the

set of errors now

so the set of errors continues we can

now have two bit flip errors so let's

say you could have error

on the second and the third qubit

you could have error on the first

and the second qubit

and you could have errors on the first

and the last two qubits right and this

set of errors is what we would call

the set of

two qubit

errors because now you have big flips

occurring on

two qubits and these occur

with probability order p squared right

and finally we also have the

three qubit error which is the x error

occurring on all three qubits so this is

what we would call the

three qubit error

and this occurs with probability order p

q

and this completes

our set of errors for the three qubit

bit flip channel right this was of

course also the case in the case of the

classical

bit flip error right and like in the

classical case we are now going to argue

that

the single qubit errors are more likely

than the two qubit which is more likely

than the three qubit and so we are only

going to focus our attention on

correcting first of all detecting and

correcting the single qubit with flip

errors right so we're going to focus our

attention only on the single qubit

errors

and like we said there's three of them

right and then of course there's a

possibility that the qubit remains

unaffected

by the error and this occurs with

probability 1 minus p so just to

complete i must say that this occurs

with probability

1 minus p the whole q

right and you can of course check that

the sum of all these probabilities must

um sum to 1

right so i have 3 p squared here i have

1 p cube here and then i have 3 here

right okay

fine

so now how do we detect or how does this

three qubit encoded state help us detect

the single qubit errors so the next

thing to look at is what how do the

single qubit errors affect the so the

what is the effect of

the single qubit

errors

well so let's look at the

let's actually look at just the basis

states right the logical states or the

code words so let me only look at

the logical states

sorry the logical

cubit

states

0l

which is

0 0 0

and

1l

which is 1 1 1.

so what happens to 0 0 0 under the

action of the single bit flip errors

well the third qubit could get flipped

so

this

could become this

i could have the second qubit

getting flipped

so

this would become this

and i could have

the first qubit getting flipped

so these are the possible output states

after the action of the single qubit

error

on

the zero zero zero state or the logical

zero state similarly we can work out

what happens to the logical one state

and again

i could have the third

qubit getting flipped to a zero i could

have the middle qubit getting flipped to

a zero or the first qubit getting

flipped to a 0. note that i am not

explicitly writing the tensor product

here but it is implied everywhere ok

so these are the set of possible states

now what do we notice about these states

like in the case of the classical

three bit

the classical three bit code

the 0 0 0 and the 1 1 1 are getting

mapped to distinct states right so this

state corresponds to a classical bit

string 0 0 1 this corresponds to 0 1 0

and this corresponds to 1 0 0

1 1 0 1 0 1 0 1 1 so all of them are

basically distinct

states

in the

three qubit space

they're all distinct three qubit states

and therefore exactly like in the case

of the classical bit flip code or the

classical repetition code

this set of six states can be

distinguished and detected so

let me just note this point that

the

single qubit errors

transform

the

logical states

that's the logical zero and the logical

one

to

distinct

this very important

three qubit states in fact

this set of three qubit states that i

have marked here are actually all

mutually orthogonal

right because they correspond to

distinct states their distinct bit

strings right so they are mutually

orthogonal which means if i take the

inner product between this three

qubit state with any of the other three

qubit states i get zero

and because they are mutually orthogonal

they are distinguishable

okay

so this is the key property of the three

qubit

code which helps us in error detection