### You May Be Interested in these APIs

### IBM QISKit API Search Results & Alternatives

View More Results### Related APIs in Category: Hardware

### About IBM

International Business Machines Corporation (IBM) is an American multinationalinformation technology company headquartered in Armonk, New York, with operations in over 170 countries. The company began in 1911, founded in Endicott, New York, as the Computing-Tabulating-Recording Company (CTR) and was renamed "International Business Machines" in 1924. IBM produces and sells computer hardware, middleware and software, and provides hosting and consulting services in areas ranging from mainframe computers to nanotechnology. In 2002, IBM acquired PwC consulting, and in 2003 it initiated a project to redefine company values, hosting a three-day online discussion of key business issues with 50,000 employees. IBM operates in 174 countries as of 2016, with mobility centers in smaller markets areas and major campuses in the larger ones. IBM also hosts the industry-wide cloud computing and mobile technologies conference InterConnect each year.Hardware designed by IBM for these categories include IBM's POWER microprocessors, which are employed inside many console gaming systems, including Xbox 360,PlayStation 3, and Nintendo's Wii U. IBM Secure Blue is encryption hardware that can be built into microprocessors, and in 2014, the company revealed TrueNorth, a neuromorphicCMOSintegrated circuit and announced a $3 billion investment over the following five years to design a neural chip that mimics the human brain, with 10 billion neurons and 100 trillion synapses, but that uses just 1 kilowatt of power. Additionally, in 2005, IBM became the first major company in the world to commit formally to not use genetic information in employment decisions; and in 2017, IBM was named to Working Mother's 100 Best Companies List for the 32nd consecutive year.

via Wikipedia

#### Related IBM QISKit API Videos

##### Video Transcription

okay so maybe I'll start it's already

4:15

so thank you everybody for seeing and

till the end of the day to listen to my

talk there have been two other talks

already today so I want to talk about

quiz kit which is a software development

kit we've been developing at IBM forinterfacing with these kinds of machines

quantum computers that you probably saw

it for a prototype model upstairs and so

this actually just this is an open

source software so we've had

contributors from the outside and

hopefully by the end of today if you

feel inspired please do contribute so

this is a brief history of con computing

it's come a long way over the past few

decades essentially there was a

scientific revolution in the 20s and 30s

where people started basically looking

at nature at the natural world and

fundamentally new way with the

formulations of quantum mechanics it

wasn't until a few decades later that in

the 70s and 80s people started thinking

that maybe this new way of thinking

about nature can actually be leveraged

for performing computation and then in

the night in the 1990s there was an

explosion of theoretical results that

basically showed how quantum computers

can be faster than classical computers

in certain tasks and also how to control

errors which was thought to be a

fundamental problem in quantum computers

so this kind of prompted a lot of work

and experimentally in the 2000s to try

to actually realize these systems and a

lot of the systems that we work with

today so for example superconducting

qubits that at IBM and at Google and

Righetti everyone was using basically

was a 2007 work so after after all this

experimental work people started making

stable coherent devices that are

controlled controllable now we've kind

of moved into a new era so IBM has at

IBM research has has contributed to a

lot of the stages over the years those

those kind of dark circles iBM has

played some part in it in 2016 I think a

very important thing happened which in

2016 basic IBM put their put its quantum

computers in the cloud with the launch

of the IBM Q experience program and I

mean as software developers we all know

what open access means like there's

there's a lot of work now that that is

being done on IBM gene with machines so

this was a very successful program sir

we were seeing executions on real

devices from all over the world 75,000

unique users have signed up two and a

half million experiments have been run

and actually people are doing real real

serious work with this sixty scientific

papers have been authored that have used

IBM Q experience machines in some form

so ok so these machines are available

but how can we write software for them

as quantum developers essentially you

you want to have actually you have

access to machines that sit in a lab so

so IBM started building this quantum

information software kit kit or quiz kit

to interface with these devices so

chriskate is has a easy Python interface

that you can use to build quantum

