PAZ. I'M HERE WITH CHRIS GRANADE.
WE WORK, WE BOTH WORK ON THE MICROSOFT
QUANTUM DEVELOPMENT KIT WHICH IS
THE SET OF TOOLS PROVIDED BY MICROSOFT
TO HELP DEVELOPERS BUILD QUANTUM
PROGRAMS. QUANTUM PROGRAMS ARE VERY
DIFFERENT FROM CLASSICAL PROGRAMS.
CLASSICAL PROGRAM, YOU HAVE YOUR
1s AND 0s AND LOGIC TO EXPLAIN HOW
THAT INFORMATION THAT YOU HAVE STORED
ON THOSE 1s AND 0s CHANGES FROM
A STEP TO STEP. ON QUANTUM PROGRAM,
YOU ALSO STILL HAVE 1s AND 0s, BUT
THE MAIN DIFFERENCE IS THAT INSTEAD
OF JUST HAVING 1s AND 0s, YOU CAN
ACTUALLY TWEAK THE PROBABILITIES
OF GETTING A 1 AND A 0. SO AT ANY
POINT IN STAGE OF THE EXECUTION,
YOU CAN TWEAK THE PROGRAM TO TELL
IT THAT YOU HAVE A 50/50 CHANCE
OF 1s AND 0s OR ANY NUMBER. MOREOVER,
THE WAY YOU CHANGE THOSE PROBABILITIES
IS BY LEVERAGING QUANTUM MECHANICS.
AND THEREFORE THE QUANTUM NAME.
SO ON EVERY STEP, YOU ACTUALLY CHANGE
THE PROBABILITIES, YOU SEE QUANTUM
MECHANICS PRINCIPLES. SO THE POINT
OF ALL THIS IS NOT TO SAY THAT QUANTUM
PROGRAMS OR YOU HAVE TO USE QUANTUM
MECHANICS. BECAUSE WE'RE NOT NECESSARILY
THAT HARD, DEPENDS ON THE AGENT
AL GO IT USES A PROBABILITY WILL
ACTUALLY RUN FASTER. YOU ACTUALLY
HAVE TO DESIGN PROGRAMS THAT LEVERAGE
THIS PROBABILITIES AND LEVERAGE
THIS QUANTUM MECHANICS TO DO THE
THINGS DIFFERENTLY, TAKE THE LESS
NUMBER OF THE STEPS AND THEREFORE
RUN FASTER. SO WITH THIS IN MIND
-- THANK YOU. WE DON'T EXPECT QUANTUM
CAN COMPUTER TO ACTUALLY REPLACE
A CLASSICAL COMPUTER. THE WAY WE
ACTUALLY THINK ABOUT THIS IS THAT
YOU HAVE YOUR QUANTUM PROGRAMS THAT
CAN BE MORE -- THAT CAN BE EXECUTED
ON THIS QUANTUM PROCESSOR, ON THIS
QUANTUM COMPUTER. BUT YOU STILL
HAVE YOUR CLASSICAL APPLICATIONS
THAT WILL DO MORE EFFICIENTLY ON
THE CLASSICAL PROGRAM ARE LIKELY
TO BE YOUR ENTRY POINTS AND DELAY
THE EXECUTION OF A QUANTUM ALGORITHM
OR A PROGRAM INTO A QUANTUM PROCESSING
UNIT. ON THE QUANTUM DEVELOPMENT
KIT THAT WE HAVE RELEASED, THE WAY
YOU WRITE YOUR QUANTUM PROGRAMS
IN ITS OWN LANGUAGE, WE HAVE CREATED
A LANGUAGE FROM THE GROUND UP CALLED
Q# TO HELP YOU WRITE THESE PROGRAMS
THAT WILL EXECUTE ON THE QUANTUM
PROCESSOR. AS PART OF THE QUANTUM
DEVELOPMENT KIT, YOU START THE EXCUSE
ON A CLASSICAL PROGRAM. AND AT RUN
TIME, YOU LOAD YOUR Q# OPERATION,
AND INDICATE WHAT TARGET MACHINE
YOU WANT TO RUN THIS ON. SO NOW
DAYS YOU CAN EXECUTE THE Q# OPERATION
ON A QUANTUM SIMULATOR THAT RUNS
ON YOUR OWN DESK TOP. YOU CAN RUN
ON AZURE. OR YOU CAN RUN ON THEM
OTHER THINGS WHERE INSTEAD OF EXECUTING
THE ENTIRE PROGRAM, WILL JUST CALCULATE
HOW MANY ACTUAL QUANTUM RESOURCE,
HOW MANY OPERATIONS IT WILL TAKE
IF YOU WANT TO EXECUTE THAT PROGRAM
ON AN ACTUAL COMPUTER. IN THE FUTURE,
YOU WILL BE ABLE TO TARGET QUANTUM
PROCESSING UNIT THAT IS RUNNING
ON YOUR DESK TOP, FOR EXAMPLE, OR
YOU COULD TARGET A QUANTUM MACHINE
RUNNING ON AZURE OR OTHER DIFFERENT
TYPES OF SIMULATORS. WHEN WE LAUNCH
THE QUANTUM DEVELOPMENT KIT ABOUT
A YEAR AGO, YOU COULD ONLY WRITE
YOUR CLASSICAL PORTIONS, CLASSICAL
PARTS OF THE PROGRAM ON C# OR .
NET CORE LANGUAGE, VISUAL BASIC
AND SUCH. BUT AS WE HAVE EVOLVED
OVER TIME, NOW WE GIVE YOU MORE
FLEXIBILITY AND MORE SPECIFICALLY,
SIMULATE THESE Q# OPERATIONS ON
BOTH PYTHON AND JUPYTER. JUPYTER
FOR THOSE NOT FAMILIAR IS A FRAMEWORK
THAT ALLOWS YOU TO BUILD INTERACTIVE
NOTEBOOKS. SO YOU CAN ACTUALLY EXECUTE
THESE NOTEBOOKS ON THE BROWSER.
AND WITHIN THE NOTEBOOK, YOU CAN
DEFINE CELLS OF CODE THAT YOU CAN
MODIFY THERE ON THE SPOT AND EXECUTE
ON THE SPOT. DIRECTLY ON YOUR BROWSER.
OUT OF THE BOX, JUPYTER CAME WITH
INTEGRATION WITH PYTHON WHICH IS
HOW IT WAS WRITTEN. BUT THEY PROVIDED
THE HOOKS TO ADD YOUR OWN LANGUAGES
SO THERE HAS BEEN INTEGRATION KERNELS
CREATED FOR C#, FOR R, F SHARP AND
NOW AN INTEGRATION FOR Q#. THIS
GET INTEGRATION ALLOWS YOU TO WRITE
ON THE DIRECTLY BROWSER WITHOUT
HAVING TO WRITE C# CODE. SO YOUR
CLASSICAL PORTION IS STILL ON JUPYTER.
AND NOW YOU CAN JUST FOCUS OR WRITE
YOUR QUANTUM OPERATIONS ON JUPYTER
DIRECTLY. AGAIN, ON TOP OF JUPYTER,
WE HAVE BUILT TO RUN THIS ON PYTHON.
AND FROM PYTHON, YOU LOAD YOUR Q#
OPERATION. AND THEN IT'S GOING --
IT'S VERY EASY TO ASK IT TO SIMULATE
THE OPERATION PASSING THE PARAMETERS
IT REQUIRES. WITH THAT IN MIND,
I'M GOING TO NOW AND CHRIS TO TAKE
OVER AND SHOW YOU THE ACTUAL CODE
RUNNING ON PYTHON AND HOW THAT WORKS.
>> ALL RIGHT, WELL, THANK YOU VERY
MUCH. SO BY WAY OF AN EXAMPLE OF
SHOWING SOME OF THE TECHNOLOGIES
THAT ANDRES MENTIONED, IT'S A LITTLE
BIT OF A WHIMSICAL NAME. AS MANY
THINGS IN QUANTUM COMPUTING ARE.
BUT POINTS ARE USEFUL WAY TO MOVE
DATA AROUND A QUANTUM COMPUTER.
SO HERE I'VE GOT JUST A STANDARD
JUPYTER NOTEBOOK INTERFACE WITH
A COUPLE DIFFERENT NOTEBOOKS INCLUDING
TELEPORTATION, HERE AS A Q# NOTEBOOK.
YOU CAN TELL BY THE LOGO IN THE
UPPER RIGHT-HAND CORNER THAT THIS
IS A Q# NOTEBOOK RATHER THAN A PYTHON
NEAT BOOK. -- PYTHON NOTEBOOK. AND
I CAN WRITE MY CODE HERE. I WILL
TAKE A STAB AT WRITING A ALGORITHM.
AT THE MOMENT, IT WILL FEEL LIKE
ASSEMBLY, BUT WHEN I RUN IT USING
SHIFT-ENTER, THE IQ SHARP KERNEL
WILL COMPILE THAT QUANTUM OPERATION
TO SOMETHING THAT WE CAN THEN SEND
TO A TARGET MACHINE. I GET AT THE
BOTTOM, A MESSAGE SAYING THAT IT
WAS SUCCESSFULLY COMPILED AND IT'S
READY TO GO. MAYBE I DON'T UNDERSTAND
HOW THIS WORKS BECAUSE I SEE THIS
THING THAT ISN'T REALLY CLEAR TO
ME. SO I CAN USE JUPYTER NOTEBOOK
FEATURES LIKE DOCUMENTATION TO GET
A SUMMARY OF WHAT THE OPERATION
DOES TO REMIND ME SO I CAN HELP
UNDERSTAND. ONCE I'M READY, I CAN
THEN RUN IN OPERATION ON ONE OF
THE TARGET MACHINES THAT YOU SAW
EARLIER SUCH AS THE QUANTUM SIMULATOR.
AND HERE I GET OUT THE OUTPUT RETURNED
BY THAT QUANTUM PROGRAM RUNNING
JUST ON MY SERVICE GO HERE, A QUANTUM
-- A SIMULATION OF HOW THAT WOULD
ACT ON ACTUAL QUANTUM HARDWARE.
I CAN GO FURTHER AND WRITE THINGS
OUT IN MULTIPLE CELLS TO ISOLATE
AND UNDERSTAND EACH DIFFERENT PIECE
AS I GO ALONG. I CAN USE THINGS
FROM THE LIBRARIES PROVIDED WITH
THE DEVELOPMENT KIT. THE RESET OPERATION
YOU SAW EARLIER IS ONE OF THE THINGS
OFFERED BY THE MICROSOFT QUANTUM
MEASUREMENT NAME SPACE. AND I CAN
OPERATE, AND BUILD UP MORE COMPLEX
PROGRAMS AND UNDERSTAND THEM THIS
WAY USING THE JUPYTER NOTEBOOK INTERFACE.
DOING THIS, IT ALLOWS ME TO FOCUS
ON AND DESCRIBE THE ALGORITHM THAT
I'M TRYING TO UNDERSTAND. IN THIS
CASE, TELEPORTATION. AND RUN FINALLY
MY TAKE TWO OF IT HERE AT THE BOTTOM
USING ANOTHER SIMULATE COMMAND TO
THE IQ SHARP NOTEBOOK. LET'S DO
THIS ONCE MORE WITH FEELING AND
DO SOMETHING A LITTLE BIT MORE FUN.
I MEAN, SO FUN, I TO INCLUDE AN
EMOJI FOR IT. AND TELEPORT NOW ARBITRARY
KINDS OF STATES BY USING FEATURES
OF Q# SUCH AS PASSING AROUND --
YOU CAN PASS OPERATIONS TO OTHER
OPERATIONS AS FIRST CLASS VALUES.
SO THIS LET'S ME WRITE OUT QUANTUM
ALGORITHMS IN A COMPACT WAY THAT
MAKES IT EASY TO BREAK DOWN AND
UNDERSTAND. WHEN I RUN THAT, I GET
ALL OF THE UNIT TESTS THAT I WROTE
OUT. CORRECTLY. AND I GET THE MESSAGE
BACK THAT SAYS IT WORKED CORRECTLY.
WE CAN ALSO DO THIS FROM PYTHON.
SO AS YOU HEARD A MOMENT AGO, SO
WHAT WE JUST SAW WAS USING C# ON
ITS OWN IN A NOTEBOOK, BUT WE CAN
MIX WITH OTHER KINDS OF MORE CONVENTIONAL
CLASSICAL PROGRAMMING SUCH AS USING
A PYTHON NOTEBOOK FROM WITHIN JUPYTER.
SO DOING THIS AS WELL NOW. WE CAN
IMPORT THE Q# PACKAGE. AND THIS
WILL GIVE US ACCESS TO THINGS LIKE
ALLOWING US TO COMPILE OPERATIONS
ON THE FLY AND SAVE THEM INTO PYTHON
OBJECTS WHICH WE CAN THEN USE THE
SIMULATE METHOD ON IN A VERY SIMILAR
FASHION, SEND THEM TO TARGET MACHINES
FOR EXECUTION. SO IT WILL TAKE JUST
-- SO WE CAN GET THE SAME MESSAGE
BACK TELLING US THAT IT WORKED CORRECTLY.
AND DOING THAT, I CAN ALSO GET ACCESS
TO OTHER TARGET MACHINES SUCH AS
THE RESOURCES ESTIMATOR WHICH GIVES
ME A BREAK DOWN OF WHAT GATES AND
OPERATIONS I NEEDED TO USE TO RUN
THAT. SO THAT AS I SCALE UP AN ALGORITHM
TO LOOK AT LARGER AND LARGER INSTANCES
BEYOND LOCALLY ON SAY A SERVICE
GO, I UNDERSTAND WHAT RESOURCES
WOULD BE REQUIRED TO RUN THAT ON
ACTUAL QUANTUM HARDWARE. YOU CAN
ALSO IMPORT OPERATIONS THAT YOU'VE
WRITTEN IN Q# INTO PYTHON RATHER
THAN JUST HAVING TO COMPILE EVERYTHING
ON THE FLY. SO THERE'S A LOT OF
DIFFERENT WAYS OF EXPLORING AND
USING Q# FROM JUPYTER AS A PLATFORM.
BUT ONE OF THE THINGS THAT'S REALLY
COOL IS HOW EASY IT IS TO GET UP
AND RUNNING WITH ALL OF THIS USING
THE OPEN SOURCE TECHNOLOGIES PROVIDED
WITH . NET CORE. YOU CAN RUN TWO
COMMANDS TO ADD IQ SHARP TO THE
EXISTING JUPYTER ENVIRONMENT. AND
THAT PROVIDES EVERYTHING THAT YOU
NEED. TO GET IN AND EXPLORE AND
GET STARTED WITH. PLEASE IF YOU'RE
INTERESTED, CHECK OUT THE DOCUMENTATION.
WE'VE GOT AN ONLINE VERSION OF THIS
THAT YOU CAN TRY WITHOUT INSTALLING
ANYTHING. AND THERE'S A GROWING
COMMUNITY AROUND THAT WE INVITE
YOU TO TAKE A PART IN. SO THANK
YOU VERY MUCH. [ APPLAUSE ] >> WE
HAVE -- WE ARE IN A BOOTH ON THE
APP SECTIONS. IF ANYONE HAS QUESTIONS
AND WOULD LIKE TO FOLLOW UP WITH
US, ANYTHING, PLEASE COME BY AND