DEV Community: Chris Granade

Quantum libraries are wonderful

Chris Granade — Mon, 20 Jan 2020 21:00:30 +0000

In my first FAQ# post, I described a bit about my life as a quantum developer, and how I came to work on developing quantum computing libraries.

What is a quantum developer, anyway?

Chris Granade ・ Jan 5 '20 ・ 5 min read

#qsharp #quantumcomputing

That raises a few more questions, though, that I'd like to start answering today: what is a quantum library, anyway, and what libraries are already out there? In future posts, I'd also like to share some As usual, I find it helps to start by taking a step back and thinking about what might be analogous in traditional software development.

What is a library?

Computers aren't that old in the history of things, but they've definitely changed a lot since they first came around. At some point not too far in the past, a skilled programmer or a small team of programmers could write all the software that ran on a computer.

As computers have grown and proliferated over the decades, however, they've very quickly reached the point where it simply isn't possible to understand all the software powering a particular application, let alone to write it. In much the way that science must be a social enterprise to deal with the limits of what any one human can do, software development thus has to be a similarly social enterprise. To help out, we've developed a variety of different abstractions to help us share our work and build stuff together as a community.

Software libraries are one really great example of that kind of social abstraction: rather than writing an entire software stack from the ground up, you can leverage what other members of your community have done before you. For instance, the NumPy library for Python has helped out physicists, data scientists, statisticians, machine learning developers, and any other number of other people get stuff done that they care about.

>>> import numpy as np
>>> H = np.array([[1, 1], [1, 1]]) / np.sqrt(2)
>>> zero_state = np.array([[1], [0]])
>>> H @ zero_state
array([[0.70710678],
       [0.70710678]])

At its core, a software library is a way of packaging up a bunch of code in a way that makes it easy for other developers to reuse, whether that code gets packaged as a Python wheel, an npm package, or as a NuGet package.

Make it quantum

OK, so let's bring it back to quantum computing. Already, we're past the days where a single person can understand every single step in a quantum application — and that's a great thing! It means we have that much more to learn from each other, and that much more of an opportunity to build off each others' work.

When you write a quantum program in Q#, you can call functions and operations from different Q# libraries to make your life easier and to help you focus on the quantum application in front of you. For example, in Chapter 9 of our book (coming soon!), Sarah Kaiser and I use the Q# libraries to help our readers focus on what a quantum program to simulate chemistry problems might look like:

operation EstimateH2Energy(idxBondLength : Int) : Double {
    let nQubits = 2;
    let trotterStepSize = 1.0;
    let trotterStep = ApplyHamiltonian(idxBondLength, trotterStepSize, _);
    let estPhase = EstimateEnergy(nQubits, 
                                  PrepareInitalState, 
                                  trotterStep, 
                                  RobustPhaseEstimation(6, _, _));
    return estPhase / trotterStepSize + H2IdentityCoeff(idxBondLength);
}

In this snippet, EstimateEnergy and RobustPhaseEstimation are both provided by the standard libraries that come with the Q# language, and provide us with a lot of the infrastructure we need to quickly build and explore quantum chemistry applications.

microsoft / QuantumLibraries

Q# libraries for the Quantum Development Kit

Microsoft Quantum Development Kit Libraries

Welcome to the Microsoft Quantum Development Kit!

This repository contains open-source libraries for the Quantum Development Kit:

Docs/: Additional documentation for developing on the libraries. Please see QDK online documentation for online documentation.
Standard/: Q# sources used to implement the Q# standard libraries.
Chemistry/: Q# and C# sources used to implement a library for quantum chemistry and Hamiltonian simulation.
Numerics/: Q# sources used to implement the quantum numerics library.
LICENSE: Terms of use and license details for the Quantum Development Kit libraries.

New to Quantum?

See the introduction to quantum computing provided with the Quantum Development Kit.

Getting Started

The libraries provided in this repository are built using .NET Core and the Quantum Development Kit Please see the installation guide for how to get up and running.

You may also visit our Quantum repository, which offers…

View on GitHub

Of course, it's not just quantum subroutines like phase estimation and amplitude amplification that come along with Q#. The forthcoming samples for the quantum machine learning library for Q# show how the Q# standard libraries make it easy for you to use functional programming concepts in your QML workflow:

function WithOffset(offset : Double, sample : Double[]) : Double[] {
    return Mapped(TimesD(offset, _), sample);
}

function WithProductKernel(scale : Double, sample : Double[]) : Double[] {
    return sample + [scale * Fold(TimesD, 1.0, sample)];
}

function Preprocessed(samples : Double[][]) : Double[][] {
    let offset = 0.75;
    let scale = 1.0;

    return Mapped(
        Compose(
            WithOffset(offset, _),
            WithProductKernel(scale, _)
        ),
        samples
    );
}

