EntanglementConsumer

docs/src/tag_query.md

@@ -30,7 +30,7 @@ QuantumSavory.tag!
 QuantumSavory.untag!
 ```
 
-## Querying for the pressence of a tag
+## Querying for the presence of a tag
 
 The [`query`](@ref) function allows the user to query for [`Tag`](@ref)s in three different cases:
 - on a particular qubit slot ([`RegRef`](@ref)) in a [`Register`](@ref) node;
@@ -43,7 +43,7 @@ The queries can search in `FIFO` or `FILO` order (`FILO` by default). E.g., for
 
 One can also query by "lock" and "assignment" status of a given slot, by using the `locked` and `assigned` boolean keywords. By default these keywords are set to `nothing` and these properties are not checked.
 
-Following is a detailed description of each `query` methods
+Following is a detailed description of each `query` method
 
 ```@docs; canonical=false
 query(::Register,::Tag)

src/CircuitZoo/CircuitZoo.jl

@@ -19,10 +19,10 @@ function inputqubits end
 struct EntanglementSwap <: AbstractCircuit
 end
 
-function (::EntanglementSwap)(localL, remoteL, lacalR, remoteR)
-    apply!((localL, lacalR), CNOT)
+function (::EntanglementSwap)(localL, remoteL, localR, remoteR)
+    apply!((localL, localR), CNOT)
     xmeas = project_traceout!(localL, σˣ)
-    zmeas = project_traceout!(lacalR, σᶻ)
+    zmeas = project_traceout!(localR, σᶻ)
     if xmeas==2
         apply!(remoteL, Z)
     end
@@ -37,10 +37,10 @@ inputqubits(::EntanglementSwap) = 4
 struct LocalEntanglementSwap <: AbstractCircuit
 end
 
-function (::LocalEntanglementSwap)(localL, lacalR)
-    apply!((localL, lacalR), CNOT)
+function (::LocalEntanglementSwap)(localL, localR)
+    apply!((localL, localR), CNOT)
     xmeas = project_traceout!(localL, σˣ)
-    zmeas = project_traceout!(lacalR, σᶻ)
+    zmeas = project_traceout!(localR, σᶻ)
     xmeas, zmeas
 end
 

src/ProtocolZoo/ProtocolZoo.jl

@@ -14,7 +14,7 @@
 using ResumableFunctions: @resumable
 import SumTypes
 
-export EntanglerProt, SwapperProt, EntanglementTracker
+export EntanglerProt, SwapperProt, EntanglementTracker, EntanglementConsumer
 
 abstract type AbstractProtocol end
 
@@ -149,6 +149,10 @@
     rounds::Int = -1
     """whether the protocol should find the first available free slots in the nodes to be entangled or check for free slots randomly from the available slots"""
     randomize::Bool = false
+    """Repeated rounds of this protocol may lead to monopolizing all slots of a pair of registers, starving or deadlocking other protocols. This field can be used to always leave a minimum number of slots free if there already exists entanglement between the current pair of nodes."""
+    margin::Int = 0
+    """Like `margin`, but it is enforced even when no entanglement has been established yet. Usually smaller than `margin`."""
+    hardmargin::Int = 0
 end
 
 """Convenience constructor for specifying `rate` of generation instead of success probability and time"""
@@ -166,8 +170,11 @@
     rounds = prot.rounds
     round = 1
     while rounds != 0
-        a = findfreeslot(prot.net[prot.nodeA], randomize=prot.randomize)
-        b = findfreeslot(prot.net[prot.nodeB], randomize=prot.randomize)
+        isentangled = !isnothing(query(prot.net[prot.nodeA], EntanglementCounterpart, prot.nodeB, ❓; assigned=true))
+        margin = isentangled ? prot.margin : prot.hardmargin
+        a = findfreeslot(prot.net[prot.nodeA]; randomize=prot.randomize, margin=margin)
+        b = findfreeslot(prot.net[prot.nodeB]; randomize=prot.randomize, margin=margin)
+
         if isnothing(a) || isnothing(b)
             isnothing(prot.retry_lock_time) && error("We do not yet support waiting on register to make qubits available") # TODO
             @debug "EntanglerProt between $(prot.nodeA) and $(prot.nodeB)|round $(round): Failed to find free slots. \n Got:\n \t $a \n \t $b \n retrying..."