programs in and then it gets translated

and compiled and optimized for specific

backends that you request those backends

could be real devices they can also be

simulators that that basically are

trying to simulate what's happening on a

real device so I don't want to make sure

you about the fundament about quantum

computing today I basically my plan is

if if all of you could go away today

having a understanding of a concrete

understanding of what kind of problems

quantum computing can be useful for and

how to actually get your hands dirty and

write code then I'll be very happy so

basically I'm just going to give a very

brief overview

of the things that are needed to

understand this talk it will be very

brief and then I'll propose this

specific problem that that shows quantum

advantage that you that is that you can

run faster on the quantum machine versus

a classical machine and then I'll do

some live coding here with quiz kit to

show how to actually write a program

that solves that problem on a quantum

machine and then if we have time at the

end I like to just take some time to

discuss the role of software developers

similar to what Stephen did in the

previous talk about from Righetti I also

want to take some time to discuss what

rule software developers can play ok so

there's I mean quantum computing gets

explained a variety of ways I think my

least favorite way is to say classical

bits are 0 or 1 quantum bits are 0 and 1

I mean that's the might be true

depending on your interpretation of

quantum mechanics but the way I like to

think about it is in terms of linear

algebra and probability theory a purely

mathematical formulation that you know

it's very nice that it actually has a

parallel in the real world also but

mathematically it makes perfect sense so

you can think of the state of n qubits

as a vector in 2 to the n dimensional

space so this space is called the

Hilbert space it grows very rapidly

every qubit that you add you're doubling

the size of this space but essentially

your vector has an orientation in this

space so you can use quantum gates or

quantum operations sometimes we call

quantum gates as like matrices that you

get multiplied by these vectors and then

vectors get moved around so the red one

by some quantum gates move moves to the

blue one I apply another quantum gate it

goes to the green and so on

ok so often it is said that the power of

quantum computing comes from this

exponential space right but but we I

mean as humans we can't really probe

into that space the only way that we can

interact with the system is by

observation and measurement when we do a

measurement the state collapses to

either a 0 or 1 so so here for example I

do a measurement on that green arrow

and that's kind of halfway between zero

and the North Pole and one in the South

Pole so with 50% chance it might

collapse to zero 50% chance it collapse

to one so here if collapse to one if I

did a measurement on the blue it had

more chance of collapsing 2-0 versus one

so measurement is just basically like

projection of those vectors onto the

basis of this space okay so that's it

now you can you can compose these gates

together in such a way that moves these

vectors around solving a problem of

interest basically you want your vectors

to be aligned in such a way that gives

when you finally measure you have a very

high probability of getting your answers

and kind of attenuating the probability

of getting wrong answers so this is a

screenshot of the of the quantity

experience website which basically lets

you create quantum circuits by dragging

and dropping these little boxes each of

them is a quantum gate and so you get a

program and then you execute it so this

is you can only do this for very small

circuits if you want to do it for larger

circuits then you need actual

programming language and that's why

quisque it exists so so there are a

couple of things to remember about

quantum gates and quantum circuits one

is that they're reversible actually this

was thought to be a major problem for

quantum computers in the 70s for example

people didn't really know like the it

was thought that maybe this is a this is

a limitation on quantum computation and

Charlie Bennett who's that who's that

IBM and it still is actually showed that

know you can efficiently simulate any

quantum any classical computation using

computer as well so so so verse

reversibility is a fundamental property

of these quantum circuits the other

thing is that with with only very very

relatively few number of gates you can

do universal computation so I'm not

gonna talk about all the gates for the

rest of this talk we only need to know

about two gates the Hadamard gate or the

h and SC not sometimes call was

controlled not those are the ones that

are highlighted in blue here

so I'm gonna talk about what those gates

are and then we'll jump into the problem

that we want to discuss so the Hadamard

gate is a simple gate for creating

superposition on States assume that I

have a qubit in state zero that notation

basically whenever you see it the ket

