Full API

Stable log groups emitted by QuantumSavory.

Pass one of these symbols through the logging macro's special _group keyword to let loggers reject a family of records before the message and metadata are constructed.

A wildcard instance for use with the tag querying functionality.

See also: query, tag!, ❓

A wildcard instance for use with the tag querying functionality.

This emoji can be inputted with the \:question: emoji shortcut, or you can simply use the ASCII alternative W.

See also: query, tag!, W

An abstract type for the various background processes that might be inflicted upon a Register slot, e.g. decay, dephasing, etc.

AbstractTag

Marker supertype for named tag heads used by QuantumSavory protocols.

AbstractTag describes the type stored at the head of a typed Tag, such as EntanglementCounterpart in Tag(EntanglementCounterpart, remote_node, remote_slot, pair_id). It does not replace the Tag sum type itself. Generic Tag(::DataType, ...) construction and querying remain available for types that do not subtype AbstractTag.

Custom tag heads supplied through protocol fields declared as Type{<:AbstractTag} must be concrete subtypes of this marker:

struct MyTag <: AbstractTag end

A depolarization background.

Represents a Hamiltonian being applied for the given duration. See also NonInstantGate.

A depolarization background.

The τ parameter specifies the average time between depolarization events (assuming a Poisson point process). I.e. after time t the probability for an depolarization event is 1-exp(-t/τ).

HomodyneMeasurement(angles; squeeze = eps())

Describe a homodyne measurement on one or more continuous-variable modes.

angles gives the quadrature angle, in radians, for each measured mode. For example, 0.0 corresponds to an x-quadrature measurement and pi/2 to a p-quadrature measurement. squeeze sets the finite-squeezing parameter used by Gaussian backends when approximating the ideal measurement.

This is typically used together with project_traceout! on a continuous-variable register slot.

julia> reg = Register([Qumode()], [GabsRepr(QuadBlockBasis)]);

julia> initialize!(reg[1], CoherentState(0.3 + 0.2im));

julia> project_traceout!(reg[1], HomodyneMeasurement([0.0]; squeeze = 1e-12))
2-element Vector{Float64}:
 0.3
 0.2

julia> isnothing(QuantumSavory.stateof(reg[1]))
true

A a buffer for classical messages. Usually a part of a Register structure.

See also: channel, messagebuffer

Represents an gate applied instantaneously followed by a waiting period. See also ConstantHamiltonianEvolution.

A Pauli noise background.

Quantum channel for transmitting quantum states from one register to another.

Delay and background noise processes are supported.

The function put! is used to take the contents of a RegRef and put it in the channel. That state can can then be received by a register (after a delay) using the take! method.

julia> using QuantumSavory, ResumableFunctions, ConcurrentSim

julia> regA = Register(1); regB = Register(1);

julia> initialize!(regA[1], Z1);

julia> sim = Simulation();

julia> qc = QuantumChannel(sim, 10.0) # a delay of 10 units
QuantumChannel{Qubit}(Qubit(), DelayQueue{Register}(ConcurrentSim.QueueStore{Register, Int64}, 10.0), nothing)

julia> @resumable function alice_node(env, qc)
            println("Putting Alice's qubit in the channel at ", now(env))
            put!(qc, regA[1])
        end
alice_node (generic function with 1 method)

julia> @resumable function bob_node(env, qc)
            @yield take!(qc, regB[1])
            println("Taking the qubit from alice at ", now(env))
        end
bob_node (generic function with 1 method)

julia> @process alice_node(sim, qc); @process bob_node(sim, qc);

julia> run(sim)
Putting Alice's qubit in the channel at 0.0
Taking the qubit from alice at 10.0

julia> regA
Register  with 1 slots: [ Qubit ]
  Slots:
    nothing

An abstract type for the various types of states that can be given to Register slots, e.g. qubit, harmonic oscillator, etc.

Specifies that a given register slot contains qubits.

Specifies that a given register slot contains qumodes.

A reference to a Register slot, convenient for use with functions like apply!, etc.

julia> r = Register(2)
       initialize!(r[1], X₁)
       observable(r[1], X)
0.9999999999999998 + 0.0im

The main data structure in QuantumSavory, used to represent a quantum register in an arbitrary formalism.

