mod04lec25 - Fixing quantum errors with quantum tricks: A brief introduction to QEC - Part 3

Summary

This script delves into quantum error correction, focusing on the three-qubit code's ability to detect and correct single qubit bit flip errors without collapsing the quantum state. It explains the use of ancillary qubits and the concept of syndrome bits for error diagnosis. The script outlines the complete circuit for encoding, error detection, and correction, emphasizing the importance of fidelity in quantum computation. It also touches on the physical resource requirements for fault-tolerant quantum processors, highlighting the progression from noisy intermediate-scale quantum devices to scalable, error-corrected quantum computing.

Takeaways

• 🧠 The discussion focuses on quantum error detection and correction, specifically for single qubit errors on a three-qubit state.
• 🔍 Error detection is crucial for quantum computing as it allows for the identification of errors without collapsing the quantum state.
• 📊 A majority voting or parity check mechanism is used to detect errors, which involves measuring in the 0-1 basis on ancillary qubits.
• 🛠️ The error detection circuit includes three encoded qubits and two ancillary qubits, with the latter initially set to zero.
• 🔄 The CNOT gate is used in the circuit to maintain the superposition of the state, aiding in the error detection process.
• 📉 Syndrome bits, derived from measurements on the ancillary qubits, indicate the presence and location of errors.
• 🔧 Error correction involves applying an X gate to the affected qubit based on the syndrome bits, effectively reversing the error.
• 🔑 The three-qubit code can detect and correct for single qubit bit flip noise, improving the fidelity of quantum states.
• 💾 Quantum error correction requires physical resources, with at least 49 physical qubits needed for one error-corrected logical qubit using a seven-qubit code.
• 📈 The current era of quantum computing involves noisy intermediate-scale quantum devices, with the goal of scaling up to fault-tolerant, error-corrected quantum computation.

Q & A

What is the primary goal of quantum error detection?

The primary goal of quantum error detection is to identify the presence of errors without collapsing the quantum state, allowing for the extraction of information about the error's presence and location to reverse its action.

Why is it important to know the location of an error in quantum error detection?

Knowing the location of an error is crucial to reverse the error's action effectively. Without this information, it would be impossible to correct the error accurately.

What role do ancilla qubits play in quantum error detection?

Ancilla qubits are used in the error detection process to help identify errors without directly measuring the data qubits. They are initially set to zero and are used in conjunction with CNOT gates to detect errors through parity checks.

How are syndrome bits generated in the error detection process?

Syndrome bits are generated through measurements of the ancilla qubits in the Z basis. These classical bits act as parity check bits, indicating which qubit was affected by a bit flip error.

What is the significance of the syndrome table in quantum error detection?

The syndrome table is significant as it maps the outcomes of the syndrome bits to specific error patterns, allowing for the identification of the type of error and the qubit it occurred on, which is essential for error correction.

How does the three-qubit code correct for single qubit errors?

The three-qubit code corrects for single qubit errors by using a syndrome table that corresponds to different error operators. Depending on the syndrome, an X gate is applied to the appropriate qubit to correct the error.

What is the relationship between fidelity and quantum error correction?

Quantum error correction can improve fidelity, which is a measure of how close the final state is to the initial state. Higher fidelity implies better preservation of the quantum state against noise.

What is the minimum number of physical qubits required for one error-corrected logical qubit?

At least 49 physical qubits are required for one error-corrected logical qubit when using a seven-qubit error-correcting code, which is more amenable to fault tolerance techniques.

What is the current state of quantum devices in terms of qubit count and error rates?

As of the script's knowledge, we are in an era of noisy intermediate-scale quantum devices with around a hundred qubits, but with error rates still above the threshold required for error-resilient computation.

What is the significance of the quantum volume metric in the context of quantum computing?

Quantum volume is a metric that combines the size of the circuit, the connectivity of the qubits, and other factors to indicate the power of a quantum computer. It is used to gauge progress beyond simple qubit count, aiming to reflect the ability to perform complex quantum computations.

Outlines

00:00

🛠️ Quantum Error Detection and Three Qubit States

The paragraph discusses the process of detecting quantum errors without collapsing the quantum state. It emphasizes the importance of identifying the location of an error to reverse its effects. The speaker introduces six three-qubit states and explains that error detection involves measuring in the 0-1 basis, or the Z basis, using ancillary qubits. The error detection circuit is described, involving pairs of CNOT gates from data qubits to ancillary qubits, which are initially set to zero. The speaker explains that the CNOT gates do not alter the superposition of the state, and that the measurement outcomes, referred to as syndrome bits, indicate the presence and location of errors.