The functions that the Q# standard library provides for working with arrays makes it really easy to quickly build up the kind of data processing that we need to work with quantum devices, as I talked about on Twitter a little while ago.

Liquid error: internal

Things get really cool, though, when you use these kinds of classical development concepts together with quantum ideas to build up quantum programs in a quick and powerful way. For instance, if someone asks you to prepare some qubits in a state like (|0000⟩ + |1111⟩) / √2 (a so-called "cat state," really useful in doing error correction), you could do that by hand simply enough in Q#:

operation PrepareCatState(register : Qubit[]) : Unit is Adj + Ctl {
    H(register[0]);
    CNOT(register[0], register[1]);
    CNOT(register[0], register[2]);
    CNOT(register[0], register[3]);
}

This looks a lot like an unrolled loop, though, so you could also just... write the loop!

operation PrepareCatState(register : Qubit[]) : Unit is Adj + Ctl {
    H(register[0]);
    for (target in register[1...]) {
        CNOT(register[0], target);
    }
}

Using functional concepts and partial application together, you can make it even easier still:

open Microsoft.Quantum.Arrays;

operation PrepareCatState(register : Qubit[]) : Unit is Adj + Ctl {
    H(Head(register));
    ApplyToEachCA(
        CNOT(Head(register), _),
        Rest(register)
    );
}

By using ApplyToEachCA, together with array functions like Head and Rest, your cat state preparation operation works no matter how many qubits are in register, and is easy-to-read to boot.

Using the Q# together with Jupyter Notebooks, it's pretty easy to explore how this all works, too (you can even run this example online!):

The Quantum Development Kit libraries

In Q#, quantum libraries are distributed using NuGet, an open-source package manager from the .NET Foundation. If you've used C#, PowerShell, or Chocolatey, you've probably already worked with NuGet, but at a high-level, NuGet is pretty similar to PyPI, npm, or other package management systems.

TIP

The main difference between how Python and Q# handle packages is that in Q#, packages and namespaces are separate concepts; a package can contain however many namespaces, and namespaces can even be split across packages.

If you're using Q# from Python, you can import NuGet packages into your session with the qsharp.packages.add method. For example:

import qsharp

print("Loading the numerics library...")
qsharp.packages.add("Microsoft.Quantum.Numerics")
print("Done. Running program...")
qsharp.reload()

from Microsoft.Quantum.Numerics.Samples import CustomModAdd

On the other hand, if you're using Q# from C#, you can include new Q# libraries by adding them as <PackageReference /> elements in your project file:

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>netcoreapp3.0</TargetFramework>
    <PlatformTarget>x64</PlatformTarget>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Microsoft.Quantum.Development.Kit" Version="0.10.1912.501" />
    <PackageReference Include="Microsoft.Quantum.Standard" Version="0.10.1912.501" />
    <PackageReference Include="Microsoft.Quantum.Numerics" Version="0.10.1912.501" />
  </ItemGroup>

</Project>

Looking at the list of Quantum Development Kit packages on nuget.org, you can see a bunch of different packages, many of which are used to provide the Q# compiler, simulators, Jupyter integration, and so forth. There's also four different Q# libraries in the list so far:

If you've written any Q# program, you've probably used the Microsoft.Quantum.Standard package, as it provides the standard libraries for Q#, including a wide variety of both basic classical and quantum functionality; for example:

The standard library provides all the basics you need to write quantum programs, just like standard libraries in languages like Python and C# give you the basics you need to write traditional programs.

Moving on from the standard library, the Microsoft.Quantum.Chemistry and Microsoft.Quantum.Numerics packages use the standard library to address specific problem domains. For instance, Microsoft.Quantum.Chemistry provides powerful tools for solving quantum chemistry problems with quantum computing. Similarly, the Microsoft.Quantum.Numerics package provides tools needed to work with integer and fixed-point numbers represented by registers of qubits, and even to evaluate polynomials on quantum devices. Both the chemistry and numerics libraries differ from the standard library in that they more specifically target and support specific kinds of quantum applications.

The last of the Q# libraries provided with the Quantum Development Kit is the Microsoft.Quantum.Research package. As the name suggests, this package is a bit more focused on research usage of the Quantum Development Kit, providing implementations of Microsoft's cutting-edge research contributions in chemistry and phase estimation.

Conclusion

Both the Q# standard and domain-specific libraries are examples of how traditional software development concepts like libraries and packages can help make quantum development easier. If there's something you'd like to see out of the Q# libraries, go on and suggest it on GitHub, or even take a stab at contributing new library features!

After all, quantum computing is a community effort that takes developers with a wide range of different skills; what you uniquely bring is part of what makes this a great community!