RegisterNet(graph::SimpleGraph, registers;
    classical_delay=0, quantum_delay=0, name=nothing, names=String[])
RegisterNet(registers::Vector{Register};
    classical_delay=0, quantum_delay=0, name=nothing, names=String[])

Store one Register for each vertex of an undirected SimpleGraph. If graph is omitted, use a chain with one vertex per register.

RegisterNet directly supports these read operations from Graphs.jl: vertices, edges, neighbors, nv, ne, and adjacency_matrix. It is not a subtype of Graphs.AbstractGraph, so other Graphs.jl functions are not part of this interface. Treat the topology as fixed after construction.

Index a network to move from the network to a register or a register slot:

net[i]       # Register at vertex i
net[i][j]    # RegRef for slot j of that register
net[i, j]    # the same RegRef
net[:]       # all registers
net[:, j]    # slot j from every register

The name keyword gives the network a display name. names gives display names to its registers. These names do not replace the integer graph vertex identifiers. A label can instead be stored as vertex metadata:

net[1, :label] = "left endpoint"

Vertex metadata uses net[i, :key]. Undirected edge metadata uses net[(i, j), :key], and directed edge metadata uses net[i => j, :key].

For more sophisticated metadata handling, check out the independent tag and query capabilities of QuantumSavory.

classical_delay and quantum_delay each accept a constant or a callable (src, dst) -> delay. A callable is evaluated in both directions of each edge, so it can give the two directions different delays.

using Graphs

graph = path_graph(3)
delay(src, dst) = src < dst ? 0.1 : 0.2
net = RegisterNet(graph, [Register(2) for _ in 1:3];
    name="line", names=["left", "middle", "right"],
    classical_delay=delay, quantum_delay=0.05)

See Register Networks for the complete explanation.

Construct a RegisterNet from a given list of Registers and a graph.

The classical_delay and quantum_delay keyword arguments each accept either a single delay used for every channel or a callable (src, dst) -> delay. The callable is evaluated separately for both directions of every graph edge.

julia> graph = grid([2,2]) # from Graphs.jl
{4, 4} undirected simple Int64 graph

julia> registers = [Register(1), Register(2), Register(1), Register(2)]
4-element Vector{Register}:
 Register
 Register
 Register
 Register

julia> net = RegisterNet(graph, registers)
A network of 4 registers in a graph of 4 edges


julia> neighbors(net, 1) # from Graphs.jl
2-element Graphs.FrozenVector{Int64}:
 2
 3

Construct a RegisterNet from a given list of Registers, defaulting to a chain topology.

julia> net = RegisterNet([Register(2), Register(4), Register(2)])
A network of 3 registers in a graph of 2 edges

julia> neighbors(net,2) # from Graphs.jl
2-element Graphs.FrozenVector{Int64}:
 1
 3

A background describing the T₁ decay of a two-level system.

A background combining both T₁ decay and T₂ dephasing.

A background describing the T₂ dephasing of a two-level system.

Tags are used to represent classical metadata describing the state (or even history) of nodes and their registers. The library allows the construction of custom tags using the Tag constructor. Currently tags are implemented as instances of a sum type and have fairly constrained structure. Most of them are constrained to contain only Symbol instances and integers.

Here is an example of such a generic tag:

julia> Tag(:sometagdescriptor, 1, 2, -3)
SymbolIntIntInt(:sometagdescriptor, 1, 2, -3)::Tag

A tag can have a custom DataType as first argument, in which case additional customizability in printing is available. E.g. consider the [EntanglementHistory] tag used to track how pairs were entangled before a swap happened.

julia> using QuantumSavory.ProtocolZoo: EntanglementHistory

julia> Tag(EntanglementHistory, 1, 2, 3, 4, 5)
Was entangled to 1.2 with chunk id 0, but swapped with .5 which was entangled to 3.4 with chunk id 0

See also: tag!, query

Apply a given operation on the given set of register slots.

apply!([regA, regB], [slot1, slot2], Gates.CNOT) would apply a CNOT gate on the content of the given registers at the given slots. The appropriate representation of the gate is used, depending on the formalism under which a quantum state is stored in the given registers. The Hilbert spaces of the registers are automatically joined if necessary.

