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

10k$ in mini dev grants

and bug bounties

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}\]

- Krastanov et al.Art installation on Non-contextual Hidden Variable theories

- security
- bandwidth-space tradeoffs
- sensing
- networking quantum computers
- Nature seems to abhor it

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

- metadata for describing local knowledge about the network
- querying and searching that metadata
- visualizing metadata
**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!?

😕 State of the art 😕

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

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

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

```
# 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
```

(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
```

(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
```

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

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.