notation is basically at a quantum state

so when I have that Y cubed is in this

state of zero whenever I observe it I

always read zero because it's in a

deterministic state of zero now when I

apply one Hadamard gate now it becomes a

superposition of zero plus one so that's

that's when what people mean when they

say qubits can be in zero and one at the

same time but essentially it's a vector

right it's a the zero vector plus the

one vector so when you add up two

vectors that that zero plus one ends up

sort of in the middle so you have 50%

chance of reading zero 50% of chance of

reading one so basically if you do that

little circuit up there and do it a

thousand times and read the result 500

times you read zero 500 times you read

one okay so what happens what if I add a

new qubit and a second qubit puts

basically I can get 0 0 0 1 1 0 1 1 all

of these combinations the probability of

each of them because I probably have to

have to add up to 1 each of them has a

probability of 25% if I add a 3rd qubit

the probability of each of these

measurements is 12.5% so you see that

basically by adding every new qubit I'm

doubling the space of the problem but

again it's important to remember that

whenever I make a measurement I read one

of these in at random right so like here

I make a measurement and I read 0 1 0 so

I with one measurement you don't really

have to have a way of knowing what that

Hilbert space probability was if we're

doing a lot of measurements so you can

kind of reconstruct that so that's one

thing to remember about how to mark gate

that it creates superpositions the other

thing is that it has an effect depending

on what you feed it so in the top

circuit I'm feeding it a zero and in the

bottom I'm feeding it a 1

when I feel a zero it becomes zero plus

one when I feel a one it becomes a zero

minus one so this is the zero vector has

been the one vector has been subtracted

from the zero vector in this case so

from it again from from a observers

perspective both of these have a 50/50

chance of zero and one we don't we can

we don't really have negative

probabilities but in the hilbert space

these vectors are different that and and

and so the second one that negative sign

will call the phase so there is a phase

there that that that is important in the

problems that we that we work with but

on the output it doesn't really have an

effect both of them are 50/50 and the

last thing about the Hadamard gate is

that it's self inverse so if you apply

it twice it cancels itself so the top

one becomes zero again the bottom one

becomes one again okay so that's the

Hadamard gate

it says sing so one qubit gate the

controlled-not gate is the other gate

which is acts on two qubits and you can

think of it as a quantum if statement

essentially basically the job of this

gate is there's the top qubit of the

control qubit the bottom qubit is a

target qubit whenever the control is in

is in is in the zero state it just

doesn't do anything if the control is in

one it flips the output at the target so

at the top at the control is zero and

the target is in some superposition

state of zero one and it doesn't do

anything nothing happens and the bottom

the control is one now so the place of

zero on one flip so you get B 0 plus a 1

alright so I mean this is quite simple

it's like if statement again the

important thing to remember is that all

of these gates can can are working in a

superposition of state so here I'm

showing the target to be in a

superposition state the control could

also be in a superposition of state and

again the same again through like linear

algebra everything works linearly and

this whole thing works I'll work through

some examples to show you if like yep so

the power of these gates comes from the

fact that date what you feed them can be

superposition states they're not just

zero or once ok so now let's just go to

the concrete problem that I talked about

ok so this problem will

formulated by ethan bernstein and

vishwas irani in the 90s and was one of

the first examples of a concrete problem

where a quantum program is much faster

than a classical program so the the

problem is this suppose somebody is

sitting somewhere and they are guarding

a secret now that secret is a secret

bits drink an n-bit bit string of SN

minus 1 to s 0 the most significant bit

I'm showing on the left and the only way

you can interact with this person I'll

call the Oracle is through querying them

with by sending them basically your

input bits drink and they take the this

bit string they do a dot product of

their secret with your input and just

give you one bit as output which is a

dot product it has to be mod 2 because

it's a 0 1 so that that's the problem so

the problem here is you want to recover

you know you want to know what their

secret is so classically the way you can

solve this is simple right so you

basically it's like a mask on these bits

so you you first feed in 1 in the first

