Composable Quantum Network Modeling

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

Which formalism should I use?

Better ways to model entanglement processing¹

1. "Faster-than-Clifford Simulations of Entanglement Purification Circuits [...]"
   Addala, Ge, Krastanov
   in review

Purification of entanglement

A convenient representation for the density matrix

A few state-of-the-art Simulators

Most sophisticated Clifford algebra simulator

              random_stabilizer(5,10) |> 
                  canonicalize_clip! |>
                  naive_syndrome_circuit
            

              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)
            

Faster-than-Clifford Bell Pair circuits

QuantumSavory.jl

Symbolic description of quantum logic

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
              ════
            

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...

Discrete event scheduler

Discrete event scheduler

High-level lego-like interface

Composable Networking Protocols

Case Study on Network Modeling

The Need for Repeaters

Exponential Loss

Exponential Loss solved by Entanglement Swapping

Swapping Protocol Enabled with Minimal Composable Code

                  for (;src, dst) in edges(network)
                      @process EntanglerProt(...)
                  end
                  for node in vertices(network)
                      @process SwapperProt(...)
                      @process EntanglementTracker(...)
                  end
                

design considerations: all the state information that a node needs to track (and update)

                  for (;src, dst) in edges(network)
                      @process EntanglerProt(...)
                  end
                  for node in vertices(network)
                      @process SwapperProt(...)
                      @process EntanglementTracker(...)
                  end
                

Protocol API requirements

• metadata for describing local knowledge about the network
• querying and searching that metadata
• visualizing metadata
• composability

Composability

We are talking just about swaps here, but a plethora of other protocols might also want to run at the same time. How do you synchronize them all!?

Composability

😕 State of the art 😕
... imagine if the classical internet needed a new Transport Layer packet type for each Application Layer service ...

The tag and query API

Tagging, i.e. recording metadata

                  # in EntanglerProt
                  tag!(qubit_slot,
                       EntanglementCounterpart,
                       remote_node,
                       remote_slot)
                  

                  julia> EntanglementCounterpart(1,2)
                  Entangled to node 1, slot 2
                  

Tagging, i.e. recording metadata

              # in SwapperProt
              

              julia> EntanglementHistory(...)
              Was entangled to node 1, slot 2,
              but swapped with local slot 3,
              which was entangled to node 4, slot 5

              julia> EntanglementUpdateX(...)
              Update slot .5
              which used to be entangled to node 2, slot 3
              to be now entangled to node 1, slot 2
              

Querying metadata
(with wildcards)

              # in EntanglementTracker
              # when an EntanglementUpdate message is received
              query(localslot, EntanglementHistory,
                     pastremotenode, pastremoteslotid,
                     ❓, ❓, # who we swapped with (node, slot)
                     ❓)    # which local slot used to be entangled

              

Querying metadata
(with custom predicates)

              # in SwapperProt
              # when deciding what swap to perform
              query(wholeregister,
                    EntanglementCounterpart,
                    <(localnode), # we want only nodes on the "left"
                    ❓; # we do not care which slot
                    locked=false) # the qubit should be available