If you like this post, read more at my blog, or read Learn Quantum Computing with Python and Q#, now available in early access from Manning Publications.

Some useful skills for quantum computing

Chris Granade — Mon, 13 Jan 2020 04:46:53 +0000

If you're reading this, you've probably also read about some of the neat things you can do with Q# and quantum computing, and are eager to try out this whole quantum development thing. Like any other part of computing and development, there's some skills that can really help you out on your way, so in this post I'll talk about what some of those skills are and how you can practice the non-quantum stuff that will make your quantum journey a bit easier.

Before that, though, it's worth mentioning a small bit of a disclaimer. There's no one right skillset that you need for quantum computing. In my previous post, I talked a bit about my path towards quantum computing, and about how rewarding it can be to work with people that come at things from a different perspective and background. As you go forward with quantum computing, you'll find your own way to make a difference, your own way to leave both the technology and the community better than how you found it. Thus, my focus here isn't on what skills you need, but what skills can be useful. You don't need to be an expert in everything or even any one thing in particular in order to get going with quantum computing.

With that caveat in mind, then, let's get down to brass tacks and explore some things you may find helpful along your way.

Math

Even though it's not required, being comfortable with math can be really quite helpful as a quantum developer. Most documentation in quantum programming languages involves at least a bit of math, so being familiar with a few mathematical concepts can help you make the most out of the resources that are already out there. The most fundamental descriptions of quantum computing are expressed using ideas from linear algebra and complex numbers, such that a familiarity with each can help you peel back the layers a bit and see how things work.

That doesn't mean you're doing quantum computing on hard mode if you aren't a PhD-level mathematician, though. Really, this is another way that quantum computing is a lot like other areas of computing. If you try to read about OpenGL, knowing some math will help you get the most out of documentation. Similarly, machine learning involves a fair bit of math, you can also get quite a ways by following along with examples or using high-level libraries.

What's really exciting, though, is that you can also practice your math skills as you go. In our Q# book, Sarah Kaiser and I write most of our the QuTiP package for Python to handle doing most of the math, so that you can jump right in and see how things work without having to do all of the math yourself.

If you want to preload things a bit, though, refreshing your memory on linear algebra and complex numbers will give you a head start with quantum computing content.

Classical Software Development

As I talked about in my previous post, many of the skills that help me out the most as a quantum developer are classical software development skills. Brushing up on classical languages like Python or C#, unit testing, how to manage projects with Git, how to work with containers, how to write and test code with an IDE, or any number of other skills can help you contribute to open source quantum projects, and can help you to make progress with your own projects.

Thankfully, there's a lot of good resources to help you out here, dev.to itself not the least of them! If you're already a seasoned software developer, that will help you out as you go forward with quantum computing. On the other hand, if you're new to software development, welcome! Your original way of looking at and learning about computing will help you make a difference with quantum computing.

Writing

There's no way to underestimate this one. Quantum computing is a big field, bringing together a lot of different ideas and ways of looking at the world. That means that as you progress through your quantum computing journey, you'll write e-mails, tweets, blog posts, documentation, and many other kinds of things in order to communicate those ideas with your community.

That's not to say you need to be an amazing novelist, of course (though if you are, awesome! 💖). Rather, my point is that math and prose go hand-in-hand for communicating quantum ideas. Being comfortable with writing isn't necessary to get started in quantum computing, but it can help you ask questions on StackOverflow that help others on their journey, to file informative and descriptive bug reports, to improve Wikipedia articles that others use to look up quantum concepts, and can help you explain ways of looking at quantum computing that you found useful. As you build your own quantum projects, your writing skills can help you make documentation that lowers barriers instead of raising them.

In my experience, there's two main parts to getting better at writing. The first? Reading. Spend time on dev.to, Twitter, StackExchange, arXiv, and whatever other platforms you find useful for talking about quantum computing. Pay attention to what things other writers do that help you, and what things make it harder for you to learn, so that you can use that in your own writing. The other part of brushing up on writing skills, of course, is to practice. Even if you think it's crappy, writing a lot can help you find a voice that you can use to make the quantum computing community that much more wonderful.

Empathy

The last and absolute most important skill that I can suggest practicing is empathy; it may even be the only mandatory skill on this list. Quantum computing, just like every other kind of computing, is a thing that humans do. Listening to those humans — your peers! — can help you understand where they get stuck and might need a little help, where they need your help making the community the best it can be, and where they might be able to help you get unstuck.

Your peers in the quantum community come from all walks of life, not just in terms of skills, but also in terms of who they are as people. The quantum computing community includes people of all genders, sexualities, races, nationalities, and kinds of disabilities. Listening to your peers can help you break down the barriers that they face in any number of small and large ways. By putting empathy into practice, you can ensure that you not only make a difference in the quantum community, but that you make a difference for the better.