position and then 0 all in all other

places when you feed in that in the dot

product just singles out that one bit of

the secret so you get SN minus 1 in the

second query you do 1 in the second

place then you get the second qubit of

the secret and so on until you get all

of the bits of the secret and so this

takes n tries alright you have to make n

queries to the Oracle so and classically

this is the optimal solution like you

can't do any better than this

anyone know why right because each query

is giving you one bit of information and

you want to recover n bits of

information so you can do better than n

queries

okay so Bernstein and Barney showed that

you can do this on a quantum computer

with only one query ok so that's pretty

remarkable I want to show you how that

that gets done so in order to think

about this problem we first need to

think about how an Oracle of this type

might

implemented on a quantum computer what

does it mean for an Oracle a quantum

Oracle so a classical Oracle as I

mentioned basically takes n bits of

input and gives you one bit of output

which is a dot product with the secret

now the the quantum Oracle can't work

like this

why because quantum programs have to be

reversible as I said right so you you

can't you can't have a reversible

circuit that has n inputs and only one

output so the typical way to resolve

this and to make this a valid quantum

circuit is to basically pad the inputs

and outputs so I just add one extra bit

of input call it the temporary qubit and

now now this is a valid quantum

operation it takes X gives out X and

then on the output it just gives me X

dot s ex-ored with temp and that temp

that export has to be there because if

it was just exit this again I'm losing

information about temp right so so if if

now now if somebody gives me a quantum

computer and I was like a black box and

says I promise you that this black box

does this then I can recover s with just

one shot according to the Bernsen was

there any algorithm okay so I mean we

don't really know we don't really need

to know how the Oracle is implemented in

order to solve the problem that's just a

black box but it's instructive to to

think about how how that Oracle might be

implemented and it will help us arrive

at a solution so I claim that this

simple circuit is an implementation of

the Oracle

okay so assume that the secret bit

string is 0 1 0 1 and bye-bye do I claim

that by doing these C knots on places

where the secret is 1 and not doing

anything on places where the secret is 0

that's that's doing the job of the

Oracle and and so just remember that the

most significant bit here is the bottom

x 3 and the top one is the least

significant bit right so so I'm doing

nothing on the X 3 C not onyx - nothing

on x1 and then

see Nanak serum and the reason for this

is very simple right so because a C

naught is essentially doing an XOR with

the target so if a C naught is

essentially if the control is one flip

the output if the control is zero don't

do anything that's that's the definition

of an XOR so when I apply this gate

these two gates I essentially do the

output that I get is that expression

there where the secret gets multiplied

by its corresponding bits in X so here

secret is 0 1 0 1 and it does the job of

the Oracle for me

so if I had a different Oracle with a

different secret like let's say 1 1 1 1

the way this would work is again I would

do seen us in places where I have a 1

right so this is a very simple implement

implementation of the Oracle as I said

we don't need to know that in order to

solve the problem but it will help us so

so just by doing a pattern of fie knots

according to the secret the Oracle can

be implemented okay so so the trick that

allows us to do this with only one shot

is the following it's called phase

kickback in quantum computing so in

order to understand feedback let's just

go work through this example it's

basically this is where you see how

linear algebra how close it is to linear

algebra right so assume that I have two

qubits starting at 0 and 1 and I just

apply haddem arts to them what happens

is that the top one becomes a zero plus

one the bottom one becomes zero minus

one right so now that because these two

qubits are together I kind of kind of

can can write can kind of multiply those

two expressions together and get this

linear algebra so now if I apply it

controlled and controlled not to this

what happens we can just go through by

the definition of the C naught whenever

the first qubit is 0 don't do anything

if the first qubit is 1 flip the second

one so 0 0 save 0 0 0 1 state 0 1 and

then 1 0 becomes 1 1 1 1 becomes 1 0

right so that's what we get at the top

after the C not does this data at the

top so I can factor that again linear

algebra

into this 0 minus 1 0 minus 1 so now