05:02

🔍 Analyzing the Error Detection Circuit

This section delves into the analysis of the error detection circuit. The speaker hypothesizes a bit flip error on the first qubit and explains how this error would affect the parity of the qubits. The role of CNOT gates in detecting such errors is highlighted, showing how they trigger bit flips in ancillary qubits based on the parity of the data qubits. A syndrome chart or table is introduced as a method to map the classical outcomes of measurements to specific errors. The speaker outlines how different syndrome bit values correspond to errors in different qubits and explains the correction process, which involves applying an X gate to the affected qubit.

10:02

🔗 Completing the Quantum Error Correction Circuit

The speaker outlines the complete process of quantum error correction, starting from encoding the qubits to detecting and correcting errors. The process involves starting with an arbitrary single qubit state, applying CNOT gates for encoding, and then introducing noise through a bit flip channel. The noisy qubits are then subjected to the error detection and correction process using additional ancillary qubits and CNOT gates. The outcomes of measurements on these ancillary qubits guide the application of X gates for error correction. The paragraph concludes by emphasizing that this process corrects for single qubit errors, improving the fidelity of quantum computations.

15:03

📈 Quantum Error Correction and Fidelity

This paragraph discusses the broader implications of quantum error correction, particularly its role in enhancing the fidelity of quantum computations. The speaker notes that the three qubit code can correct for single qubit bit flip noise, improving coherence time provided the noise parameter is small. The discussion extends to different types of errors, such as phase flip and amplitude damping, and how they can be corrected using extended codes like the nine qubit code. The speaker also introduces the concept of fault tolerance and concatenation, which are techniques used to further reduce error rates and achieve a fault-tolerant quantum processor.

20:04

🚀 Roadmap to Fault-Tolerant Quantum Computation

The final paragraph provides an overview of the current state and future prospects of quantum computing. The speaker references the Google roadmap from 2018, highlighting the transition from noisy intermediate scale quantum (NISQ) devices to fault-tolerant quantum computation. The speaker discusses the progress in terms of quantum volume, a metric that captures the size and error resilience of quantum devices. The goal is to scale up to thousands of qubits to achieve fault tolerance and robust, scalable quantum devices. The speaker concludes by emphasizing the ongoing efforts to improve quantum volume and the anticipation of achieving higher quantum volumes in the coming years.

Keywords

💡Error Detection

Error detection in the context of the video refers to the process of identifying the presence of errors in quantum computing without collapsing the quantum state. This is crucial for quantum error correction, as it allows for the diagnosis of errors that have occurred during computation. The video discusses how error detection is achieved through the use of ancillary qubits and parity checks, which help to identify the location of errors without disturbing the encoded state. For example, the script mentions, 'the point is, we need to know where the error occurred, in order to be able to reverse the action of the error.'

💡Qubit

A qubit, short for quantum bit, is the fundamental unit of quantum information. Unlike classical bits that can be either 0 or 1, qubits can exist in superpositions of states, allowing quantum computers to perform complex calculations. The video script discusses how errors in qubits can occur and how these errors are detected and corrected, such as 'the action of the single qubit errors on the encoded state or the three qubit state'.

💡Encoded State

In quantum computing, an encoded state refers to a quantum state that has been prepared using quantum error correction techniques to protect it from errors. The script describes how qubits are put into an encoded state using the three-qubit code, which is designed to detect and correct for bit flip errors. The concept is illustrated when the script says, 'so the next step is to look at error detection, we have looked at the action of the single qubit errors on the encoded state or the three qubit state'.

💡Ancillary Qubits

Ancillary qubits are additional qubits used in quantum error correction to assist in the detection and correction of errors. They are not part of the original data but are used to perform operations that help identify errors without disturbing the main qubits. The video explains how ancillary qubits are used in the error detection circuit, as stated, 'we must measure each qubit in the 0 1 basis, and like I said the key point is that the measurement is not done on the data qubits itself but rather on two additional qubits called the ancillary qubits'.

💡Bit Flip Error

A bit flip error is a type of quantum error where the state of a qubit is flipped from 0 to 1 or vice versa. This is a common type of error in quantum computing that can lead to incorrect computation results. The video script discusses how bit flip errors are detected and corrected using the three-qubit code, with the script stating, 'if there was an error on the first qubit you notice that the 0 0 0 has become 1 0 0 and the 1 1 one has become a zero one one'.

