Composable API for Quantum Networking Protocols

Stefan Krastanov | University of Massachusetts Amherst

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

10k$ in mini dev grants
and bug bounties

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

QuantumSavory.jl

github.com/QuantumSavory

Composable Networking Protocols

But first! Why quantum networking?

Alice has a qubit
Alice has a qubit
Bob too
They can be entangled! \[\begin{aligned} A=|\phi_{+}\rangle=\frac{|00\rangle+|11\rangle}{\sqrt{2}}\\ B=|\psi_{-}\rangle=\frac{|01\rangle-|10\rangle}{\sqrt{2}}\\ C=|\psi_{+}\rangle=\frac{|01\rangle+|10\rangle}{\sqrt{2}}\\ D=|\phi_{-}\rangle=\frac{|00\rangle-|11\rangle}{\sqrt{2}} \end{aligned}\]
They can be entangled! \[\begin{aligned} A=|\phi_{+}\rangle=\frac{|00\rangle+|11\rangle}{\sqrt{2}}\\ B=|\psi_{-}\rangle=\frac{|01\rangle-|10\rangle}{\sqrt{2}}\\ C=|\psi_{+}\rangle=\frac{|01\rangle+|10\rangle}{\sqrt{2}}\\ D=|\phi_{-}\rangle=\frac{|00\rangle-|11\rangle}{\sqrt{2}} \end{aligned}\]
Hidden Variable theories¹
  1. Krastanov et al.
    Art installation on Non-contextual Hidden Variable theories
This nonclassical correlation can be valuable:
  • security
  • bandwidth-space tradeoffs
  • sensing
  • networking quantum computers
  • Nature seems to abhor it

Case Study on Network Modeling

The Need for Repeaters

Exponential Loss

Raw entangled fiber links can not be longer than a few km.

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

More Sophisticated Protocols: Switches

More Sophisticated Protocols: Switches


                  for ((client1, client2), rate) in zip(client_pairs, rates)
                      @process make_request(...)
                  end
                  for client in clients
                      @process EntanglementTracker(...)
                  end
                  @process SimpleSwitchDiscreteProt(...)

Other Examples:
Swappers on a grid

We are hiring
(remote worldwide):
software engineering
quantum science

Message at skrastanov@umass.edu

 

10k$ in code bounties at
github.com/QuantumSavory

 

Options for larger dev grants as well!

Consider gradschool or postdoc
at UMass Amherst:

Design of quantum hardware.

Working on practical LDPC ECC.

Creating new tools for the entire community.