Delete one or more register slots.

traceout!(reg, slot) would reset (perform a partial trace) over the given subsystem. The Hilbert space of the register gets automatically shrunk.

traceout!(ref1, ref2, ...) deletes several RegRefs in argument order and returns the corresponding registers as a tuple. When the arguments include every live slot backed by the same StateRef, that state is deleted as one group without calling the backend's partial-trace implementation. Incomplete groups are reduced one slot at a time.

For QuantumMCRepr trajectories, partial reduction samples the discarded subsystem in its native canonical basis. Use project_traceout! instead when the sampled outcome is needed.

Return the available public background types along with their documentation.

Used to make a background available to tools like the GUI WebQuantumSavory.

Concrete direct and indirect subtypes of AbstractBackground are discovered on each call. The defining binding of each type must be public. The InteractiveUtils and REPL standard libraries must be loaded to activate this optional method.

Return the available public slot types along with their documentation.

Used to make a slot type available to tools like the GUI WebQuantumSavory.

Concrete direct and indirect subtypes of QuantumStateTrait are discovered on each call. The defining binding of each type must be public. The InteractiveUtils and REPL standard libraries must be loaded to activate this optional method.

Get a handle to a classical channel between two registers.

Usually used for sending classical messages between registers. It can be used for receiving as well, but a more convenient choice is messagebuffer, which is a message buffer listening to all channels sending to a given destination register.

julia> net = RegisterNet([Register(2), Register(2), Register(2)]) # defaults to a chain topology
A network of 3 registers in a graph of 2 edges

julia> channel(net, 1=>2)
ConcurrentSim.DelayQueue{Tag}(ConcurrentSim.QueueStore{Tag, Int64}, 0.0)

julia> channel(net, 1=>2)
ConcurrentSim.DelayQueue{Tag}(ConcurrentSim.QueueStore{Tag, Int64}, 0.0)

julia> channel(net, 1=>2) === channel(net, net[1]=>net[2])
true

See also: qchannel, messagebuffer

Return documented constructor fields for a type.

Used to make a constructor available to tools like the GUI WebQuantumSavory.

Each entry has the fields field, type, and doc. Undocumented fields and fields whose names begin with an underscore are omitted. The InteractiveUtils and REPL standard libraries must be loaded to activate this optional method.

Find an empty unlocked slot in a given Register.

julia> reg = Register(3); initialize!(reg[1], X); lock(reg[2]);

julia> findfreeslot(reg) == reg[3]
true

julia> lock(findfreeslot(reg));

julia> findfreeslot(reg) |> isnothing
true

Generates a default map with country and state boundaries and returns a GeoAxis. The returned GeoAxis can be used as an input for registernetplot_axis.

The Tyler package must be installed and imported.

Set the state of a given set of registers.

initialize!([regA,regB], [slot1,slot2], state) would set the state of the given slots in the given registers to state. state can be any supported state representation, e.g., kets or density matrices from QuantumOptics.jl or tableaux from QuantumClifford.jl.

For a given background noise type, provide the corresponding Kraus operators, in a QuantumOptics.jl representation.

See also: paulinoise, lindbladop

The Kraus operators for depolarization are √(1-3p/4) I, √p/2 * X, √p/2 * Y, √p/2 Z

The Kraus operators for a T₁ process

• A₁ = |0⟩⟨0| + √(1-γ) |1⟩⟨1|
• A₂ = √γ |0⟩⟨1|
• λ = 1 - exp(-Δt/T₁)

The Kraus operators for a T₁T₂ process.

Of note, this is not the same as having "on top of each other" T₁ noise and then an additional "dephasing" noise. T₁ is causing dephasing of its own, and T₂ (transverse relaxation time) includes dephasing from T₁ and pure dephasing Tᵩ where 1/Tᵩ = 1/T₂ - 1/(2T₁). See https://qiskit-community.github.io/qiskit-experiments/manuals/characterization/tphi.html for more.

The Kraus operators for a T₂ process

One option is the following (more popular in the literature):

• P₁ = |0⟩⟨0| + √(1-λ) |1⟩⟨1|
• P₂ = √λ |1⟩⟨1|
• λ = 1 - exp(-2Δt/T₂)