If you like this post, read more at my blog, or read Learn Quantum Computing with Python and Q#, now available in early access from Manning Publications.

What is a quantum developer, anyway?

Chris Granade — Sun, 05 Jan 2020 21:50:15 +0000

Quantum computing has been, to put it mildly, in the news a bit as of late.
With so many different announcements about and developments in quantum computing, it can feel a bit daunting to jump in and get started. Sometimes, quantum computing can even pick up an air of mystique about it, given popular analogies such as "two places at once," "action at a distance," and other pretty confusing explanations.

While there's thankfully quite a range of good content out there to help you get started, it can still be hard to get a feeling for what it's like to actually be a quantum developer. As I talk to people at the bar, in carpools, on Twitter, at conferences, and the like, saying that I work on quantum computing can be a bit of a conversation killer; sure quantum computing is cool, but what do I do? With this post, I'd like help to demystify things a little bit by talking about what quantum development is like for me as I go about my day.

WHOAMI?

But first because everyone's path to quantum development looks different, a little bit about myself can provide some helpful context. I'm Chris Granade, a research software development engineer in the Quantum System group at Microsoft. Before that, I did a triple-major at the University of Alaska Fairbanks, a Masters degree at the Perimeter Institute, a PhD at the Institute for Quantum Computing, and a postdoc at the University of Sydney. Needless to say, learning about quantum computing has been a bit of a thing for me throughout much of my life. In my spare time, I'm as liable to be shitposting surreal memes, planning a World of Darkness tabletop campaign, or taking our adorable puppy for a walk to one of Seattle's surprisingly numerous dog-friendly breweries.

insert pun here

Given that, one might think I spend all day buried in obscure journal papers, nose-deep in a pen-and-paper calculation, or scrawling at a chalkboard. While those are all completely valid and useful ways of working on quantum computing, I've tried my hand at them and found that at least for myself, there are other ways I can contribute.

Even before starting in undergrad, for example, I have always found a joy in solving problems using programming. I got my start back with QBASIC and GWBASIC (yes, I am officially an Old; I'm also a Millennial, somehow?), and loved that I could use programming to get answers to things I was curious about. When I wanted to understand population growth and how that affected ecology better, I borrowed my mom's population dynamics textbook and started programming things up as VBA macros in Excel.

As it turns out, that's a great approach to working with quantum computing as well. Building a quantum computer is hard, and there's lots of ways that classical computers help us out on our way there. We can use classical computers to model what we want quantum computers to do, using linear algebra packages to help us out, or we can use classical computers to run statistical inference algorithms on the data we get back from quantum devices to help us understand how to make better ones.
Of course, we can go much further as well and use classical computers to write and test the actual programs we want to run on quantum computers; hence the emergence of quantum programming languages like Q#!

So, what do you do?

As soon as you start using classical computers to solve problems of any sort, you get back into the fun issues of building, testing, packaging, deploying, and designing classical software. Recently, as a part of the 2019 Q# Advent Calendar, Andres Paz explained many of the pieces that make up Q# and the Quantum Development Kit. Making Q# work involves writing classical compilers and simulators, integrating with existing languages like C# and Python, making editor integration extensions to help us write quantum programs in the first place, writing documentation for everything, and even making Docker containers to power online-first experiences for Q#. This is a team effort, as designing, building, and maintaining the Quantum Development Kit necessarily involves more kinds of expertise what any one member of the team brings with them.

For myself, I tend to fit into that team effort by designing and maintaining the different Q# libraries that come with the QDK, and by working with domain experts to make those libraries as awesome as they can be. This means that a large part of my day is writing unit tests in Q#, fixing things when builds fail, reading through pull requests, and working on the best way to package things up so that other quantum developers can make use of the code that I help out with. If you're curious to see more of what I do, follow me on GitHub! Since the Quantum Development Kit is open source, you can follow along as we add new features, fix bugs, introduce new bugs, and otherwise do what you'd expect software developers to do.

Put differently, a large part of the skills that help me as a quantum developer are the same skills that help out in any other software development engineering role. While I do use the skills that I've learned throughout my quantum computing training on a daily basis, it's the traditional software development engineering practices that give me the basis I need to make use of those skills.

There's a point to all this, right?

As you get involved in quantum computing, you'll bring your own skills, background, and experience to what you do. There's no one way to be a quantum developer, or to contribute to the quantum computing community. My hope is that by showing my particular path, I can provide an example of the way I use my particular background to help the community. Your path will look different, and that's not just OK but wonderful. The breath of different skills and backgrounds that come to bear on quantum computing is one of the most amazing things about this field. You'll do amazing things here, and you'll do them your way.

If you like this post, read more at my blog, or read Learn Quantum Computing with Python and Q#, now available in early access from Manning Publications.