what an interesting thing has happened

here is that the top cubed started at

being 0 plus 1 it became 0 minus 1

it's as if that the second cubed kind of

kicked back the phase to the first one

through this circuit so now if I if I do

another layer of Hadamard because both

both of them are now in the 0 minus 1

both of them become 1 on 1 right so this

is only the only thing we need to know

in order to implement our algorithm if

you if you notice the thing at the in

the middle that C naught is very similar

to this pattern of C knots of the Oracle

right so so this I claim is the solution

basically you have a black box or a code

that has a bunch of C nuts in it and you

just sandwich them between hata Mart's

similar to how we did in the phase

kickback yeah I just sandwiched them

between here Mars and that there's an X

Box there at the like like that the temp

0 cubed I just make it apply an X

because I want it to be come from I

assume everything starts at 0 so by

doing that I just make that last one of

one because in phase kickback I want

that la sorry in phase kickback I won

the last keep it do we want right anyway

I just do that and then I applied this

layers of two layers of Hadamard like

between before and after Oracle and what

happens is basically that Oracle kicks

back the phase of wherever it has a C

naught to the control qubit so so for

example if the the Oracle had this

pattern of C knots it would do phase

kickback on the on the top one and then

on this third and the fourth one so

those be the last layer of had Amar's

those are the ones that become ones

right and the rest because the rest

stays 0 so now it kind of now now after

I do a measurement

I basically recover the secret with just

one shot right

I made one query to Oracle and and all

of the bits of the secret came out

okay so I just want to pause here and

kind of reflect on how why this worked

again it's not like quantum algorithms

are not magic they it designing a good

corner mal rhythm was actually very hard

because you have to exploit certain

certain structure in the problem and you

have to be lucky for those structures to

exist and then you should be even more

lucky if that problem that you're

solving has some practical interest so

this arguably has no practical interest

the reason this works is that first of

all that Oracle can be implemented by a

very simple pattern of C nonce and the

second reason is that using fav kickback

we're able to encode the bits of the

secret bits of the Oracle into the

phases of the inputs that we have so all

of these align together to give us this

nice algorithm okay so now let's just go

and actually write a quiz gate program

to to to solve this right okay so so

okay so in order to download Chris could

you just there's a Python package you

just do pip install quiz kit and you

have it and then in order to interface

with the IBM Q experience devices you

need a key

that you need to basically sign up I

find the IBM quantum experience website

so for example you go here and then you

sign up and then they after you sign up

they give you a key so in order to also

authenticate you I know who you are so

you go to your account and then under

advanced you'll see your key I don't

want to show my key here because it's

being recorded

so anyway when you get that token with

with quiz kid comes a file called Q come

fix that pile you just grab that token

and paste it in into that space and

that's it and then you're good to go you

can now you can talk to the backend

devices okay so okay let's let's let's

try to implement this algorithm this is

what we want to implement right there's

a Oracle and then there are the other

stuff that go around okay so so the way

we do this is basically I will say from

quiz kit

import first I need a quantum register

to contain my qubits and I need a

classical register in order to read the

results in the results or classical

register so I'll just say import quantum

register and then classical register

right and then a quantum circuit object

okay so I'll just create my quantum

registers here you see them on the left

here right so I'll just create Q is a

quantum register I have to give it a

name because later on when you want to

print out the your program you can have

a name to refer that register by so I'll

call it Q and it has a size of four and

then I'll call I'll create another

quantum register the temp register I'll

call it temp and I has a size of one and

then I'll create a classical register to

contain my result I'll call it res with

size four okay so that's it

I'd my quantum register in classical

register so now let's start by

implementing this Oracle okay so the

Oracle is okay so the Oracle first of

all has a bit string that we have to

define let's say that bit string is I

don't know 14 okay so

14 in bit string would be one one one

zero right okay that that's the secret

and then I'll create an Oracle circuit

so it's a quantum circuit that acts on

these registers takes Q temp and rest

okay

so now I want to create basically put