@@ -245,10 +252,12 @@
             @yield timeout(prot.sim, prot.retry_lock_time)
             continue
         end
+
         (q1, tag1) = qubit_pair[1].slot, qubit_pair[1].tag
         (q2, tag2) = qubit_pair[2].slot, qubit_pair[2].tag
         @yield lock(q1) & lock(q2) # this should not really need a yield thanks to `findswapablequbits`, but it is better to be defensive
         @yield timeout(prot.sim, prot.local_busy_time)
+
         untag!(q1, tag1)
         # store a history of whom we were entangled to: remote_node_idx, remote_slot_idx, remote_swapnode_idx, remote_swapslot_idx, local_swap_idx
         tag!(q1, EntanglementHistory, tag1[2], tag1[3], tag2[2], tag2[3], q2.idx)
@@ -369,4 +378,70 @@
     end
 end
 
+"""
+$TYPEDEF
+
+A protocol running between two nodes, checking periodically for any entangled pairs between the two nodes and consuming/emptying the qubit slots.
+
+$FIELDS
+"""
+@kwdef struct EntanglementConsumer{LT} <: AbstractProtocol where {LT<:Union{Float64,Nothing}}
+    """time-and-schedule-tracking instance from `ConcurrentSim`"""
+    sim::Simulation
+    """a network graph of registers"""
+    net::RegisterNet
+    """the vertex index of node A"""
+    nodeA::Int
+    """the vertex index of node B"""
+    nodeB::Int
+    """time period between successive queries on the nodes (`nothing` for queuing up and waiting for available pairs)"""
+    period::LT = 0.1
+    """stores the time and resulting observable from querying nodeA and nodeB for `EntanglementCounterpart`"""
+    log::Vector{Tuple{Float64, Float64, Float64}} = Tuple{Float64, Float64, Float64}[]
+end
+
+function EntanglementConsumer(sim::Simulation, net::RegisterNet, nodeA::Int, nodeB::Int; kwargs...)
+    return EntanglementConsumer(;sim, net, nodeA, nodeB, kwargs...)
+end
+
+@resumable function (prot::EntanglementConsumer)()
+    if isnothing(prot.period)
+        error("In `EntanglementConsumer` we do not yet support waiting on register to make qubits available") # TODO
+    end
+    while true
+        query1 = query(prot.net[prot.nodeA], EntanglementCounterpart, prot.nodeB, ❓; locked=false, assigned=true) # TODO Need a `querydelete!` dispatch on `Register` rather than using `query` here followed by `untag!` below
+        if isnothing(query1)
+            @debug "EntanglementConsumer between $(prot.nodeA) and $(prot.nodeB): query on first node found no entanglement"
+            @yield timeout(prot.sim, prot.period)
+            continue
+        else
+            query2 = query(prot.net[prot.nodeB], EntanglementCounterpart, prot.nodeA, query1.slot.idx; locked=false, assigned=true)
+
+            if isnothing(query2) # in case EntanglementUpdate hasn't reached the second node yet, but the first node has the EntanglementCounterpart
+                @debug "EntanglementConsumer between $(prot.nodeA) and $(prot.nodeB): query on second node found no entanglement (yet...)"
+                @yield timeout(prot.sim, prot.period)
+                continue
+            end
+        end
+
+        q1 = query1.slot 
+        q2 = query2.slot
+        @yield lock(q1) & lock(q2)
+
+        @debug "EntanglementConsumer between $(prot.nodeA) and $(prot.nodeB): queries successful, consuming entanglement"
+        untag!(q1, query1.tag)
+        untag!(q2, query2.tag)
+        # TODO do we need to add EntanglementHistory and should that be a different EntanglementHistory since the current one is specifically for SwapperProt
+        # TODO currently when calculating the observable we assume that EntanglerProt.pairstate is always (|00⟩ + |11⟩)/√2, make it more general for other states
+        ob1 = real(observable((q1, q2), Z⊗Z))
+        ob2 = real(observable((q1, q2), X⊗X))
+
+        traceout!(prot.net[prot.nodeA][q1.idx], prot.net[prot.nodeB][q2.idx])
+        push!(prot.log, (now(prot.sim), ob1, ob2))
+        unlock(q1)
+        unlock(q2)
+        @yield timeout(prot.sim, prot.period)
+    end
+end
+
 end # module