💡Parity Check

In the context of the video, a parity check is a method used to detect errors by examining the even or odd number of 1s in a set of qubits. This is a key part of the error detection process in quantum computing, as it helps to identify whether an error has occurred without collapsing the quantum state. The script describes this process, noting 'there is a majority voting or a parity check element that comes in'.

💡Syndrome Bits

Syndrome bits are classical bits that result from measurements made during the error detection process in quantum computing. They provide information about the presence and type of errors in the quantum system. The video script explains how syndrome bits are used to determine which qubit was affected by a bit flip error, as indicated by 'these classical outcomes are called syndrome bits, because these classical syndrome bits are essentially the parity check bits, which tell us exactly which error occurred'.

💡Error Correction

Error correction in quantum computing is the process of identifying and fixing errors that occur during quantum computation. The video script describes how error correction is achieved through the use of a syndrome table and the application of X gates to correct bit flip errors. The script mentions, 'this syndrome table essentially captures the fact that the different single qubit errors can be distinctly identified and they can be fixed by the simple application of an X gate on one of the three encoded qubits'.

💡Fidelity

In quantum computing, fidelity is a measure of how closely the final state of a quantum system matches the intended state. High fidelity indicates that errors have been successfully corrected. The video discusses how quantum error correction can improve fidelity, which in turn implies an improvement in the coherence time of the physical qubits. The script states, 'quantum error correction can improve fidelity, and this in turn implies that it can improve the coherence time of the physical qubits'.

💡Fault Tolerance

Fault tolerance in quantum computing refers to the ability of a quantum system to continue operating correctly even when some of its components fail. The video script mentions the theory of quantum fault tolerance, which is necessary to deal with faulty gates and circuits in a real quantum processor. The script points out that 'the next step is to talk about fault tolerance, so in order to deal with faulty gates and circuits we have the theory of quantum fault tolerance'.

Highlights

Introduction to error detection in quantum computing without collapsing the state

Explanation of the need for error detection to know the location of errors for reversal

Discussion on the use of majority voting or parity check in three qubit states for error detection

Emphasis on measuring in the 0 1 basis for detecting X errors in quantum states

Description of the role of ancillar qubits in error detection circuits

Circuit diagram explanation for error detection using ancillar qubits

Analysis of how the circuit handles different types of bit flip errors

Introduction to syndrome bits as classical outcomes of measurements for error detection

Construction of a syndrome table to map error detection to specific qubit errors

Explanation of how to correct errors by applying an X gate based on syndrome results

Overview of the complete circuit for encoding, detecting, and correcting errors in a three qubit code

Discussion on the limitations of error correction to single qubit errors

Importance of the noise parameter being small for effective error correction

Introduction to the concept of fault tolerance in quantum computing

Exploration of the physical resource requirements for implementing quantum error correction

Discussion on the transition from noisy intermediate scale quantum devices to fault-tolerant quantum computation

Presentation of the Google and IBM roadmaps for scaling up quantum devices

Conclusion on the current state and future prospects of quantum error correction

Transcripts

[Music]

so the next step is to look at error

detection

we have looked at

the action of the

single qubit errors

on the encoded state or the three qubit

state

so the next step is to ask how do we

detect these errors in a way that the

state doesn't collapse but still we are

able to extract information about

the presence of the error the point is

we need to know where the error occurred

in order to be able to

reverse the action of the error right so

how do we know where the error occurred

now look at these six

three qubit states

you notice that once again there is a

majority voting or a parity check

element that comes in right so

but now notice that the measurement that

i need to do as far as the quantum

states are concerned is actually a

measurement in the 0 1 basis so this is

the first thing to note that if i want

to detect x errors

note

that

we must measure

in the so called z basis

or

the 0 1 basis so we must measure measure

each qubit

in the

0 1 basis

and like i said the key point is that

the measurement is not done on the

data qubits itself uh on the encoded on

the three encoded qubits but rather on

two additional qubits called the

ancillar qubits so here is what the

error detection circuit looks like

so we have the three

encoded qubits and then we have two

additional lines

to denote the ancillar qubits

and these ancillar qubits are initially

set to

zero

okay

so here what we have is some arbitrary

superposition of the form

alpha zero zero

plus beta 1 1

1

right so this is what the circuit looks

like it basically entails