An equivalent option is (more convenient when converting to a Pauli error channel):

• P₁′ = √(1-p/2) I
• P₂′ = √(p/2) Z
• p = 1 - exp(-Δt/T₂)

These two options are equivalent under a unitary transformation. We implement the second one.

For a given background noise type, provide the corresponding Lindblad collapse operator, in a QuantumOptics.jl representation.

See also: paulinoise, krausops

1/√τ â

1/√T₁ |0⟩⟨1|

Lindblad operators for combined T₁ and T₂ noise.

Returns a list of Lindblad operators:

• L₁ = (1/√T₁) |0⟩⟨1| for amplitude damping
• L₂ = (1/√(2Tᵩ)) Z for pure dephasing (if T₂ < 2T₁)

where 1/Tᵩ = 1/T₂ - 1/(2T₁)

Of note, this is not the same as having "on top of each other" T₁ noise and then an additional "dephasing" noise. As you can see from the formula above, T₁ is causing dephasing of its own. Thus, T₂ (transverse relaxation time) includes dephasing from T₁ and pure dephasing Tᵩ. See https://qiskit-community.github.io/qiskit-experiments/manuals/characterization/tphi.html for more.

1/√(2T₂) Z

messagebuffer(
    net::RegisterNet,
    dst::Int64
) -> MessageBuffer{Tag}

Get a handle to a classical message buffer corresponding to all channels sending to a given destination register.

See also: channel

messagebuffer(
    ref::Union{RegRef, Register}
) -> MessageBuffer{Tag}

Get a handle to a classical message buffer corresponding to all channels sending to a given destination register.

See also: channel

Calculate the expectation value of a quantum observable on the given register and slot.

observable([regA, regB], [slot1, slot2], obs) would calculate the expectation value of the obs observable (using the appropriate formalism, depending on the state representation in the given registers).

The register and slot-index collections must have equal lengths, and each physical register slot may appear at most once. Invalid selections are rejected before empty slots are handled, time is advanced, or backend work begins.

Wait for changes to occur on a MessageBuffer or Register. By specifying a second argument, you can filter what type of events are waited on. E.g. onchange(r, Tag) will wait only on changes to tags and metadata.

For a given background noise type, provide the corresponding (potentially twirled) Pauli operators and the probabilities for the operators to act, in a QuantumClifford.jl representation.

See also: krausops, lindbladop

The Pauli operator and probability of its application for a Depolarization process.

((p/4, X), (p/4, Y), (p/4, Z)) for p = 1-exp(-Δt/τ)

The Pauli operator and probability of its application for a T₂ process.

(1-exp(-Δt/T₂)) / 2 and Z

Perform a projective measurement on the given slot of the given register.

project_traceout!(reg, slot, [stateA, stateB]) performs a projective measurement, projecting on either stateA or stateB, returning the index of the subspace on which the projection happened. It assumes the list of possible states forms a basis for the Hilbert space. The Hilbert space of the register is automatically shrunk.

A basis object can be specified on its own as well, e.g. project_traceout!(reg, slot, basis).

Discrete qubit backends return a one-based Int outcome. Gabs homodyne measurements return continuous quadrature data. Clifford qubit measurements currently support the symbolic X, Y, and Z bases.

Get a handle to a quantum channel between two registers.

julia> net = RegisterNet([Register(2), Register(2), Register(2)]) # defaults to a chain topology
A network of 3 registers in a graph of 2 edges

julia> qchannel(net, 1=>2)
QuantumChannel{Qubit}(Qubit(), ConcurrentSim.DelayQueue{Register}(ConcurrentSim.QueueStore{Register, Int64}, 0.0), nothing)

julia> qchannel(net, 1=>2) === qchannel(net, net[1]=>net[2])
true

See also: channel

query(
    mb::MessageBuffer,
    queryargs::Union{QuantumSavory.Wildcard, Int64, DataType, Function, Symbol}...
) -> Union{Nothing, NamedTuple{(:depth, :src, :tag), <:Tuple{Int64, Union{Nothing, Int64}, Any}}}

You are advised to actually use querydelete!, not query when working with classical message buffers.