src/queries.jl

@@ -75,14 +75,14 @@ julia> queryall(r, :symbol, ❓, >(5))
 """
 queryall(args...; filo=true, kwargs...) = query(args..., Val{true}(); filo, kwargs...)
 
-
 """
 $TYPEDSIGNATURES
 
 A query function searching for the first slot in a register that has a given tag.
 
 Wildcards are supported (instances of `Wildcard` also available as the constants [`W`](@ref) or the emoji [`❓`](@ref) which can be entered as `\\:question:` in the REPL).
 Predicate functions are also supported (they have to be `Int`↦`Bool` functions).
+The order of query lookup can be specified in terms of FIFO or FILO and defaults to FILO if not specified.
 The keyword arguments `locked` and `assigned` can be used to check, respectively,
 whether the given slot is locked or whether it contains a quantum state.
 The keyword argument `filo` can be used to specify whether the search should be done in a FIFO or FILO order,
@@ -384,20 +384,20 @@ julia> findfreeslot(reg) |> isnothing
 true
 ```
 """
-function findfreeslot(reg::Register; randomize=false)
-    if randomize
-        for i in randperm(length(reg.staterefs))
+function findfreeslot(reg::Register; randomize=false, margin=0)
+    n_slots = length(reg.staterefs)
+    freeslots = sum((!isassigned(reg[i]) for i in 1:n_slots))
+    if freeslots >= margin
+        perm = randomize ? randperm : (x->1:x)
+        for i in perm(n_slots)
             slot = reg[i]
             islocked(slot) || isassigned(slot) || return slot
         end
     end
-    for slot in reg
-        islocked(slot) || isassigned(slot) || return slot
-    end
 end
 
 
 function Base.isassigned(r::Register,i::Int) # TODO erase
-    r.stateindices[i] != 0 # TODO this also usually means r.staterenfs[i] !== nothing - choose one and make things consistent
+    r.stateindices[i] != 0 # TODO this also usually means r.staterefs[i] !== nothing - choose one and make things consistent
 end
 Base.isassigned(r::RegRef) = isassigned(r.reg, r.idx)

test/runtests.jl

@@ -32,6 +32,7 @@ println("Starting tests with $(Threads.nthreads()) threads out of `Sys.CPU_THREA
 @doset "messagebuffer"
 @doset "tags_and_queries"
 @doset "entanglement_tracker"
+@doset "entanglement_consumer"
 @doset "entanglement_tracker_grid"
 
 @doset "circuitzoo_api"

test/test_entanglement_consumer.jl

@@ -0,0 +1,47 @@
+using QuantumSavory
+using QuantumSavory.ProtocolZoo: EntanglerProt, SwapperProt, EntanglementTracker, EntanglementConsumer
+using Graphs
+using ConcurrentSim
+using Test
+
+if isinteractive()
+    using Logging
+    logger = ConsoleLogger(Logging.Warn; meta_formatter=(args...)->(:black,"",""))
+    global_logger(logger)
+    println("Logger set to debug")
+end
+
+
+for i in 1:30, n in 3:30
+    net = RegisterNet([Register(10) for j in 1:n])
+    sim = get_time_tracker(net)
+
+    for e in edges(net)
+        eprot = EntanglerProt(sim, net, e.src, e.dst; rounds=-1, randomize=true, margin=5, hardmargin=3)
+        @process eprot()
+    end
+
+    for v in 2:n-1
+        sprot = SwapperProt(sim, net, v; nodeL = <(v), nodeH = >(v), chooseL = argmin, chooseH = argmax, rounds = -1)
+        @process sprot()
+    end
+
+    for v in vertices(net)
+        etracker = EntanglementTracker(sim, net, v)
+        @process etracker()
+    end
+
+    econ = EntanglementConsumer(sim, net, 1, n; period=1.0)
+    @process econ()
+
+    run(sim, 100)
+
+
+    for i in 1:length(econ.log)
+        if !isnothing(econ.log[i][2])
+            @test econ.log[i][2] ≈ 1.0
+            @test econ.log[i][3] ≈ 1.0
+        end
+    end
+
+end