Formalism-agnostic Quantum Hardware Simulation

Stefan Krastanov | UMass Amherst

U. Arizona, Harvard, MIT, Yale, BYU, U. Chicago, Howard University, U. Oregon, UMass Amherst, NAU

The Quantum Technology Stack

Materials

Analog Control

Noisy Digital Circuits

Error Correction

Quantum Algorithms

Full-Stack Design and Optimization Toolkit

Symbolic description of quantum logic

Declarative noise models

Translation to many simulator backends

Discrete event scheduler

High-level lego-like interface

Symbolic description of quantum logic

Build upon Symbolics.jl and many "backend" libraries.

Full Symbolic Computer Algebra System


              julia> Z₁
              |Z₁⟩
            

              julia> ( Z₁⊗X₂+Y₁⊗Y₁ ) / √2
              0.707 (|Y₁⟩|Y₁⟩+|Z₁⟩|X₂⟩)

Symbolic to Numeric Conversion


              julia> express( ( Z₁⊗X₂+Y₁⊗Y₁ ) / √2 )
              Ket(dim=4)
                basis: [Spin(1/2) ⊗ Spin(1/2)]
                 0.8535533905932736 + 0.0im
                                0.0 + 0.3535533905932737im
               -0.49999999999999994 + 0.3535533905932737im
                -0.3535533905932737 + 0.0im
            

              julia> express( Y₁⊗Y₂, CliffordRepr() )
              Rank 2 stabilizer
              + Z_
              + _Z
              ════
              + Y_
              - _Y
              ════

The express interface


              express(::Symbolic, ::Representation, ::Use)
              express_nolookup(::Symbolic, ::Representation, ::Use)

Caching with express


              julia> op = X;
              julia> express(op);
              julia> op.metadata
              Dict{...}(
                (QuantumOpticsRepr(), UseAsState()) => QuantumOptics.Operator
              )

              julia> express(op, CliffordRepr(), UseAsOperation());
              julia> op.metadata
              Dict{...}(
                (QuantumOpticsRepr(), UseAsState()) => QuantumOptics.Operator,
                (CliffordRepr(), UseAsOperation()) => QuantumClifford.sX
              )

Translation to many simulator backends


                traits = [Qubit(), Qubit(), Qumode()]
                reg = Register(traits)

A register "stores" the states being simulated.


                initialize!(reg[1], X₁)

A register's slot can be initialized to an arbitrary state, e.g. $|x_1\rangle$ an eigenstate of $\hat{\sigma}_x$.


                initialize!(reg[1], X₁)
                initialize!(reg[2], Z₁)
                apply!((reg[1], reg[2]), CNOT)

Arbitrary quantum gates or channels can be applied.


                initialize!(reg[1], X₁)
                initialize!(reg[2], Z₁)
                apply!((reg[1], reg[2]), CNOT)

Arbitrary quantum gates or channels can be applied.


              project_traceout!(reg[1], σˣ) # Projective measurement

              observable((reg[1],reg[2]), σᶻ⊗σˣ) # Calculate an expectation

Measurements and expectation values...

Automatic tracking of noise processes


                reg = Register([Qubit(), Qubit(), Qubit()])
              

                reg = Register(
                  [Qubit(), Qubit(), Qubit()]
                  [T1Decay(T₁), CoherentError(ε*σᶻ), NZ(...)]
                )
              

                reg = Register(
                  [Qubit(), Qubit(), Qubit()]
                  [T1Decay(T₁), CoherentError(ε*σᶻ), NZ(...)]
                )
                apply!((reg[1],reg[2]), CNOT; time=τ₁)
              

                reg = Register(
                  [Qubit(), Qubit(), Qubit()]
                  [T1Decay(T₁), CoherentError(ε*σᶻ), NZ(...)]
                )
                apply!((reg[1],reg[2]), CNOT; time=τ₁)
                apply!((reg[2],reg[3]), CPHASE; time=τ₂)

Discrete event scheduler

Locks and channels, message passing, delays, concurrency, agent-based sims...

Discrete event scheduler

High-level lego-like interface

Full repeater sim with automatic instrumentation.

QuantumSavory.jl

github.com/QuantumSavory

prerelease...

A few state-of-the-art Simulators

The wider Julia ecosystem

QuantumOptics.jl, ITensors.jl, Yao.jl, quantum chemistry and solid state tools, EM tools, multiphisics classical tools, etc

Most sophisticated Clifford algebra simulator

github.com/QuantumSavory/QuantumClifford.jl Multiplying two 1 gigaqubit Paulis in 32 ms.

With upcoming "Google Summer of Code" contributors working on GPU acceleration and ECC zoo.

MIT and UMass students working on code generators.

Incoming master student working on code decoders.

github.com/QuantumSavory/QuantumClifford.jl

As an "algebra" tool: random states, gate enumeration, canonicalization, partial traces, projections.

QuantumClifford.jl 

              random_stabilizer(5,10) |> 
                  canonicalize_clip! |>
                  naive_syndrome_circuit
QuantumClifford.jl

As an "circuit simulation" tool: Monte Carlo, Pauli frames, and perturbative expansions.

QuantumClifford.jl

              Dict{CircuitStatus, Num} with 3 entries:
                failure       => 4e*((1 - 3e)^3)
                false_success => 6e*((1 - 3e)^3)
                true_success  => (1 - 3e)^4 + 2e*((1 - 3e)^3)
QuantumClifford.jl

support for non-Clifford expansions, conversion to QuantumOptics.jl objects and more...

Faster-than-Clifford Bell Pair circuits

github.com/QuantumSavory/BPGates.jl
Time to perform a pair of CNOT gates, depending on formalism

Waveguide Quantum Electrodynamics

github.com/qojulia/WaveguideQED.jl
Quantum wavepacket reflected from a cavity

Taking Optimization Seriously

Even your Monte Carlo simulations should be "differentiable"!

QuantumInterface.jl

github.com/qojulia/QuantumInterface.jl

We are hiring both at UMass Amherst and MIT:
software engineering
quantum science

Message at stefankr@mit.edu, skrastanov@umass.edu

 

Including work done with Vaishnavi Addala, Shu Ge, Shayan Pardis, Chen Zhao, Hong-Ye Hu, Dirk Englund, Saikat Guha.

Consider gradschool or postdoc at UMass Amherst:

Design of optical/mechanical/spin devices with Sandia, Mitre, and MIT.

Working on practical LDPC ECC in networking and computing with CQN.

Creating new tools for the entire community.