query(
    reg::Union{RegRef, Register},
    queryargs::Union{QuantumSavory.Wildcard, Int64, DataType, Function, Symbol}...;
    locked,
    assigned,
    filo
) -> Any

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 or the emoji ❓ 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, defaulting to filo=true (i.e. a stack-like behavior).

julia> r = Register(10);
       tag!(r[1], :symbol, 2, 3);
       tag!(r[2], :symbol, 4, 5);


julia> query(r, :symbol, 4, 5)
(slot = 1043859625813851568.2, id = 4, tag = SymbolIntInt(:symbol, 4, 5)::Tag, time = 0.0)

julia> lock(r[1]);

julia> query(r, :symbol, 4, 5; locked=false) |> isnothing
false

julia> query(r, :symbol, ❓, 3)
(slot = 1043859625813851568.1, id = 3, tag = SymbolIntInt(:symbol, 2, 3)::Tag, time = 0.0)

julia> query(r, :symbol, ❓, 3; assigned=true) |> isnothing
true

julia> query(r, :othersym, ❓, ❓) |> isnothing
true

julia> tag!(r[5], Int, 4, 5);

julia> query(r, Float64, 4, 5) |> isnothing
true

julia> query(r, Int, 4, >(7)) |> isnothing
true

julia> query(r, Int, 4, <(7))
(slot = 1043859625813851568.5, id = 5, tag = TypeIntInt(Int64, 4, 5)::Tag, time = 0.0)

A query can be on on a single slot of a register:

julia> r = Register(5);

julia> tag!(r[2], :symbol, 2, 3);

julia> query(r[2], :symbol, 2, 3)
(slot = 2589040728030450388.2, id = 14, tag = SymbolIntInt(:symbol, 2, 3)::Tag, time = 0.0)

julia> query(r[3], :symbol, 2, 3) === nothing
true

julia> queryall(r[2], :symbol, 2, 3)
1-element Vector{@NamedTuple{slot::RegRef, id::Int128, tag::Tag, time::Float64}}:
 (slot = 2589040728030450388.2, id = 14, tag = SymbolIntInt(:symbol, 2, 3)::Tag, time = 0.0)

See also: queryall, tag!, W, ❓

A convenience function that combines waiting (via onchange) and querying (via query) in a loop, returning a ConcurrentSim process that yields the first successful query result.

This replaces the common pattern of:

while true
    @yield onchange(register, Tag)
    result = query(register, :my_tag, ❓)
    if !isnothing(result)
        # do something with result
        break
    end
end

with the much simpler:

result = @yield query_wait(register, :my_tag, ❓)
# do something with result

query_wait does not consume the matching tag. Multiple waiters can observe the same register tag. If your protocol will remove the tag, prefer querydelete_wait!, or re-query/check with querydelete! after acquiring any needed locks.

The on keyword argument is passed to onchange to control what type of events are waited on. The locked and assigned keyword arguments are passed through to query for register queries.

julia> using ResumableFunctions; using ConcurrentSim;

julia> reg = Register(5);
       net = RegisterNet([reg]);
       env = get_time_tracker(net);

julia> @resumable function sender(env, reg)
           @yield timeout(env, 1.0)
           tag!(reg[1], :my_tag, 42)
       end;

julia> LOG = [];

julia> @resumable function receiver(env, reg)
           result = @yield query_wait(reg, :my_tag, ❓)
           push!(LOG, result)
       end;

julia> @process sender(env, reg);

julia> @process receiver(env, reg);

julia> run(env, 0.5);

julia> length(LOG)
0

julia> run(env, 1.5);

julia> length(LOG)
1

julia> LOG[1].tag
SymbolInt(:my_tag, 42)::Tag

See also: query, querydelete_wait!, onchange, tag!

queryall(
    reg::Union{RegRef, Register},
    queryargs::Union{QuantumSavory.Wildcard, Int64, DataType, Function, Symbol}...;
    filo,
    kwargs...
) -> Any

A query function that returns all slots of a register that have a given tag, with support for predicates and wildcards.

julia> r = Register(10);
       tag!(r[1], :symbol, 2, 3);
       tag!(r[2], :symbol, 4, 5);