this stuff up the work will inside it I

have a typo oh thanks

so okay so the way you okay so you

basically just say I want to implement

that pattern of see now so for I in

lengths of Q I want to say whatever the

secret is a one at a C naught so if I

can basically I can do a mask right a

bit mask right bit string math so if s

and with one shifted right

if that's one then do a C not on the

Oracle circuit and I've seen nothing and

quiskal is represented by CX it's the

same thing

control decks controlled not I want to

do a fee not between Qi and temp

register which is there okay problem

here length let's just do four here I'm

sorry

length of queue

okay so let's let's see if I made the

right program Orko

so chasm is essentially our

representation of the circuit in quantum

assembly language format so if I do this

it seems like that's correct right so

this is a standard header for Kasim this

is my quantum register the two point

registers one classical register and

then that's the pattern of C knots that

I created

right so for 14 I get C knots between Q

q3 q2 and q1 but nothing on q0 right

okay so now I have the Oracle let's

create it the main circuit right so I'll

just assume that the Oracle is now black

box I'll create the Bernstein Bazar on

your circuit again on the same registers

and then I'll start building the gates

right so I'll say first I'll need to do

this X kate on the last qubit so X on

temp 0 and then I need that that layer

of Hadamard x' so the nice thing about

is that you don't need to do it

index line X you if you just don't

provide an index it automatically does

it on all of the indices of that

register so I apply how to Morris on Q

and I want how to Mars on temp again now

I want to add the Oracle right so in

quiskal is very easy to compose

sub-circuits together to make a larger

circuit you just do this you just do add

Oracle ok so I add the work goal so now

I'm up to here I need the last layer of

the Hadamard which is the same thing as

I did above so I'll just copy that and

then I'll just need to measure the

results ok so I measure the results of Q

into the results register so

your cue into okay so now my first thing

was writing circuit has created let's

see if I got the right circuit so I'll

just again print the quantum assembly

and okay great

so so I have the registers I have that

first X then the first layer of the

Hadamard of these and then that's my

Oracle and then the last layer of how to

Mars and then measurements okay actually

you can also just visualize a circuit so

you can basically do from quiz get tools

visualization import circuit drawer okay

so now I can easily just draw the

circuit so that's it right so that

that's basically what we created so

these boxes move around a little bit

that the plotter tries to kind of move

them left as much as possible but anyway

if you don't want that to be moved

around you can insert things called

barriers to prevent the compiler doing

that but this is automatically generated

so good so now we have the circuit now

let's run it right so so in order to run

a job in in quiz kit you have to work

with this object called a quantum

program so I'll basically just do from

quiz kit import

and then so the quantum programs

basically can contain many circuits so

you can just like put like five circuits

in a quantum program and then submit

that entire batch to the backend here we

just have one circuit and then I'll just

do make a quantum program and I will add

my circuit to it I'll need to give it a

name again because later I if I had

multiple circuits and then the circuit

itself is BV right so I have created a

quantum program okay so now in order to

run and on the backend I have to

remember I got that queue config token

classes in the backend I have to I have

to import that here so the quantum

program knows has it has an ID attached

to it that that can use to authenticate

itself with the backend so I will

basically do I have to set API to queue

config

[Music]

jokin sorry one second okay so here you

have to pass him the token and this

second thing here was a URL the URL is

always pointing to the quantum

experience website but you know it's

there because if you want to run on

different backends of different company

for example you could do that so that q

config has a URL so it has a config

which has a URL field so now I've set

the API for my corner program okay so

before running on the backend

let's just see what backings are

available so I can do from quiz kids

import backends and then I can do this I

can say this has information about all

the backends are available so so some of

the backings are local backends and some

of them are remote backends the local

packages are basically simulators that

run on your own laptop you know for a

small number of circles you can just do

that again you don't need internet

connection for example the remote

backends are basically the devices that

we have and some of the high performance

simulators that are on the cloud so here

the local simulators we have a bunch of