pairs of c naughts i'll describe the

circuit first and then we'll see how

it achieves our goal of error detection

so i have a pair of c naughts from the

first two qubits

to the first ancillar qubit and then

i have another pair of c naughts to the

second ancillar qubit coming from the

second and the third

data qubit so essentially the first two

data qubits act as control for the first

two c naughts and the second two data

qubits sorry

act as control

for the

second two c naughts

two c naughts on the first ansel are

qubit

with the first two data qubits as

controlled and two c naughts on the

second ancillar qubit with the second

and third data qubits as control now

notice that the c naught being a two

qubit unitary gate does nothing to the

superposition so this state continues to

remain

as

um actually i should not say 0 0 plus

beta 1 1 1 this could be some noisy

version of 0 0 0 plus beta 1 1 so this

could be a state with say a bit flip

that has occurred in the second qubit or

a big flip that has occurred in the

third qubit and so on right so this

state remains whatever it is

right so let me not write this as an

as an

error free state but some

encoded state so i will say encoded

noisy state

right

and this state continues to remain what

it is so if i call this

maybe psi

logical to denote that this is an

encoded state this continues to remain

psi logic

now what we do with the two ancillar

qubits well we perform a measurement

we perform two measurements both of them

in the z basis

okay

and this leads to

some classical bits right so let me call

this as

s1 and s2

classical outcomes of these two

measurements and these classical

outcomes

are called syndrome bits

because these classical syndrome bits

are essentially the parity check bits

which tell us exactly which error

occurred or rather which qubit was

affected by the bit flip error

so let's analyze the circuit now suppose

there was a bit flip error on the first

qubit right so let me mark this

let me say that there was an error on

the

first qubit right

so then what happens

uh

well let's go back here right

and see

so if there was an error on the first

qubit you notice that the 0 0 0 has

become 1 0 0 and the 1 1 one has become

a zero one one right so this is the

possibility that we are talking about

this one right

so in this case you notice that the

parity of the first two qubits is odd

right but the parity of the second two

qubits is even

so

that's what these c naughts are doing

for us so if either of the first or the

second qubit

has undergone a bit flip

then one of these c naughts gets

triggered one of these two c naughts of

the on the first two qubits gets

triggered and correspondingly the first

ancillar qubit undergoes a bit flip so

this

then undergoes a bit flip

similarly if one of the second two

qubits underwent a bit flip then the

second ancillar qubit will undergo a bit

flip

so either the first ancillar qubit or

the second ancillar qubit undergoes a

bit flip depending on whether the first

two qubits underwent a bit flip or the

second two qubits underwent a bit flame

and so we can actually make a table

right so we can do this where we can

make what is called a syndrome chart or

a syndrome table

right

where

we write down the values of the

classical outcomes s1 and s2 so s1 and

s2 are both

bits right so they cannot be 0 or 1. so

what happens if s1 and s2 are both 0

well this implies that neither of the

two ancillar qubits got flipped right

because both continue to be zero

and this can only happen if

both pairs of qubits the first two

qubits and the second two data qubits

continue to have even parity which means

even number of zeros and ones

right and this can only happen in the

case that there was no noise so if both

syndrome bits

are zero then the diagnosis

is that there are there was no

error right

this is the case where all three of them

simply got acted by the identity

operator

now if the first syndrome bit

has flipped but the second one has not

what it means is that there was an error

only somewhere in the first two qubits

but none in the second pair of qubits

and so the error must be on the first

qubit so this means

that there was a bit flip

on

the first qubit

so this is basically the error operator

x i i

right and once you detect this what do

you do you simply reverse for it by now

acting an x gate on the first

data qubit of the first encoded qubit

similarly if the syndrome was 0 1 then

that implies a bit flip

on the

third qubit

which is corresponding to the error

operator iix

why is this because this means that

there was no error on the first two

qubits there was an error on the second

pair of qubits and that's why the second

ancillar qubit has gotten flipped so

this again means that the second qubit

is unaffected but is the third qubit

that is affected and finally you could

have the possibility that both syndrome

bits

are one which means the outcomes of both

the z measurements at the end on the

ancillars are one in which case there

must have been a bit flip

on

the first pair and the second pair which

then means a bit flip on the second

qubit alone right

and this corresponds to the error

operator i x i

so while i am writing correspondingly

the error operator here note that this

is also the recovery operator in the

sense that if there is no error

then

what is the correction procedure involve

nothing you just do identities do