julia> queryall(r, :symbol, ❓, ❓)
2-element Vector{@NamedTuple{slot::RegRef, id::Int128, tag::Tag, time::Float64}}:
 (slot = 15531193455478883312.2, id = 16, tag = SymbolIntInt(:symbol, 4, 5)::Tag, time = 0.0)
 (slot = 15531193455478883312.1, id = 15, tag = SymbolIntInt(:symbol, 2, 3)::Tag, time = 0.0)

julia> queryall(r, :symbol, ❓, >(4))
1-element Vector{@NamedTuple{slot::RegRef, id::Int128, tag::Tag, time::Float64}}:
 (slot = 15531193455478883312.2, id = 16, tag = SymbolIntInt(:symbol, 4, 5)::Tag, time = 0.0)

julia> queryall(r, :symbol, ❓, >(5))
@NamedTuple{slot::RegRef, id::Int128, tag::Tag, time::Float64}[]

querydelete!(
    reg::Union{RegRef, Register},
    args...;
    kwa...
) -> Any

A query for Register or a register slot (i.e. a RegRef) that also deletes the tag.

For register protocol code, this is safer than query followed by untag!. If the result will be used after an @yield or lock acquisition, re-query after the wait before deleting or acting on the tag.

julia> reg = Register(3)
       tag!(reg[1], :tagA, 1, 2, 3)
       tag!(reg[2], :tagA, 10, 20, 30)
       tag!(reg[2], :tagB, 6, 7, 8);

julia> queryall(reg, :tagA, ❓, ❓, ❓)
2-element Vector{@NamedTuple{slot::RegRef, id::Int128, tag::Tag, time::Float64}}:
 (slot = 767672459337976635.2, id = 19, tag = SymbolIntIntInt(:tagA, 10, 20, 30)::Tag, time = 0.0)
 (slot = 767672459337976635.1, id = 18, tag = SymbolIntIntInt(:tagA, 1, 2, 3)::Tag, time = 0.0)

julia> querydelete!(reg, :tagA, ❓, ❓, ❓)
(slot = 767672459337976635.2, id = 19, tag = SymbolIntIntInt(:tagA, 10, 20, 30)::Tag, time = 0.0)

julia> queryall(reg, :tagA, ❓, ❓, ❓)
1-element Vector{@NamedTuple{slot::RegRef, id::Int128, tag::Tag, time::Float64}}:
 (slot = 767672459337976635.1, id = 18, tag = SymbolIntIntInt(:tagA, 1, 2, 3)::Tag, time = 0.0)

querydelete!(
    mb::MessageBuffer,
    queryargs::Union{QuantumSavory.Wildcard, Int64, DataType, Function, Symbol}...
) -> Union{Nothing, @NamedTuple{src::Union{Nothing, Int64}, tag::T} where T}

A query for classical message buffers that also deletes the message out of the buffer.

julia> net = RegisterNet([Register(3), Register(2)])
A network of 2 registers in a graph of 1 edges

julia> put!(channel(net, 1=>2), Tag(:my_tag));

julia> put!(channel(net, 1=>2), Tag(:another_tag, 123, 456));

julia> query(messagebuffer(net, 2), :my_tag)

julia> run(get_time_tracker(net))

julia> query(messagebuffer(net, 2), :my_tag)
(depth = 1, src = 1, tag = Symbol(:my_tag)::Tag)

julia> querydelete!(messagebuffer(net, 2), :my_tag)
@NamedTuple{src::Union{Nothing, Int64}, tag::Tag}((1, Symbol(:my_tag)::Tag))

julia> querydelete!(messagebuffer(net, 2), :my_tag) === nothing
true

julia> querydelete!(messagebuffer(net, 2), :another_tag, ❓, ❓)
@NamedTuple{src::Union{Nothing, Int64}, tag::Tag}((1, SymbolIntInt(:another_tag, 123, 456)::Tag))

julia> querydelete!(messagebuffer(net, 2), :another_tag, ❓, ❓) === nothing
true

You can also wait on a message buffer for a message to arrive before running a query:

julia> using ResumableFunctions; using ConcurrentSim;

julia> net = RegisterNet([Register(3), Register(2), Register(3)])
A network of 3 registers in a graph of 2 edges

julia> env = get_time_tracker(net);