local simulators that are installed with

quiz kids you can use those you can

basically read about the differences of

each of them but the main one that you

can just use is this local chasm

simulator and then the backend devices

we have to IBM qx2 you Explorer qx5 so

the difference between these is

basically this is a device page of the

IBM quantum experience we have a twenty

cubits chip we have a 16 cubed chip and

then we have two five cubed chips and it

shows the status of each of them so this

IBM qx2 five I just need five cubits for

this example it's active so I'm just

gonna use this but first let's just

validate the result on a simulator

before running it on an actual quantum

machine so I can just execute my quantum

program I just need a list of the

circuit

within that program that I'm interested

in running so that's just one circuit BV

and then the back end I'm just gonna say

this local chasm simulator and I'm gonna

gather the result here I'm also just

gonna pass a timeout parameter of 300 to

make sure that it doesn't timeout this

is a small circumcision and time off

anyway so but just to be sure that's

just in seconds mm-hmm

so let's just run this so it finished

the result object is there and by

default this runs 1,024 shots of the

experiment as I mentioned you have to

run multiple shots if it's a probability

distribution with one shot you don't get

any answer like you need to run multiple

times and get a histogram of the answers

so in order to see how many times each

result was returned you can just

basically do result get counts of that

BV circuit you see that the 14 that I

included in the problem was returned all

because this is ideal simulator all of

the shots return the right answer okay

so that's great

you can also so let's just call this

counts Saul King print accounts in RAW

format or or I can visualize it by a

histogram so I can say from quiz kit

Tools stop visualization import plot

histogram so I can plot the histogram of

this as well

okay so all of the results are the

correct answer the histogram is not that

interesting but that's pretty cool right

that the problem worked with one shot we

were able to recover all of the secret

bitstream so like if I if I change this

number to let's say I don't know three

so this would be just bit string and

rerun the entire notebook I get three

okay so that's good so now let's run on

a real device for the real device I'm

just as I said

IBM qx2 there's a five cubed chip IB and

QX - all right let's let's run that and

hope that it so this is now being sent

to the quantum lab in Yorktown Heights

in New York it's running on a real

quantum computer and the result will

come back so remember that this is a

noisy quantum computer right so the

results will won't be as clean as this

simulator but hopefully we'll see the

correct result so I mean it takes time

to some time even if it times out the

timeout parameter there is a quiz get

timeout parameter so that you can just

put it in your script so that you don't

wait your script doesn't run forever but

essentially even if the cue is really

busy so this finish right now but even

if the cue is really busy and you don't

want to wait for it it will still sit in

the queue and eventually run and then

you can get your your run the jobs that

you have run later whenever you want

okay so I got this result from the real

quantum computer and if I plot it I see

this so the correct answer is through

zero one one and the majority of the

counts that were returned where it was

for for the correct answer but because

it's a noisy device there are some

errors some of the runs return these

unwanted results right so so I mean that

that's I hope that you found this simple

enough to use we have a lot of resources

I'll talk about those - in order to get

familiar

but in the remainder of my time much

that is I just want to talk a little bit

about the rule of compiler so so here

you saw that we had errors right in the

program that I ran so suppose that I

have a pro program that I write so

that's again the bursting Bazaar any

algorithm at the top and I want to run

it on it back end so the back end that

I'm choosing here for example is the 5

cubed chip with and and the thing is

that the qubits are not don't have full

connectivity so here I see for example

in the quantum the program wants me to

do C knots unforseen us where the same

qubit is the target for all of them so

basically that qubit has to be connected

to four cubits in the surrounding but no

such qubit exists here so even this one

in the center the directions of C nuts

are not correct so this this can do this

can be the control for these 3 C knots

and the target for this so that that

doesn't match the program so the

compiler has to be smart in order to

basically so Stephen talked about this a

little bit in the previous talk the

compiler has to be smart in order to map

this in the most efficient way from the

program level to the on chip qubits and

then fit and then if the graphs don't