nothing right so this last column what

i'm writing here is actually in some

sense the

recovery or the correction operation

right

so

if there's a bit flip on the first qubit

you simply apply an x on the first qubit

if there's a big flip on the third qubit

you apply a x on the third qubit and

there's a bit flip on the second qubit

you simply apply an x on the second

cubit right so this syndrome table

essentially captures

the fact that the different single qubit

errors

can be

distinctly identified and they can be

fixed by the simple application of an x

gate on one of the three encoded qubits

or one of the three data qubits

depending on

what the syndrome table tells us right

so

this

summarizes the error detection and the

error correction procedure

or the decoding procedure for the three

qubit code

so finally we can sort of

complete the circuit right we can we can

put together the encoding the detection

and the correction right so we can draw

a complete circuit so let me just

quickly draw that finally so

the three qubit

code

this is the complete

circuit so i first have these three

qubits which are going to become my

encoded qubits

i start with an arbitrary single qubit

state which is alpha 0 plus beta 1.

i do two c naughts

two control not gates

these are two ancillars remember which

were set to zero

right

so i do two c naughts right and i assume

so far

that this process where i have prepared

where where the initial qubit state is

in alpha zero plus beta one i have

prepared the two ancillar qubits in get

zero and i have applied two c naught

gates i assume that this process has

happened somehow in a perfect way we'll

address this

in the very last

few minutes of this lecture

but it's as if no error has happened

until now and at this point we say that

the qubits are now affected by

error

okay

so now we say

you have the

bit flip channel or the bit flip noise

that is affecting the qubits remember we

only

aim to correct detect and correct for

the single qubit bit flip errors so now

we have the noisy qubits right so so far

we have perfect qubits is the assumption

somehow

okay

and now we have the noisy qubit so this

part

you have the noisy encoded qubits

what do we do with them well we now have

to detect and correct for the errors so

we add these two additional ancillar

qubits which are going to help us in

error detection and correction

and now we have all these c naughts c

naughts from the first

and the second

which act on the first ancillar qubit c

naught from the second

and the third

with the second ancillar qubit as target

so c naught on the first ancillar qubit

have

the first two data qubits is controlled

c naught's on the second

answer like cubit have second and third

data qubits is control and then we do

measurement

and depending on the outcome of this

measurement

and i draw two lines here to denote that

this is now classical bits

so depending on the classical outcome

of

these two measurements

we now have to apply simply nx gate

and this

so the double line denotes

classical bits

right and this is the classical bit s1

this is the classical bit s2 and

depending on the values of these two

classical bits we apply an x gate on

these

a single x gate on one of these three

encoded or data qubits and then what

comes out

is

something which is

error corrected

but remember its error corrected only

for the single qubit error so in essence

this is error corrected up to order p

right so this is the complete circuit

and

we simply conclude this discussion by

noting that the three qubit code can

detect and correct for

single qubit bit flip noise so under the

action of a bit quantum bit flip channel

the three qubit code corrects up to

order p errors right and so essentially

this demonstrates that quantum error

correction

can improve

what we call fidelity fidelity is simply

a metric that compares how close the

final state is to the initial state

right so quantum error correction can

improve fidelity

and

this in turn implies that it can improve

the coherence

time of

the physical cubits

provided

this noise parameter is small

because the entire procedure crucially

hinges on the fact that single qubit

errors are the most likely errors and

that is true only if

the noise parameter is small in

particular in this case we require

that the error probability is less than

a half

right because the errors are corrected

only up to order p remember and so we

require that

in order for this entire procedure to

improve the fidelity and correspondingly

effectively improve the coherence time

of the qubits the

error probability or the noise parameter

must be small and in this case in

particular it must be less than a half

so having explained the technique

and the mathematical ideas behind

quantum error correction

we would like to conclude with a brief

comment on what what is the kind of

physical resource requirement in order

to be able to implement quantum error

correction

so as we mentioned earlier

we don't just have big flip errors we

can have a continuum of different errors

which can occur on a single qubit

and

this includes erasure which is an

important error in the classical setting

as well this includes phase flip this

includes amplitude damping it includes

depolarizing noise etc

right

now of course as we said the resolution

is to now

break down your errors in terms of

a

finite set of errors the x error is the

bit flip error that we already discussed

the z error is what we would call a

phase flip error which can again be

corrected in a sort of fashion that is

identical to the bit flip error

and the y error can actually be viewed

as a combination of the x and the z