julia> @resumable function receive_tags(env)
           while true
               mb = messagebuffer(net, 2)
               @yield onchange(mb)
               msg = querydelete!(mb, :second_tag, ❓, ❓)
               print("t=$(now(env)): query returns ")
               if isnothing(msg)
                   println("nothing")
               else
                   println("$(msg.tag) received from node $(msg.src)")
               end
           end
       end
receive_tags (generic function with 1 method)

julia> @resumable function send_tags(env)
           @yield timeout(env, 1.0)
           put!(channel(net, 1=>2), Tag(:my_tag))
           @yield timeout(env, 2.0)
           put!(channel(net, 3=>2), Tag(:second_tag, 123, 456))
       end
send_tags (generic function with 1 method)

julia> @process send_tags(env);

julia> @process receive_tags(env);

julia> run(env, 10)
t=1.0: query returns nothing
t=3.0: query returns SymbolIntInt(:second_tag, 123, 456)::Tag received from node 3

A convenience function that combines waiting (via onchange) and querying-with-deletion (via querydelete!) in a loop, returning a ConcurrentSim process that yields the first successful query result (deleting the matched entry).

This replaces the common pattern of:

while true
    @yield onchange(store, Tag)
    result = querydelete!(store, :my_tag, ❓)
    if !isnothing(result)
        # do something with result
        break
    end
end

with the much simpler:

result = @yield querydelete_wait!(store, :my_tag, ❓)
# do something with result

The on keyword argument is passed to onchange to control what type of events are waited on. The locked and assigned keyword arguments are passed through to querydelete! for register queries.

julia> using ResumableFunctions; using ConcurrentSim;

julia> net = RegisterNet([Register(3), Register(2)]);
       env = get_time_tracker(net);

julia> @resumable function sender(env)
           @yield timeout(env, 1.0)
           put!(channel(net, 1=>2), Tag(:my_tag))
           @yield timeout(env, 2.0)
           put!(channel(net, 1=>2), Tag(:second_tag, 123, 456))
       end;

julia> LOG = [];

julia> @resumable function receiver(env)
           mb = messagebuffer(net, 2)
           msg = @yield querydelete_wait!(mb, :second_tag, ❓, ❓)
           push!(LOG, msg)
       end;

julia> @process sender(env);

julia> @process receiver(env);

julia> run(env, 2.0);

julia> length(LOG)
0

julia> run(env, 4.0);

julia> length(LOG)
1

julia> LOG[1].tag
SymbolIntInt(:second_tag, 123, 456)::Tag

See also: querydelete!, query_wait, onchange, tag!

Draw the given register network.

Requires a Makie backend be already imported.

Draw the given register network on a given Makie axis.

Requires a Makie backend be already imported.

Draw the given register network on a given Makie axis or subfigure and modify the axis with numerous visualization enhancements.

Requires a Makie backend be already imported.

Draw the various resources and locks stored in the given meta-graph on a given Makie axis.

Requires a Makie backend be already imported.

simulation_log_context(sim::Simulation)

Return the structured logging context for sim.

The result contains the current simulated time and the active ConcurrentSim process identifier. sim_process_id is nothing when called outside a running process.

Ensure that the all slots of the given registers are represented by one single state object, i.e. that all the register slots are tracked in the same Hilbert space.

tag!(ref::RegRef, tag) -> Int128

Assign a tag to a slot in a register.

See also: query, untag!

untag!(
    ref::Union{RegRef, Register},
    id::Integer
) -> @NamedTuple{tag::Tag, slot::Int64, time::Float64}

Remove the tag with the given id from a RegRef or a Register.

To remove a tag based on a query, use querydelete! instead. In asynchronous protocols, do not keep a query result across a yield and later call untag! with the old id. Another process may already have consumed that tag. Re-query under the relevant locks or use a consuming query helper.

See also: querydelete!, query, tag!

Evolve all the states in a register to a given time, according to the various backgrounds that they might have.

julia> reg = Register(2, T1Decay(1.0))
Register  with 2 slots: [ Qubit | Qubit ]
  Slots:
    nothing
    nothing

julia> initialize!(reg[1], X₁)
       observable(reg[1], σᶻ)
0.0 + 0.0im

julia> uptotime!(reg[1], 10)
       observable(reg[1], Z)
0.9999546000702374 + 0.0im