match exactly you can insert swaps and

things like that but each swap is quite

expensive so so here is an example of

two different compilers out to do the

the first the the bottom one is a is a

bad compiler it created this long

circuit the top one is a very smart

compiler I'd created that short circuit

so again both of these circuits do the

same thing we perform this bursting

buzzer Ani algorithm but this one is

significantly better as I said though

you have a lot of noise on the devices

so when you have a long computation

there is much more opportunity for noise

to accumulate during this computation so

actually when you run this on on the on

the devices what you see the top one you

get the right answer

57% of the time and the noise this much

for for the bad circuit yes there's a

20-point difference like 35% of time you

get the right answer and there's a lot

of noise

so I mean here we're kind of lucky we

were still able to kind of visually know

what the right answer is if the circuit

was a little bit longer the the noise

would become more and more until

virtually the result and the wrong

answers would just be indistinguishable

so so there's a there's a lot I mean the

way I think about it is that in the near

term we're gonna have noisy devices

there's a lot of work being done at the

experimental level trying to make these

devices more coherent to reduce the gaze

and things like gait errors and things

like that

at the top level at the algorithm side

people are thinking about you know

creating algorithms that don't require

that much resources and are short dips

and things like that but in this space

in between of translating those

algorithms from the top to the bottom

devices you know we need very good

software to do that and you know you can

see that the effect of that is quite

dramatic that you know if your software

is good you can actually extract the

most juice out of your devices and it's

not good you're wasting a lot of

resources so actually this is the

subject of a IBM quantum awards program

that was launched about last month

and so there's a developer challenge in

there that that is exactly this problem

is that can you write better compiler so

chriskate already has a basic

implementation of this it's not the most

optimal but we want to know you know who

can write a better version of this and

there are $5,000 in prizes to be won

deadline is 15th of May so if you're

interested I definitely invite you to

give it a shot ok so hopefully if you

found anything interesting in this talk

there are many other resources to be

explored so the first place you can go

is the quiz kit website there we have

extensive documentation about the

software and how to use it and things

like that a very excellent resources are

tutorials that have been written and

similar to the Jupiter notebook that I

created we have tutorials for a variety

of concepts in quantum information and

quantum physics and all of them have a

car company

with code so I I mean I had a very small

role in creating these but a lot of them

have been created by experts in that

particular subfield so they're very good

for get basically getting to know

quantum more again if you're a developer

that is interested in contributing to

the software toolkit please go to our

github and pull requests and issues and

everything is welcome and we also have

the public flat channel where we just

discussed basically new features that

we're developing we get suggestions from

the community you can you can really

have an input on where cool skate should

go and awards I talked about so yeah I

mean but that'sthat's all I want to talk

about so if you have any questions

please yes

I mean we're working on increasing it so

right now right now we the the publicly

available ones are two five cubed chips

and a sixteen cubed chip there's a

commercial twenty Cuba chip available

for clients as well yeah yeah so so yeah

so that's it that's a good question so I

mean a lot of times you know you hear

people say that quantum algorithms have

the exponential speed-up that's not the

case that's you know a very select few

quantum algorithms actually have

exponential speed-up and so this one

that I showed have polynomial speed-up

so the classical case is n queries

this one is one query if you're

interested about an exponential speed-up

of something similar to this you can

look into Simon's problem if you read up

on that that's exponential speed-up but

yeah here I mean aesthetics it's not

it's polynomial and you need to as many

qubits as your secret to accomplish this

so yeah I mean I'm around if you wanna

ask me another question but I think that

time is up sir maybe one more

the witch conditional oh I mean yes so

that all of that is a is Python right so

chriskate is implemented in Python and

we have the full power of Python so you

can use any valid Python program the

compiler will get that and it long as it

can be generated from that you can

generate a valid quantum program it can

do that for you the if statement is not

a quantum thing it's a classical thing

that gets compiled yeah sure I'm I'll

stick around if you need any after have

any questions basically thank you

[Applause]