errors

and together

this set of errors

can be corrected

and if this set of errors if we have an

error correcting code that can correct

for this set of errors then such a code

can indeed correct for an any single

qubit error because any single qubit

error e can be written as

some linear combination

of

x y z and identity this is any

2 by 2 matrix

which is what any single qubit error

would look like so any 2 cross 2 matrix

can be written as a linear combination

of identity x y and z

and therefore if we are able to correct

for x and z errors

and since y is simply a product of x and

z we can also correct for y

then we end up correcting for any single

qubit error

i should note that just as we had a

three qubit code for

just the x errors

if i now

extend the same idea to also correct for

the phase flips then i get

a 9 qubit code

for

x

and z errors

that is a nine qubit code that corrects

for

single qubit x and z errors and this

code

often goes by the name of the short code

okay

so

but the nine qubit code is not the most

optimal code

in fact the shortest code

that is

that can correct for an arbitrary single

qubit error is a so called five qubit

code and this saturates what's called a

quantum hamming bound one can make

certain arguments to say that the

shortest

code that can potentially correct for

any arbitrary single qubit error must be

at least five qubits long and

we indeed have such a code that

a five qubit code that corrects for

arbitrary single qubit errors

but note that so far we have assumed

that

while the qubit itself is susceptible to

noise the gates up have been assumed to

be perfect and so the encoding process

has been assumed to be perfect

the error detection has been assumed to

be perfect the readouts the measurements

have been assumed to be perfect

but in a real circuit in a real quantum

processor all of these are going to be

faulty

and so the next

level is to talk about fault tolerance

the next step is to talk about fault

tolerance

so in order to deal with faulty gates

and circuits we have the theory of

quantum fault tolerance

and finally

we also need additional qubits in order

to bring down the error rate further and

this uses a technique called

concatenation so finally

we have

i'm just trying to now talk about the

kind of physical requirements we need in

order to have a fault tolerant quantum

processor

it turns out

that we need at least 49 physical qubits

in order to have one error corrected

logical qubit and this is due to the

fact that

rather than the five qubit code it is a

seven qubit code which is more amenable

to or more easily amenable to fault

tolerance techniques and so most of the

physical architectures today focus on

implementing the seven qubit error

correcting code

not just at one level but at two levels

of concatenation so that we have a 49

qubits effectively in order to

protect against single qubit errors in a

fault tolerant way right so this is the

kind of resource requirement that one is

talking about if one has to have error

corrected

quantum processors or quantum devices

so just a couple of more slides to talk

about what is the road ahead where are

we today as i mentioned at the very

beginning we are today in an era of

noisy intermediate scale quantum devices

um and this is the google roadmap which

was put out in 2018 as you can see

where we are today um is somewhere here

where we have

we have

we are off the order of let's say a

hundred qubits

but with hundred qubits one can realize

near term applications but these are 100

noisy qubits

right with an error rate which is still

which is still not really below this

threshold right so this is the so-called

error correction threshold which says

that so long as your error rates are

below this

one can do error resilient computation

but today this is where we are at

and

the goal is to then scale up to

say a thousand or ten thousand qubits

which could then actually be error

corrected qubits and this is the regime

where we finally have useful error

corrected quantum computation which is

require something beyond

um 1000 qubits or close to a 10 000

qubits right

there's a similar roadmap that we have

from ibm and this is a very encouraging

map what i have on the left here is the

good old moore's law that many of us are

familiar with which tells us how

it's a log log plot of how the number of

computations per integrated function is

actually

showing a linear rise in a log log plot

with time

what is plotted on the second figure is

an interesting metric which is often

used today called the quantum volume

it's a combined metric which includes

information about

what is the size of the circuit

the connectivity of the qubits and so on

right and the higher the quantum volume

the more

number of qubits the more number of

error resilient qubits that we have

right so

in terms of quantum volume you find that

we in a log log plot we actually doing

better than linear and today ibm is at a

quantum volume of about 128

and the hope is that in the next in the

coming few years we are actually going

to achieve higher and higher quantum

volumes and be able to implement fault

tolerant error resilient quantum

algorithms

and this roadmap talks about the current

state of affairs so we are here where we

have about 60 qubits today on the ibm

processors

and

the hope is to be able to scale to a

thousand qubits in over the next couple

of years and then

we will be in a regime where we can do

quantum error correction hopefully

achieve fault tolerance and

get closer to robust scalable quantum

devices

thank you