Quantum Computing and Workforce, Curriculum, and Application Development: Overview and access


>>Hello. My name is Mariia. Today, I will tell you about some really great tools that we created to help people
learn quantum computing. So earlier today, you heard
a lot about quantum computing, and you have to admit that
it’s a very exciting topic. There is also this idea
of being able to solve the problems that are
impossible to solve now. So this means that, there are a lot of people there who really want to learn
quantum computing. What can we do to teach
them to help them learn? As a first step towards
teaching people, is creating materials
that they can use to learn themselves on their own. So we’ll know that learning
with the teacher is awesome. You can be guided. You can have your questions answered, but not everybody has the luxury
of having access as a mentor. In fact, I’m pretty sure
that vast majority of people learning quantum computing
these days are on their own. So we need to be able to help them. There are a lot of materials on the Internet that cover
quantum computing. I mean, it’s 2019 after all. There are books, there are videos, but a lot of these materials
have some disadvantages. First, if you’re reading a book
or you’re watching some videos, it’s by definition, basic learning. You consume information, but
you’re not very engaged with it. There are resources that
offer active learning, but are very few of them. Really, you cannot master a concept
or an algorithm until you have actually tried to apply it to solve a problem
to implement the algorithm. It doesn’t really matter if this is a quantum algorithm or a classical. That’s why the course is
on classical algorithms always have written assignments. They had labs, they have ways to implement things to make sure that you have actually internalized them. Second, let’s say, you have found
some exercises to practice on. For example, books have exercises. But what is the book doesn’t
have the answers or hints? I have a very specific book in mind. It’s the one which everybody recommends to people who start
learning quantum computing. It has lovely exercises, but it doesn’t have answers. So if you have solved the exercise and you want
to check if you’re correct, or if you’re stuck on
an exercise and you need a hint. Well, congratulations you’re stuck. So what we are trying to do? We’re trying to remedy those issues. We created a project
called Quantum Katas, named after this breaks
that’s used in martial arts. I heard from people who actually tried martial arts that
it’s a terrible name, but I’ve never done it myself, so works for me. So the Katas are sets of programming exercises
on quantum computing that you can do using Q sharp. Each Kata offers a set of tasks of increasing
complexity on one topic. Each task has to be solved
by writing some code. So it’s active learning. You try to do something active. The most important part is that
the Katas have testing framework, which takes your solution, runs it, and evaluate it to figure out whether
it’s correct or not. So Katas implement
all the principles of good learning. It’s learning by doing, they give you immediate feedback, and there is increasing complexity
of the tasks you attempt. There are also answers for
the tasks in the code. So if you are stuck, you can go to see the answers, and figure out what you
have been doing wrong or in what direction you
have to be thinking. So Katas project is
only about a year old. So far, we’re have been seen Katas on different projects,
on different topics. So we cover a lot of topics
that would usually be covered in an introduction to quantum computing materials,
starting from the very, very basics like the gates that
are used in quantum computing, like teaching you to recognize
the correct gate for the situation, to very advanced topics
like Grover’s algorithm. Bettina talked earlier today
about Grover’s algorithm, and it’s actually my favorite example of what we can do to teach people, because it’s one of the very famous algorithms
in quantum computing. A lot of people have
heard something about it. Usually, it’s something
like, “All right. It’s this algorithms that can
speed up database search.” That level of detail. But once you actually go
in and try to implement it to solve a certain problem, even the simple one, that’s when you start to figure
out how easy it’s it works. What are the scenes
that nobody mentions? Trust me, there are scenes
that books don’t mention. The more you play with it, is the more you start
to understand it. Maybe database search is not the best application
for this algorithm. So Katas are all open source, and freely available for
everybody to download, to learn themselves,
to teach other people. In fact, they’re open source, so a lot of them were contributed
by people outside of our team. They’re available online
as Jupyter notebooks. Now, it’s time for demo. Well, I like to live dangerously. This is the Kata which teaches you to solve
problems with Grover’s algorithm. I did mention that this my favorite. So let’s take a look
at how this is works. Okay. It doesn’t. Minor technical
malfunction. Now, it does. So I’m running this locally. It’s also available online, but I didn’t want to run the risk of dropping Internet connection
or something exciting exist. So it’s a Jupyter notebook. You see there are
some instructions in the beginning on how to
initialize the Kata. Basically, it loads
some packages that it will need to evaluate your solutions. The first part is, writing oracles for the problems
that you’re trying to solve. So what does Grover Algorithm do? Basically, it’s given
an implementation of a function which takes binary input and
gives you a binary output, zero or one, indicating whether this input is the solution to the problem you’re
looking for or not. The goal of Grover’s
algorithm is to find any input that will produce
the value of function equal to one. It’s basically trying to reverse engineer’s function without
knowing what it is. So the most interesting
thing about it, is actually implementing
this oracle that it uses, because you cannot use as a classical implementation
of the function to get this speedup that
Grover’s algorithm gives you. You need to be clever and to describe
the conditions on the input, which will give you the answer
you were looking for. So Boolean satisfiability problems are actually an excellent example of the problems that can be
solved using Grover search, because they map to this binary input binary output
really, really well. Binary input is just the values
of the Boolean variables that you assigned to those variables, and the output is
the value of the function. So the easiest example of a SAT instance that you
can do is this one, the AND expression of two variables. So you see that the first task
gives you a very simple task. It describes as the inputs to the operations that
you will implement. It tells you what’s the goal is, what’s the transformation as it
is done by your code should be? In some tasks, it describes the return if the operation
has the return. But this one is a transformation,
so there is no need. Since there is a code cell, in which you actually
write your code, it gives you the signature of the operations that
you need to implement, and here you can write a code. I have seen this task
once or twice before, so I should be able to
write some code for it, and run it by executing the cell. Executing the first cell
takes a little bit of time. But after that, it’s much faster. Okay. Actually, it does and
this code I wrote isn’t correct. Purely for demonstration
purposes, I’ll show you. So this is actually
a compilation error. It will also tell you if your solution can be
compiled but it’s incorrect. This one is actually
fairly easy to resolve, its just a missing semicolon. Then we runs this. So again. Suspense, success. So yes. I did know how to
solve the first task. So after this, the second task offers
a slightly more complicated task. It’s an OR formula which
is very similar to end, but in quantum it takes
a little more effort to solve. I could go on solving
these tasks just because we have a lot of time from cutting the previous talk short, but really I want to be conscious
of flange coming up soon. So let’s just look through the tasks. So you see, the next one is
another example of the formula, then we get to
more complicated formulas in which you need to
actually combine some of the pieces you have
implemented earlier and use them as building blocks. Then thirdly, so they get
to the SAT problem itself. It gives you a definition
of what is a SAT problem, how it can be represented. Then it explains to you how this task gives user input
how it is represented. Because representing SAT problem you need to have to look at some data structure which represents it. Then on and on, and then you get the full SAT problem with arbitrary number of clauses. Then the second part of
the kata and offers you to implement Grover’s Algorithm using the oracles which you have
done in the third section. So this is one of
the major principles of the katas, the next task build
on the previous ones. Or the covers that topic from
slightly different angle. But usually in the end of the kata, you need to be able to put
everything you’ve learned together. In the end, you have to
implement the algorithm and see to make sure
that it works even if you don’t know the number of inputs, to see the number of solutions. There’s a formula. Does anybody
have any questions at this stage? Because in the second part I will be talking about something
slightly different. Okay, excellent. Let me return to the presentation mode. Okay. So now that we
looked at the tools that people can use to learn quantum
computing as their own. In the second part of my talk, I will tell you about how
we used the quantum katas and other tools to teach
students quantum computing. I will also tell you how you can get access to those excellent materials, just in case you want
to teach somebody. So this went on retort a
course introduction to quantum computing at
University of Washington. Martin will tell you more
about it after lunch, it was a major effort by
a lot of people in the team, and it was a very
interesting experience. Just to give you something
to look forward to. Meanwhile, I’ll give you an overview
of some materials we created for it that we’re happy to
share with other teachers. So here is an overview
of course materials. Basically it was
a 10 week long course. So we had 17 lectures and we
have slides from those lectures. We’ve had written assignments
that come with the solutions. We had six programming assignments which I will be talking
about in much more detail. We offered a big subset
of quantum katas as webs. So the material which
students can use to learn the actual programming necessary to do
programming assignments before they continue to do
programming assignments. All sorts of your final projects which we offer and
the students do in teams. So we did programming projects
rather than final exams. But again, Martin will
talk more about it. I shouldn’t steal his spotlight. Here is a brief overview of what topics we covered
in the lectures. You will see that
these are topics that any introductory course and
quantum computing will have. In fact this course had a lot more information than some of the courses
that we will have. So it was a 10-week course
and reflected full. We had actually several universities already using these materials
for teaching their courses. One of our partners took
these materials and they basically took a lot of these materials which
are more introductory, except Fourier Transform I think, which is a bit more advanced. From this section, they only took Shor’s Algorithm and they
made a great course. They didn’t feel short on materials. Then there are written assignments. They are tasks based on
theory and applications. They don’t involve any programming. So basically it’s a task
which is given to you on paper and you return
right off of it. It’s also many integrated. Fortunately, I was not
involved in grading them. Therefore, written assignments, they cover different topics of the course. We gave approximately one
assignment for two weeks. Then there are
programming assignments. That’s what really made
the course stand out because for hands-on component is
always very available and it’s always done in
normal computer science courses. But in quantum computing, it’s a bit harder to do it. So the loveliest piece of model it is the task are
automatically graded. Our teaching assistants
loved me for it. Because I mean there are only so
many times you can look at to sharp called for
Grover’s algorithm to grade it. There’s not a lot of times. So they are very
similar to the katas. I will show them a bit later and the gains they cover
the same material, but they are designed to accompany
the written assignments. For example, if you have
a task about the circuit, like the one shown here, it’s really easier to
just do it on paper. If you have a task, for example about drawing a circuit, it’s done on paper. But if you want to do
something a different angle, programming assignments
are excellent for that. So how we did it, we taught the lectures to introduce
the theoretical material. Then we offered a CAT or several on these topics for people to practice
and internalize the topic. Then we followed it with
a graded and programming assignment. Now it’s time for another demo. I will show you the programming
assignments themselves. Just to continue the trend I started who is
talking about Grover’s algorithm, this is programming assignment from Week 4 in which we cover
Grover’s algorithm. We also happens to cover
Fourier transform on that week. We had basically a snowpocalypse
and it was a long week to cover. So you can see the structure
of the project here, it’s very similar to
the structure of the Katas. You have the file with the tasks, you have the file with reference
implementations which you can see just to check yourself
how it is graded, and you have testing harnesses. The file with the tasks is similar to what Bettina showed
us earlier and this is how the Katas looked when they are in project mode as opposed
to notebook mode, and this file is the only one that the students get once
they get the homework. You sees that it has
a little introduction telling you what topics
are covered and what Katas should be solved before
attempting this material, and then we have the tasks. Again, they look very similar. Because the Katas, they give
you the inputs to the tasks, the output or the goal of the task, and the signature, and you
have to write the code here. So basically, how the
workflow looks like? We give this file to the students, the students work on it or
fill ins a blank spaces, and in the end of the week or
once the assignment is due, they send it back to
the teaching assistant. Then the teaching assistant
takes the students file, substitutes it into the project, builds with it lecture. I can pretend that I’m
a very lazy student and this is the file
which I submitted. I really should have
put more effort into it but as our commitments. So as this file builds and then if you switch
to Test Explorer mode, you will see that it has 10 tests, one test per task. If you do Run all tests, you will see that all
10 of them failed. Okay. I guess I’m not getting
a good grade on this one. So segregating part can be automated even further because you can
do this copying over files, and substituting them, and
running some tests on them. You can do all of this
from common line from a script which is what
our teaching assistants need. Basically, it’s
the one thing you care about is how many tests passed. This is basically
the grade out of 10. One saying set, we are
considering improvements on. Well obviously, a lot of
things can be improve. I want to do a refresh on the tasks, I want to do more tasks, and maybe a little simpler ones because we got a lot of feedback on these materials basically
that the tasks are too hard which I understand. I can error on the side of
being too hard sometimes. One of big scene in these was a set, you notice that the Katas
count with the tests. If you are trying to solve them, you get your feedback
immediately and you don’t need to think about how
to verify your code. When you have this
programming assignment, you only given the file
was the tasks. You’re not given the testing harness. The reason why we’re
doing this way now is that the testing harness
uses the correct solutions. A lot of times, there is
no other ways that you can test the solution other than
compare it with the correct one. These solutions are all in the open. You can just look at this file, find the correct solution. We cannot really give out a graded assignment which
comes with solutions built in, this is not how it’s
supposed to work. So this is why we had to
withhold as a testing harness. For now, I think we can
do better than this and package the testing
harness so that it doesn’t expose the students to the reference tasks but also doesn’t require them to write testing harness upfront because writing
testing harness is not trivial and most students just cannot do
it in the very first week because they have seen this whole
quantum computing same yet. I think this is it for
the material that I had for you. So any questions?>>[inaudible]>>There is a mic coming up.>>I was curious how are you hiding [inaudible]. I was wondering how
the implementation is hidden when if the Katas in the notebook rather than in the project
because you said like, “Essentially, the project
which we are seeing here is the same that we
have gotten over.”>>So when the kata comes in
notebook format like here, it’s essentially
a different front end for the same thing that you’ve
had seen in the assignment. So I can show you the repository
where the Katas reside. GitHub repository, and you have
seen the links previously. For example, if you look at
the same Grover’s algorithm, there is the same solution file
and project file and it has a reference implementation file
which has the answers. So in the notebook format, they are hidden purely by virtue or for just not exposing people
to this file structure. Just because Jupyter Notebook, you look at the notebook and it doesn’t show you the rest
of the files in that folder. But if you go to the repository, you can get access to these files. So for programming assignments, we cannot do the same thing. We need to package those files tighter like builds them
up in a DLL at least so that the students can still like disassemble the DLL and reconstruct
what was inside for it. But honestly if they do that, they deserves that grade.>>Thank you.>>Any other questions? I guess that is it then. Thank you for listening to me.

2 thoughts on “Quantum Computing and Workforce, Curriculum, and Application Development: Overview and access

Leave a Reply

Your email address will not be published. Required fields are marked *