Library reference
Quantum Processing Unit
Snowflurry.AnyonYukonQPU — Type.
AnyonYukonQPU <: AbstractQPU
A data structure to represent an Anyon System's Yukon generation QPU, consisting of 6 qubits in a linear arrangement (see LineConnectivity).
Fields
client ::Client– Client to the QPU server.status_request_throttle ::Function– Used to rate-limit job status requests.project_id ::String– Used to identify which project the jobs sent to this QPU belong to.realm ::String– Optional: used to identify to which realm on the host server requests are sent to.
Example
julia> qpu = AnyonYukonQPU(host = "example.anyonsys.com", user = "test_user", access_token = "not_a_real_access_token", project_id = "test-project", realm = "test-realm")
Quantum Processing Unit:
manufacturer: Anyon Systems Inc.
generation: Yukon
serial_number: ANYK202201
project_id: test-project
qubit_count: 6
connectivity_type: linear
realm: test-realm
Snowflurry.AnyonYamaskaQPU — Type.
AnyonYamaskaQPU <: AbstractQPU
A data structure to represent an Anyon System's Yamaska generation QPU, consisting of 12 qubits in a 2D lattice arrangement (see LatticeConnectivity).
Fields
client ::Client– Client to the QPU server.status_request_throttle ::Function– Used to rate-limit job status requests.project_id ::String– Used to identify which project the jobs sent to this QPU belong to.realm ::String– Optional: used to identify to which realm on the host server requests are sent to.
Example
julia> qpu = AnyonYamaskaQPU(host = "example.anyonsys.com", user = "test_user", access_token = "not_a_real_access_token", project_id = "test-project", realm = "test_realm")
Quantum Processing Unit:
manufacturer: Anyon Systems Inc.
generation: Yamaska
serial_number: ANYK202301
project_id: test-project
qubit_count: 12
connectivity_type: 2D-lattice
realm: test_realm
Snowflurry.VirtualQPU — Type.
VirtualQPU
A data structure to represent a Quantum Simulator.
Example
julia> qpu = VirtualQPU()
Quantum Simulator:
developers: Anyon Systems Inc.
package: Snowflurry.jl
Snowflurry.Client — Type.
Client
A data structure to represent a Client to a QPU service.
Fields
host::String– URL of the QPU server.user::String– Username.access_token::String– User access token.realm::String– Optional: realm on the host to which the submitted jobs are sent to.
Example
julia> c = Client(host = "http://example.anyonsys.com", user = "test_user", access_token = "not_a_real_access_token", realm = "test_realm")
Client for QPU service:
host: http://example.anyonsys.com
user: test_user
realm: test_realm
Snowflurry.get_host — Function.
get_host(Client)
Returns host URL of a Client to a QPU service.
Example
julia> c = Client(host = "http://example.anyonsys.com", user = "test_user", access_token = "not_a_real_access_token");
julia> get_host(c)
"http://example.anyonsys.com"
Snowflurry.submit_job — Function.
submit_job(client::Client,circuit::QuantumCircuit,shot_count::Integer)
Submit a circuit to a Client of QPU service, requesting a number of repetitions (shot_count). Returns circuitID.
Example
julia> submit_job(client, QuantumCircuit(qubit_count = 3, instructions = [sigma_x(3), control_z(2, 1), readout(1, 1)]), 100, "project_id")
"8050e1ed-5e4c-4089-ab53-cccda1658cd0"
Snowflurry.get_status — Function.
get_status(client::Client,circuitID::String)::Tuple{Status,Dict{String,Int}}
Obtain the status of a circuit computation through a Client of a QPU service. Returns status::Dict containing status["type"]: -"QUEUED" : Computation in queue -"RUNNING" : Computation being processed -"FAILED" : QPU service has returned an error message -"SUCCEEDED": Computation is completed, result is available.
In the case of status["type"]=="FAILED", the server error is contained in status["message"].
In the case of status["type"]=="SUCCEEDED", the second element in the return Tuple is the histogram of the job results, as computed on the QPU.
Example
julia> jobID = submit_job(client, QuantumCircuit(qubit_count = 3, instructions = [sigma_x(3), control_z(2, 1), readout(1, 1)]), 100, "project_id")
"8050e1ed-5e4c-4089-ab53-cccda1658cd0"
julia> get_status(client, jobID)
(Status: SUCCEEDED
, Dict("001" => 100))
Snowflurry.run_job — Function.
run_job(qpu::VirtualQPU, circuit::QuantumCircuit, shot_count::Integer)
Run a circuit computation on a QPU simulator, repeatedly for the specified number of repetitions (shot_count). Returns the histogram of the completed circuit measurements, as prescribed by the Readouts present.
Example
julia> qpu = VirtualQPU();
julia> run_job(qpu, QuantumCircuit(qubit_count = 3, instructions = [sigma_x(3), control_z(2, 1), readout(1, 1), readout(2, 2), readout(3, 3)]), 100)
Dict{String, Int64} with 1 entry:
"001" => 100
run_job(qpu::AnyonYukonQPU, circuit::QuantumCircuit, shot_count::Integer)
Run a circuit computation on a QPU service, repeatedly for the specified number of repetitions (shot_count). Returns the histogram of the completed circuit calculations, or an error message. If the circuit received in invalid - for instance, it is missing a Readout - it is not sent to the host, and an error is throw.
Example
julia> qpu = AnyonYukonQPU(client, "project_id");
julia> run_job(qpu, QuantumCircuit(qubit_count = 3, instructions = [sigma_x(3), control_z(2, 1), readout(1, 1)]), 100)
Dict{String, Int64} with 1 entry:
"001" => 100
Snowflurry.transpile_and_run_job — Function.
transpile_and_run_job(qpu::VirtualQPU, circuit::QuantumCircuit,shot_count::Integer; transpiler::Transpiler = get_transpiler(qpu))
This method first transpiles the input circuit using either the default transpiler, or any other transpiler passed as a key-word argument. The transpiled circuit is then run on a QPU simulator, repeatedly for the specified number of repetitions (shot_count). Returns the histogram of the completed circuit calculations, or an error message.
Example
julia> qpu=VirtualQPU();
julia> transpile_and_run_job(qpu, QuantumCircuit(qubit_count = 3, instructions = [sigma_x(3), control_z(2, 1), readout(1, 1), readout(2, 2), readout(3, 3)]) ,100)
Dict{String, Int64} with 1 entry:
"001" => 100
transpile_and_run_job(qpu::AnyonYukonQPU, circuit::QuantumCircuit,shot_count::Integer;transpiler::Transpiler=get_transpiler(qpu))
This method first transpiles the input circuit using either the default transpiler, or any other transpiler passed as a key-word argument. The transpiled circuit is then run on the AnyonYukonQPU, repeatedly for the specified number of repetitions (shot_count).
Returns the histogram of the completed circuit calculations, or an error message.
Example
julia> qpu = AnyonYukonQPU(client_anyon, "project_id");
julia> transpile_and_run_job(qpu, QuantumCircuit(qubit_count = 3, instructions = [sigma_x(3), control_z(2, 1), readout(3, 3)]), 100)
Dict{String, Int64} with 1 entry:
"001" => 100
Snowflurry.get_transpiler — Function.
get_transpiler(qpu::AbstractQPU)::Transpiler
Returns the transpiler associated with this QPU.
Example
julia> qpu = AnyonYukonQPU(client, "project_id");
julia> get_transpiler(qpu)
SequentialTranspiler(Transpiler[CircuitContainsAReadoutTranspiler(), ReadoutsDoNotConflictTranspiler(), UnsupportedGatesTranspiler(), DecomposeSingleTargetSingleControlGatesTranspiler(), CastToffoliToCXGateTranspiler(), CastCXToCZGateTranspiler(), CastISwapToCZGateTranspiler(), SwapQubitsForAdjacencyTranspiler(LineConnectivity{6}
1──2──3──4──5──6
), CastSwapToCZGateTranspiler(), CompressSingleQubitGatesTranspiler(), SimplifyTrivialGatesTranspiler(1.0e-6), CastUniversalToRzRxRzTranspiler(), SimplifyRxGatesTranspiler(1.0e-6), CastRxToRzAndHalfRotationXTranspiler(), CompressRzGatesTranspiler(), SimplifyRzGatesTranspiler(1.0e-6), ReadoutsAreFinalInstructionsTranspiler()])
Snowflurry.SequentialTranspiler — Type.
SequentialTranspiler(Vector{<:Transpiler})
Composite transpiler object which is constructed from an array of Transpiler stages. Calling transpile(::SequentialTranspiler,::QuantumCircuit) will apply each stage in sequence to the input circuit and return a transpiled output circuit. The result of the input and output circuit on any arbitrary state Ket is unchanged (up to a global phase).
Examples
julia> transpiler = SequentialTranspiler([CompressSingleQubitGatesTranspiler(), CastToPhaseShiftAndHalfRotationXTranspiler()]);
julia> circuit = QuantumCircuit(qubit_count = 2, instructions = [sigma_x(1), hadamard(1)])
Quantum Circuit Object:
qubit_count: 2
bit_count: 2
q[1]:──X────H──
q[2]:──────────
julia> transpile(transpiler,circuit)
Quantum Circuit Object:
qubit_count: 2
bit_count: 2
q[1]:──Z────X_90────Z_90────X_m90────Z──
q[2]:───────────────────────────────────
julia> circuit = QuantumCircuit(qubit_count = 3, instructions = [sigma_x(1),sigma_y(1),control_x(2,3),phase_shift(1,π/3)])
Quantum Circuit Object:
qubit_count: 3
bit_count: 3
q[1]:──X────Y─────────P(1.0472)──
q[2]:────────────*───────────────
|
q[3]:────────────X───────────────
julia> transpile(transpiler,circuit)
Quantum Circuit Object:
qubit_count: 3
bit_count: 3
q[1]:──P(-2.0944)───────
q[2]:────────────────*──
|
q[3]:────────────────X──
Snowflurry.AllToAllConnectivity — Type.
AllToAllConnectivity <:AbstractConnectivity
A data structure to represent all-to-all qubit connectivity in an Anyon System's QPU. This connectivity type is encountered in simulated QPUs, such as the VirtualQPU
Example
julia> connectivity = AllToAllConnectivity()
AllToAllConnectivity()
Snowflurry.LineConnectivity — Type.
LineConnectivity <:AbstractConnectivity
A data structure to represent linear qubit connectivity in an Anyon System's QPU. This connectivity type is encountered in QPUs such as the AnyonYukonQPU
Fields
dimension ::Int– Qubit count in this connectivity.
Example
julia> connectivity = LineConnectivity(6)
LineConnectivity{6}
1──2──3──4──5──6
Snowflurry.LatticeConnectivity — Type.
LatticeConnectivity <:AbstractConnectivity
A data structure to represent 2D-lattice qubit connectivity in an Anyon System's QPU. This connectivity type is encountered in QPUs such as the AnyonYamaskaQPU
Fields
qubits_per_row ::Vector{Int}– number of qubits in each line, when constructing the printout.dimensions ::Vector{Int}– number of rows and columns (turned 45° in the printout).
Example
The following lattice has 4 rows, made of qubits [1, 5, 9], [2, 6, 10], [3, 7, 11] and [8, 4, 12], with each of those rows having 3 elements.
The corresponding qubits_per_row field is [2, 3, 3, 3, 1], the number of qubits in each line in the printed representation.
julia> connectivity = LatticeConnectivity(3, 4)
LatticeConnectivity{3,4}
5 ── 1
| |
9 ── 6 ── 2
| |
10 ── 7 ── 3
| |
11 ── 8 ── 4
|
12
Lattices of arbitrary dimensions can be built:
julia> connectivity = LatticeConnectivity(6, 4)
LatticeConnectivity{6,4}
5 ── 1
| |
13 ── 9 ── 6 ── 2
| | | |
21 ── 17 ── 14 ── 10 ── 7 ── 3
| | | | |
22 ── 18 ── 15 ── 11 ── 8 ── 4
| | | |
23 ── 19 ── 16 ── 12
| |
24 ── 20
Note
To match the qubit numbering used in the hardware implementation of AnyonYamaskaQPU, the LatticeConnectivity must be built using: LatticeConnectivity([1, 3, 3, 3, 2]), which is provided as the package const Snowflurry.AnyonYamaskaConnectivity.
Snowflurry.path_search — Function.
path_search(origin::Int, target::Int, connectivity::AbstractConnectivity, excluded::Vector{Int} = Vector{Int}([]))
Find the shortest path between origin and target qubits in terms of Manhattan distance, using the Breadth-First Search algorithm, on any connectivity::AbstractConnectivity, avoiding positions defined in the excluded optional argument. If no path exists, returns an empty Vector{Int}.
Example
julia> connectivity = LineConnectivity(6)
LineConnectivity{6}
1──2──3──4──5──6
julia> path = path_search(2, 5, connectivity)
4-element Vector{Int64}:
5
4
3
2
On LatticeConnectivity, the print_connectivity() method is used to visualize the path. The qubits along the path between origin and target are marker with ( )
julia> connectivity = LatticeConnectivity(6, 4)
LatticeConnectivity{6,4}
5 ── 1
| |
13 ── 9 ── 6 ── 2
| | | |
21 ── 17 ── 14 ── 10 ── 7 ── 3
| | | | |
22 ── 18 ── 15 ── 11 ── 8 ── 4
| | | |
23 ── 19 ── 16 ── 12
| |
24 ── 20
julia> path = path_search(3, 24, connectivity)
6-element Vector{Int64}:
24
20
16
12
8
3
Snowflurry.get_adjacency_list — Function.
get_adjacency_list(connectivity::AbstractConnectivity)::Dict{Int,Vector{Int}}
Given an object of type AbstractConnectivity, get_adjacency_list returns a Dict where key => value pairs are each qubit number => an Vector of the qubits that are adjacent (neighbors) to it on this particular connectivity.
Example
julia> connectivity = LineConnectivity(6)
LineConnectivity{6}
1──2──3──4──5──6
julia> get_adjacency_list(connectivity)
Dict{Int64, Vector{Int64}} with 6 entries:
5 => [4, 6]
4 => [3, 5]
6 => [5]
2 => [1, 3]
3 => [2, 4]
1 => [2]
julia> connectivity = LatticeConnectivity(3, 4)
LatticeConnectivity{3,4}
5 ── 1
| |
9 ── 6 ── 2
| |
10 ── 7 ── 3
| |
11 ── 8 ── 4
|
12
julia> get_adjacency_list(connectivity)
Dict{Int64, Vector{Int64}} with 12 entries:
5 => [9, 1]
12 => [8]
8 => [3, 12, 11, 4]
1 => [6, 5]
6 => [1, 10, 9, 2]
11 => [7, 8]
9 => [5, 6]
3 => [8, 7]
7 => [2, 11, 10, 3]
4 => [8]
2 => [7, 6]
10 => [6, 7]
Note
get_adjacency_list cannot be performed for AllToAllConnectivity, as in such a connectivity, all qubits are adjacent, with no upper bound on the number of qubits. A finite list of adjacent qubits thus cannot be constructed.
Snowflurry.get_qubits_distance — Function.
get_qubits_distance(target_1::Int, target_2::Int, ::AbstractConnectivity)
Find the length of the shortest path between target qubits in terms of Manhattan distance, using the Breadth-First Search algorithm, on any connectivity::AbstractConnectivity.
Example
julia> connectivity = LineConnectivity(6)
LineConnectivity{6}
1──2──3──4──5──6
julia> get_qubits_distance(2, 5, connectivity)
3
julia> connectivity = LatticeConnectivity(6, 4)
LatticeConnectivity{6,4}
5 ── 1
| |
13 ── 9 ── 6 ── 2
| | | |
21 ── 17 ── 14 ── 10 ── 7 ── 3
| | | | |
22 ── 18 ── 15 ── 11 ── 8 ── 4
| | | |
23 ── 19 ── 16 ── 12
| |
24 ── 20
julia> get_qubits_distance(3, 24, connectivity)
5