Cloud Hosting

WebAssembly has come a long way from the browser; it can be used for building high-performance web applications, for serverless applications, and for many other uses.

Recently, we also spotted it as a key technology used in creating and controlling a previously theoretical state of matter that could unlock reliable quantum computing for the same reasons that make it an appealing choice for cloud computing.

Quantum computing uses exotic hardware (large, expensive and very, very cold) to model complex systems and problems that need more memory than the largest supercomputer: it stores information in equally exotic quantum states of matter and runs computations on it by controlling the interactions of subatomic particles.

But alongside that futuristic quantum computer, you need traditional computing resources to feed data into the quantum system, to get the results back from it and to manage the state of the qubits to deal with errors in those fragile quantum states.

As Dr. Krysta Svore, the researcher heading the team building the software stack for Microsofts quantum computing project, put it in a recent discussion of hybrid quantum computing, We need 10 to 100 terabytes a second bandwidth to keep the quantum machine alive in conjunction with a classical petascale supercomputer operating alongside the quantum computer: it needs to have this very regular 10 microsecond back and forth feedback loop to keep the quantum computer yielding a reliable solution.

Qubits can be affected by whats around them and lose their state in microseconds, so the control system has to be fast enough to measure the quantum circuit while its operating (thats called a mid-circuit measurement), find any errors and decide how to fix them and send that information back to control the quantum system.

Those qubits may need to remain alive and remain coherent while you go do classical compute, Svore explained. The longer that delay, the more theyre decohering, the more noise that is getting applied to them and thus the more work you might have to do to keep them stable and alive.

There are different kinds of exotic hardware in quantum computers and you have a little more time to work with a trapped-ion quantum computer like the Quantinuum System Model H2, which will be available through the Azure Quantum service in June.

That extra time means the algorithms that handle the quantum error correction can be more sophisticated, and WebAssembly is the ideal choice for building them Pete Campora, a quantum compiler engineer at Quantinuum, told the New Stack.

Over the last few years, Quantinuum has used WebAssembly (WASM) as part of the control system for increasingly powerful quantum computers, going from just demonstrating that real-time quantum error correction is possible to experimenting with different error correction approaches and, most recently, creating and manipulating for the first time the exotic entangled quantum states (called non-Abelian anyons) that could be the basis of fault-tolerant quantum computing.

Move one of these quasiparticles around another like braiding strings and they store that sequence of movements in their internal state, forming whats called a topological qubit thats much more error resistant than other types of qubit.

At least, thats the theory: and WebAssembly is proving to be a key part of proving it will work which still needs error correction on todays quantum computers.

Were using WebAssembly in the middle of quantum circuit execution, Campora explained. The control system software is preparing quantum states, doing some mid-circuit measurements, taking those mid-circuit measurements, maybe doing a little bit of classical calculation in the control system software and then passing those values to the WebAssembly environment.

In cloud, developers are used to picking the virtual machine with the right specs or choosing the right accelerator for a workload.

Rather than picking from fixed specs, quantum programming can require you to define the setup of your quantum hardware, describing the quantum circuit that will be formed by the qubits and as well as the algorithm that will run on it and error-correcting the qubits while the job is running with a language like OpenQASM (Open Quantum Assembly Language); thats rather like controlling an FPGA with a hardware description language like Verilog.

You cant measure a qubit to check for errors directly while its working or youd end the computation too soon, but you can measure an extra qubit (called an ancilla because its used to store partial results) and extrapolate the state of the working qubit from that.

What you get is a pattern of measurements called a syndrome. In medicine, a syndrome is a pattern of symptoms used to diagnose a complicated medical condition like fibromyalgia. In quantum computing, you have to diagnose or decode qubit errors from the pattern of measurements, using an algorithm that can also decide what needs to be done to reverse the errors and stop the quantum information in the qubits from decohering before the quantum computer finishes running the program.

OpenQASM is good for basic integer calculation, but it requires a lot of expertise to write that code: Theres a lot more boilerplate than if you just call out to a nice function in WASM.

Writing the algorithmic decoder that uses those qubit measurements to work out what the most likely error is and how to correct it in C, C++ or Rust and compiling it to WebAssembly makes it more accessible and lets the quantum engineers use more complex data structures like vectors, arrays, tuples and other ways to pass data between different functions to write more sophisticated algorithms that deliver more effective quantum error correction.

An algorithmic decoder is going to require data structures beyond what you would reasonably try to represent with just integers in the control system: it just doesnt make sense, Campora said. The WASM environment does a lot of the heavy lifting of mutating data structures and doing these more complex algorithms. It even does things like dynamic allocation that normally youd want to avoid in control system software due to timing requirements and being real time. So, the Rust programmer can take advantage of Rust crates for representing graphs and doing graph algorithms and dynamically adding these nodes into a graph.

The first algorithmic decoder the Quantinuum team created in Rust and compiled to WASM was fairly simple: You had global arrays or dictionaries that mapped your sequence of syndromes to a result.The data structures used in the most recent paper are more complex and quantum engineers are using much more sophisticated algorithms like graph traversal and Dijkstras [shortest path] algorithm. Its really interesting to see our quantum error correction researchers push the kinds of things that they can write using this environment.

Enabling software thats powerful enough to handle different approaches to quantum error correction makes it much faster and more accessible for researchers to experiment than if they had to make custom hardware each time, or even reprogram an FPGA, especially for those with a background in theoretical physics (with the support of the quantum compiler team if necessary). Its portable, and you can generate it from different languages, so that frees people up to pick whatever language and software that can compile to WASM thats good for their application.

Its definitely a much easier time for them to get spun up trying to think about compiling Rust to WebAssembly versus them having to try and program an FPGA or work with someone else and describe their algorithms. This really allows them to just go and think about how theyre going to do it themselves, Campora said.

With researchers writing their own code to control a complex and expensive quantum system, protecting that system from potentially problematic code is important and thats a key strength of WebAssembly, Campora noted. We dont have to worry about the security concerns of people submitting relatively arbitrary code, because the sandbox enforces memory safety guarantees and basically isolates you from certain OS processes as well.

Developing quantum computing takes the expertise of multiple disciplines and both commercial and academic researchers, so there are the usual security questions around code from different sources. One of the goals with this environment is that, because its software, external researchers that were collaborating with can write their algorithms for doing things like decoders for quantum error correction and can easily tweak them in their programming language and resubmit and keep re-evaluating the data.

A language like Portable C could do the computation, but then you lose all of those safety guarantees, Campora pointed out. A lot of the compilation tooling is really good about letting you know that youre doing something that would require you to break out of the sandbox.

WebAssembly restricts what a potentially malicious or inexpert user could do that might damage the system but also allows system owners to offer more capabilities to users who need them, using WASI the WebAssembly System Interface that standardizes access to features and services that arent in the WASM sandbox.

I like the way WASI can allow you, in a more fine-grained way, to opt into a few more things that would normally be considered breaking the sandbox. It gives you control. If somebody comes up to you with a reasonable request that that would be useful for, say, random number generation we can look into adding WASI support so that we can unblock them, but by default, theyre sandboxed away from OS things.

In the end, esoteric as the work is, the appeal of WebAssembly for quantum computing error correction is very much what makes it so useful in so many areas.

The web part of the name is almost unfortunate in certain ways, Camora noted, because its really this generic virtual machine-stack machine-sandbox, so it can be used for a variety of domains. If you have those sandboxing needs, its really a great target for you to get some safety guarantees and still allows people to submit code to it.

The rest is here:
How WASM (and Rust) Unlocks the Mysteries of Quantum Computing - The New Stack