From ade2e19554fd09bfdaf8dde0a42285a007346f89 Mon Sep 17 00:00:00 2001 From: Ryan Shaffer <3620100+rmshaffer@users.noreply.github.com> Date: Fri, 26 Jun 2026 10:57:28 -0400 Subject: [PATCH 1/2] infra: schema updates, deprecate JAQCD --- .gitignore | 4 +- Project.toml | 6 +- .../BraketSimulatorBraketExt.jl | 22 +-- src/BraketSimulator.jl | 46 +++--- src/circuit.jl | 2 +- src/dm_simulator.jl | 2 - src/properties.jl | 145 ------------------ src/raw_schema.jl | 24 ++- src/sv_simulator.jl | 2 - test/test_braket_integration.jl | 36 ++--- test/test_dm_simulator.jl | 2 +- test/test_sv_simulator.jl | 67 +------- test/test_validation.jl | 6 +- 13 files changed, 70 insertions(+), 294 deletions(-) diff --git a/.gitignore b/.gitignore index 9a399ca..feaf2ce 100644 --- a/.gitignore +++ b/.gitignore @@ -4,9 +4,9 @@ lcov.info *.profraw *.json -/Manifest.toml -/docs/Manifest.toml +Manifest.toml /docs/build/ /.coverage +.CondaPkg/ .DS_Store */.DS_Store diff --git a/Project.toml b/Project.toml index 569ec71..ade1f2b 100644 --- a/Project.toml +++ b/Project.toml @@ -1,7 +1,7 @@ name = "BraketSimulator" uuid = "76d27892-9a0b-406c-98e4-7c178e9b3dff" -authors = ["Katharine Hyatt and contributors"] -version = "0.0.7" +authors = ["Katharine Hyatt and contributors", "Amazon Web Services"] +version = "0.0.8" [deps] Combinatorics = "861a8166-3701-5b0c-9a16-15d98fcdc6aa" @@ -27,7 +27,7 @@ BraketSimulatorBraketExt = "Braket" [compat] Aqua = "=0.8" -Braket = "0.9.5" +Braket = "0.10" Combinatorics = "=1.0.2" DataStructures = "=0.18.20" Dates = "1.6" diff --git a/ext/BraketSimulatorBraketExt/BraketSimulatorBraketExt.jl b/ext/BraketSimulatorBraketExt/BraketSimulatorBraketExt.jl index 2550cf5..e160f33 100644 --- a/ext/BraketSimulatorBraketExt/BraketSimulatorBraketExt.jl +++ b/ext/BraketSimulatorBraketExt/BraketSimulatorBraketExt.jl @@ -9,7 +9,6 @@ end Braket.name(d::BraketSimulator.AbstractSimulator) = BraketSimulator.name(d) Braket.properties(d::BraketSimulator.AbstractSimulator) = BraketSimulator.properties(d) Braket.simulate(d::BraketSimulator.AbstractSimulator, program::Braket.OpenQasmProgram, args...; kwargs...) = convert(Braket.GateModelTaskResult, BraketSimulator.simulate(d, convert(BraketSimulator.OpenQasmProgram, program), args...; kwargs...)) -Braket.simulate(d::BraketSimulator.AbstractSimulator, program::Braket.Program, qubit_count::Int, shots::Int; kwargs...) = convert(Braket.GateModelTaskResult, BraketSimulator.simulate(d, convert(BraketSimulator.Program, program), shots; kwargs...)) Base.convert(::Type{Braket.TaskMetadata}, tm::BraketSimulator.TaskMetadata) = Braket.TaskMetadata(Braket.braketSchemaHeader("braket.task_result.task_metadata", "1"), tm.id, tm.shots, tm.deviceId, tm.deviceParameters, tm.createdAt, tm.endedAt, tm.status, tm.failureReason) Base.convert(::Type{Braket.AdditionalMetadata}, am::BraketSimulator.AdditionalMetadata) = Braket.AdditionalMetadata(convert(Braket.AbstractProgram, am.action), nothing, nothing, nothing, nothing, nothing, nothing, nothing, nothing) @@ -26,6 +25,7 @@ function Base.convert(::Type{Braket.GateModelTaskResult}, r::BraketSimulator.Gat r.measurementProbabilities, rts, r.measuredQubits, + r.outputs, task_meta, addl_meta) end @@ -142,22 +142,10 @@ Base.convert(::Type{Braket.Instruction}, ix::BraketSimulator.Instruction) = Brak Base.convert(::Type{BraketSimulator.OpenQasmProgram}, p::Braket.OpenQasmProgram) = BraketSimulator.OpenQasmProgram(BraketSimulator.braketSchemaHeader("braket.ir.openqasm.program", "1"), p.source, p.inputs) -# have to handle the special case of 2-qubit Hermitians carefully due to endianness -# nosemgrep -function Base.convert(::Type{BraketSimulator.Program}, p::Braket.Program) - ixs = [convert(BraketSimulator.Instruction, ix) for ix in p.instructions] - rts = [convert(BraketSimulator.AbstractProgramResult, rt) for rt in p.results] - bris = map(p.basis_rotation_instructions) do bri - if bri.operator isa Unitary && length(bri.target) == 2 - return BraketSimulator.Instruction(BraketSimulator.Unitary(BraketSimulator.fix_endianness(bri.operator.matrix)), bri.target) - else - return convert(BraketSimulator.Instruction, bri) - end - end - p = BraketSimulator.Program(BraketSimulator.braketSchemaHeader("braket.ir.jaqcd.program", "1"), ixs, rts, bris) - return p -end -Base.convert(::Type{Braket.AbstractProgram}, p::BraketSimulator.Program) = Braket.Program(Braket.braketSchemaHeader("braket.ir.jaqcd.program", "1"), [convert(Braket.Instruction, ix) for ix in p.instructions],[convert(Braket.AbstractProgramResult, rt) for rt in p.results], [convert(Braket.Instruction, ix) for ix in p.basis_rotation_instructions]) +# Braket.jl v0.10 has no `Program` struct. A simulator-side `BraketSimulator.Program` +# (which is just a lossless Julia-side container around a Circuit) is mapped back to +# a placeholder `Braket.OpenQasmProgram` for `AdditionalMetadata.action` round-trips. +Base.convert(::Type{Braket.AbstractProgram}, p::BraketSimulator.Program) = Braket.OpenQasmProgram(Braket.braketSchemaHeader("braket.ir.openqasm.program", "1"), "", nothing) Base.convert(::Type{Braket.AbstractProgram}, p::BraketSimulator.OpenQasmProgram) = Braket.OpenQasmProgram(Braket.braketSchemaHeader("braket.ir.openqasm.program", "1"), p.source, p.inputs) function __init__() diff --git a/src/BraketSimulator.jl b/src/BraketSimulator.jl index 3fa2119..ce69209 100644 --- a/src/BraketSimulator.jl +++ b/src/BraketSimulator.jl @@ -143,6 +143,7 @@ function _bundle_results( nothing, results, sorted_qubits, + nothing, _build_metadata(simulator, circuit_ir)... ) end @@ -198,10 +199,10 @@ function _get_measured_qubits(program, qubit_count::Int) return measured_qubits end """ - _prepare_program(circuit_ir::OpenQasmProgram, inputs::Dict{String, <:Any}, shots::Int) -> (Program, Int) + _prepare_program(circuit_ir::OpenQasmProgram, inputs::Dict{String, <:Any}, shots::Int) -> (Circuit, Int) Parse the OpenQASM3 source, apply any `inputs` provided for the simulation, and compute -basis rotation instructions if running with non-zero shots. Return the `Program` after +basis rotation instructions if running with non-zero shots. Return the `Circuit` after parsing and the qubit count of the circuit. """ function _prepare_program(circuit_ir::OpenQasmProgram, inputs::Dict{String, <:Any}, shots::Int) @@ -234,7 +235,7 @@ function _prepare_program(circuit_ir::Program, inputs::Dict{String, <:Any}, shot return bound_program, qubit_count(circuit_ir) end """ - _combine_operations(program, shots::Int) -> Program + _combine_operations(program, shots::Int) -> Vector{Instruction} Combine explicit instructions and basis rotation instructions (if necessary). Validate that all operations are performed on qubits within `qubit_count`. @@ -248,14 +249,17 @@ function _combine_operations(program, shots::Int) return operations end """ - _compute_results(::, simulator, program::Program, n_qubits::Int, shots::Int) -> Vector{ResultTypeValue} + _compute_results(simulator, program, n_qubits::Int, shots::Int) -> Vector{ResultTypeValue} -Compute the results once `simulator` has finished applying all the instructions. The results depend on the IR type if `shots>0`: +Compute the results once `simulator` has finished applying all the instructions. The +behavior depends on the IR shape and on shot count: -- For JAQCD IR (`Program`), the results array is *empty* because the Braket SDK computes the results from the IR directly. -- For OpenQASM IR (`OpenQasmProgram`), the results array is *empty* only if no results are present in the parsed IR. Otherwise, - the results array is populated with the parsed result types (to help the Braket SDK compute them from the sampled measurements) - and a placeholder zero value. +- For Julia-side `Program` IR, the results array is *empty* when `shots > 0` because the + Braket SDK will compute results from the IR directly; for `shots == 0` the results are + computed analytically from the simulator state. +- For `OpenQasmProgram` IR (which is parsed into a `Circuit`), the results array is empty + only if no results are present; otherwise it is populated with the parsed result types + (and a placeholder zero value if shots > 0) so the SDK can compute them from samples. """ function _compute_results(simulator, program::Circuit, n_qubits, shots) results = program.result_types @@ -278,14 +282,14 @@ function _compute_results(simulator, program::Program, n_qubits, shots) end end function _validate_circuit_ir(simulator, circuit_ir::Program, qubit_count::Int, shots::Int) - _validate_ir_results_compatibility(simulator, circuit_ir.results, Val(:JAQCD)) - _validate_ir_instructions_compatibility(simulator, circuit_ir, Val(:JAQCD)) + _validate_ir_results_compatibility(simulator, circuit_ir.results, Val(:OpenQASM)) + _validate_ir_instructions_compatibility(simulator, circuit_ir, Val(:OpenQASM)) _validate_shots_and_ir_results(shots, circuit_ir.results, qubit_count) return end function _validate_circuit_ir(simulator, circuit_ir::Circuit, qubit_count::Int, shots::Int) - _validate_ir_results_compatibility(simulator, circuit_ir.result_types, Val(:JAQCD)) - _validate_ir_instructions_compatibility(simulator, circuit_ir, Val(:JAQCD)) + _validate_ir_results_compatibility(simulator, circuit_ir.result_types, Val(:OpenQASM)) + _validate_ir_instructions_compatibility(simulator, circuit_ir, Val(:OpenQASM)) _validate_shots_and_ir_results(shots, circuit_ir.result_types, qubit_count) return end @@ -294,11 +298,11 @@ end simulate(simulator::AbstractSimulator, circuit_ir::Union{OpenQasmProgram, Program}, shots::Int; kwargs...) -> GateModelTaskResult Simulate the evolution of a state vector or density matrix using the passed-in `simulator`. -The instructions to apply (gates and noise channels) and measurements to make are -encoded in `circuit_ir`. Supported IR formats are `OpenQASMProgram` (OpenQASM3) -and `Program` (JAQCD). Returns a `GateModelTaskResult` containing the individual shot -measurements (if `shots > 0`), final calculated results, circuit IR, and metadata -about the task. +The instructions to apply (gates and noise channels) and measurements to make are encoded in +`circuit_ir`. Supported IR formats are `OpenQasmProgram` (OpenQASM3 source string) and the +Julia-side `Program` container (typically built via `Program(c::Circuit)`). +Returns a `GateModelTaskResult` containing the individual shot measurements (if `shots > 0`), +final calculated results, circuit IR, and metadata about the task. """ function simulate( simulator::AbstractSimulator, @@ -321,9 +325,9 @@ end simulate(simulator::AbstractSimulator, circuit_irs::Vector{<:Union{Program, OpenQasmProgram}}, shots::Int; max_parallel::Int=min(32, Threads.nthreads()), inputs=Dict{String,Float64}(), kwargs...) -> Vector{GateModelTaskResult} Simulate the evolution of a *batch* of state vectors or density matrices using the passed in `simulator`. -The instructions to apply (gates and noise channels) and measurements to make are -encoded in `circuit_irs`. Supported IR formats are `OpenQASMProgram` (OpenQASM3) -and `Program` (JAQCD). +The instructions to apply (gates and noise channels) and measurements to make are encoded in +`circuit_irs`. Supported IR formats are `OpenQasmProgram` (OpenQASM3 source string) and the +Julia-side `Program` container. The simulation of the batch is done in parallel using threads. The keyword argument `max_parallel` specifies the number of evolutions to simulate in diff --git a/src/circuit.jl b/src/circuit.jl index c0d3339..bc8117e 100644 --- a/src/circuit.jl +++ b/src/circuit.jl @@ -80,7 +80,7 @@ qubit_count(p::Program) = length(qubits(p)) function Base.convert(::Type{Program}, c::Circuit) # nosemgrep lowered_rts = map(StructTypes.lower, c.result_types) - header = braketSchemaHeader("braket.ir.jaqcd.program" ,"1") + header = braketSchemaHeader("braket.ir.openqasm.program", "1") return Program(header, c.instructions, lowered_rts, c.basis_rotation_instructions) end Program(c::Circuit) = convert(Program, c) diff --git a/src/dm_simulator.jl b/src/dm_simulator.jl index 35763b9..f8f3161 100644 --- a/src/dm_simulator.jl +++ b/src/dm_simulator.jl @@ -71,10 +71,8 @@ Query the properties and capabilities of a `DensityMatrixSimulator`, including w """ properties(d::DensityMatrixSimulator) = dm_props supported_operations(d::DensityMatrixSimulator, ::Val{:OpenQASM}) = dm_props.action["braket.ir.openqasm.program"].supportedOperations -supported_operations(d::DensityMatrixSimulator, ::Val{:JAQCD}) = dm_props.action["braket.ir.jaqcd.program"].supportedOperations supported_operations(d::DensityMatrixSimulator) = supported_operations(d::DensityMatrixSimulator, Val(:OpenQASM)) supported_result_types(d::DensityMatrixSimulator, ::Val{:OpenQASM}) = dm_props.action["braket.ir.openqasm.program"].supportedResultTypes -supported_result_types(d::DensityMatrixSimulator, ::Val{:JAQCD}) = dm_props.action["braket.ir.jaqcd.program"].supportedResultTypes supported_result_types(d::DensityMatrixSimulator) = supported_result_types(d::DensityMatrixSimulator, Val(:OpenQASM)) device_id(dms::DensityMatrixSimulator) = "braket_dm_v2" name(dms::DensityMatrixSimulator) = "DensityMatrixSimulator" diff --git a/src/properties.jl b/src/properties.jl index 77616d4..c6f0c85 100644 --- a/src/properties.jl +++ b/src/properties.jl @@ -17,77 +17,6 @@ const sv_props_dict = Dict( :shotsRange => [0, sv_max_shots], ), :action => Dict( - "braket.ir.jaqcd.program" => Dict( - :actionType => "braket.ir.jaqcd.program", - :version => ["1"], - :supportedOperations => [ - "ccnot", - "cnot", - "cphaseshift", - "cphaseshift00", - "cphaseshift01", - "cphaseshift10", - "cswap", - "cv", - "cy", - "cz", - "ecr", - "h", - "i", - "iswap", - "pswap", - "phaseshift", - "prx", - "rx", - "ry", - "rz", - "s", - "si", - "swap", - "t", - "ti", - "unitary", - "v", - "vi", - "x", - "xx", - "xy", - "y", - "yy", - "z", - "zz", - ], - :supportedResultTypes => [ - Dict( - :name => "Sample", - :observables => sv_observables, - :minShots => 1, - :maxShots => sv_max_shots, - ), - Dict( - :name => "Expectation", - :observables => sv_observables, - :minShots => 0, - :maxShots => sv_max_shots, - ), - Dict( - :name => "Variance", - :observables => sv_observables, - :minShots => 0, - :maxShots => sv_max_shots, - ), - Dict( - :name => "Adjoint_Gradient", - :observables => sv_observables, - :minShots => 0, - :maxShots => 0, - ), - Dict(:name => "Probability", :minShots => 0, :maxShots => sv_max_shots), - Dict(:name => "StateVector", :minShots => 0, :maxShots => 0), - Dict(:name => "DensityMatrix", :minShots => 0, :maxShots => 0), - Dict(:name => "Amplitude", :minShots => 0, :maxShots => 0), - ], - ), "braket.ir.openqasm.program" => Dict( :actionType => "braket.ir.openqasm.program", :version => ["1"], @@ -336,80 +265,6 @@ const dm_props_dict = Dict( :supportsUnassignedMeasurements => true, :disabledQubitRewiringSupported => false, ), - "braket.ir.jaqcd.program" => Dict( - :actionType => "braket.ir.jaqcd.program", - :version => ["1"], - :supportedOperations => [ - "amplitude_damping", - "bit_flip", - "ccnot", - "cnot", - "cphaseshift", - "cphaseshift00", - "cphaseshift01", - "cphaseshift10", - "cswap", - "cv", - "cy", - "cz", - "depolarizing", - "ecr", - "generalized_amplitude_damping", - "h", - "i", - "iswap", - "kraus", - "pauli_channel", - "two_qubit_pauli_channel", - "phase_flip", - "phase_damping", - "phaseshift", - "pswap", - "prx", - "rx", - "ry", - "rz", - "s", - "si", - "swap", - "t", - "ti", - "two_qubit_dephasing", - "two_qubit_depolarizing", - "unitary", - "v", - "vi", - "x", - "xx", - "xy", - "y", - "yy", - "z", - "zz", - ], - :supportedResultTypes => [ - Dict( - :name => "Sample", - :observables => dm_observables, - :minShots => 1, - :maxShots => dm_max_shots, - ), - Dict( - :name => "Expectation", - :observables => dm_observables, - :minShots => 0, - :maxShots => dm_max_shots, - ), - Dict( - :name => "Variance", - :observables => dm_observables, - :minShots => 0, - :maxShots => dm_max_shots, - ), - Dict(:name => "Probability", :minShots => 0, :maxShots => dm_max_shots), - Dict(:name => "DensityMatrix", :minShots => 0, :maxShots => 0), - ], - ), ), :paradigm => Dict(:qubitCount => dm_qubit_count), :deviceParameters => diff --git a/src/raw_schema.jl b/src/raw_schema.jl index e41fe4e..6c0ad99 100644 --- a/src/raw_schema.jl +++ b/src/raw_schema.jl @@ -16,8 +16,8 @@ abstract type AbstractProgram <: BraketSchemaBase end StructTypes.StructType(::Type{AbstractProgram}) = StructTypes.AbstractType() function bsh_f(raw_symbol::Symbol) raw = String(raw_symbol) - v = eval(Meta.parse(raw)) - return v["name"] == "braket.ir.openqasm.program" ? OpenQasmProgram : Program + eval(Meta.parse(raw)) + return OpenQasmProgram end StructTypes.subtypes(::Type{AbstractProgram}) = StructTypes.SubTypeClosure(bsh_f) StructTypes.subtypekey(::Type{AbstractProgram}) = :braketSchemaHeader @@ -91,7 +91,7 @@ end # module using .IR -@enum DeviceActionType openqasm jaqcd +@enum DeviceActionType openqasm DeviceActionTypeDict = Dict(string(inst)=>inst for inst in instances(DeviceActionType)) struct ResultType @@ -135,14 +135,6 @@ end ResultTypeValue(nt::@NamedTuple{type::AbstractProgramResult, value::Union{Float64, Dict, Vector}}) = ResultTypeValue(nt.type, nt.value) StructTypes.lowertype(::Type{ResultTypeValue}) = @NamedTuple{type::AbstractProgramResult, value::Union{Float64, Dict, Vector}} -struct JaqcdDeviceActionProperties <: DeviceActionProperties - version::Vector{String} - actionType::String - supportedOperations::Union{Nothing, Vector{String}} - supportedResultTypes::Union{Nothing, Vector{ResultType}} - disabledQubitRewiringSupported::Union{Nothing, Bool} -end - struct ControlMod name::String max_qubits::Union{Nothing, Int} @@ -180,6 +172,7 @@ struct OpenQASMDeviceActionProperties <: DeviceActionProperties disabledQubitRewiringSupported::Bool supportedResultTypes::Union{Nothing, Vector{ResultType}} end +StructTypes.defaults(::Type{OpenQASMDeviceActionProperties}) = Dict{Symbol, Any}(:supportedModifiers => Any[], :supportsUnassignedMeasurements => true, :requiresAllQubitsMeasurement => false, :supportedPragmas => Any[], :supportPhysicalQubits => false, :supportsPartialVerbatimBox => true, :forbiddenPragmas => Any[], :requiresContiguousQubitIndices => false, :disabledQubitRewiringSupported => false, :forbiddenArrayOperations => String[], :maximumQubitArrays => nothing, :maximumClassicalArrays => nothing) struct GateModelParameters <: BraketSchemaBase braketSchemaHeader::braketSchemaHeader @@ -206,13 +199,14 @@ struct DeviceServiceProperties <: BraketSchemaBase braketSchemaHeader::braketSchemaHeader executionWindows::Vector{DeviceExecutionWindow} shotsRange::Tuple{Int, Int} + reservationShotsRange::Union{Nothing, Tuple{Int, Int}} deviceCost::Nothing deviceDocumentation::Nothing deviceLocation::Nothing updatedAt::Nothing getTaskPollIntervalMillis::Nothing end -StructTypes.defaults(::Type{DeviceServiceProperties}) = Dict{Symbol, Any}(:braketSchemaHeader => braketSchemaHeader("braket.device_schema.device_service_properties", "1")) +StructTypes.defaults(::Type{DeviceServiceProperties}) = Dict{Symbol, Any}(:braketSchemaHeader => braketSchemaHeader("braket.device_schema.device_service_properties", "1"), :reservationShotsRange => nothing) struct GateModelSimulatorParadigmProperties <: BraketSchemaBase braketSchemaHeader::braketSchemaHeader @@ -222,7 +216,7 @@ StructTypes.defaults(::Type{GateModelSimulatorParadigmProperties}) = Dict{Symbol struct GateModelSimulatorDeviceCapabilities <: BraketSchemaBase service::DeviceServiceProperties - action::Dict{Union{DeviceActionType, String}, Union{OpenQASMDeviceActionProperties, JaqcdDeviceActionProperties}} + action::Dict{Union{DeviceActionType, String}, OpenQASMDeviceActionProperties} deviceParameters::Dict braketSchemaHeader::braketSchemaHeader paradigm::GateModelSimulatorParadigmProperties @@ -246,15 +240,19 @@ struct TaskMetadata <: BraketSchemaBase failureReason::Union{Nothing, String} end +const OutputValue = Any + struct GateModelTaskResult <: BraketSchemaBase braketSchemaHeader::braketSchemaHeader measurements::Union{Nothing, Vector{Vector{Int}}} measurementProbabilities::Union{Nothing, Dict{String, Float64}} resultTypes::Union{Nothing, Vector{ResultTypeValue}} measuredQubits::Union{Nothing, Vector{Int}} + outputs::Union{Nothing, Vector{Dict{String, OutputValue}}} taskMetadata::TaskMetadata additionalMetadata::AdditionalMetadata end +StructTypes.defaults(::Type{GateModelTaskResult}) = Dict{Symbol, Any}(:outputs => nothing) struct GenericDeviceActionProperties <: DeviceActionProperties version::Vector{String} diff --git a/src/sv_simulator.jl b/src/sv_simulator.jl index ce4f0ee..135d9ff 100644 --- a/src/sv_simulator.jl +++ b/src/sv_simulator.jl @@ -75,9 +75,7 @@ Query the properties and capabilities of a `StateVectorSimulator`, including whi properties(svs::StateVectorSimulator) = sv_props supported_operations(svs::StateVectorSimulator, ::Val{:OpenQASM}) = sv_props.action["braket.ir.openqasm.program"].supportedOperations supported_operations(svs::StateVectorSimulator) = supported_operations(svs::StateVectorSimulator, Val(:OpenQASM)) -supported_operations(svs::StateVectorSimulator, ::Val{:JAQCD}) = sv_props.action["braket.ir.jaqcd.program"].supportedOperations supported_result_types(svs::StateVectorSimulator, ::Val{:OpenQASM}) = sv_props.action["braket.ir.openqasm.program"].supportedResultTypes -supported_result_types(svs::StateVectorSimulator, ::Val{:JAQCD}) = sv_props.action["braket.ir.jaqcd.program"].supportedResultTypes supported_result_types(svs::StateVectorSimulator) = supported_result_types(svs::StateVectorSimulator, Val(:OpenQASM)) device_id(svs::StateVectorSimulator) = "braket_sv_v2" name(svs::StateVectorSimulator) = "StateVectorSimulator" diff --git a/test/test_braket_integration.jl b/test/test_braket_integration.jl index 0b9d62d..c56225f 100644 --- a/test/test_braket_integration.jl +++ b/test/test_braket_integration.jl @@ -140,7 +140,7 @@ end state_001 = Braket.Circuit([(Braket.I, 0), (Braket.I, 1), (Braket.X, 2)]) @testset for (state, most_com) in ((state_110, "110"), (state_001, "001")) - tasks = (state, ir(state, Val(:JAQCD)), ir(state, Val(:OpenQASM))) + tasks = (state, ir(state, Val(:OpenQASM))) @testset for task in tasks res = result(device(task, shots = SHOTS)) mc = argmax(res.measurement_counts) @@ -153,7 +153,7 @@ end circuit = bell_circ() circuit(Braket.Expectation, Braket.Observables.H() * Braket.Observables.X(), [0, 1]) circuit(Braket.Sample, Braket.Observables.H() * Braket.Observables.X(), [0, 1]) - tasks = (circuit, ir(circuit, Val(:JAQCD)), ir(circuit, Val(:OpenQASM))) + tasks = (circuit, ir(circuit, Val(:OpenQASM))) @testset for task in tasks device = DEVICE res = result(device(task; shots = SHOTS)) @@ -170,7 +170,7 @@ end @testset "Bell pair full probability" begin circuit = bell_circ() circuit(Braket.Probability) - tasks = (circuit, ir(circuit, Val(:JAQCD)), ir(circuit, Val(:OpenQASM))) + tasks = (circuit, ir(circuit, Val(:OpenQASM))) tol = get_tol(SHOTS) @testset for task in tasks device = DEVICE @@ -187,7 +187,7 @@ end @testset "Bell pair marginal probability" begin circuit = bell_circ() circuit(Braket.Probability, 0) - tasks = (circuit, ir(circuit, Val(:JAQCD)), ir(circuit, Val(:OpenQASM))) + tasks = (circuit, ir(circuit, Val(:OpenQASM))) tol = get_tol(SHOTS) @testset for task in tasks device = DEVICE @@ -223,7 +223,7 @@ end ) circuit = three_qubit_circuit(θ, ϕ, φ, obs, obs_targets) shots > 0 && circuit(Braket.Sample, obs, obs_targets) - tasks = (circuit, ir(circuit, Val(:JAQCD)), ir(circuit, Val(:OpenQASM))) + tasks = (circuit, ir(circuit, Val(:OpenQASM))) for task in tasks res = result(device(task, shots = shots)) variance_expectation_sample_result( @@ -257,7 +257,7 @@ end ) circuit = three_qubit_circuit(θ, ϕ, φ, obs, obs_targets) shots > 0 && circuit(Braket.Sample, obs, obs_targets) - tasks = (circuit, ir(circuit, Val(:JAQCD)), ir(circuit, Val(:OpenQASM))) + tasks = (circuit, ir(circuit, Val(:OpenQASM))) for task in tasks res = result(device(task, shots = shots)) variance_expectation_sample_result( @@ -286,7 +286,7 @@ end ) circuit = three_qubit_circuit(θ, ϕ, φ, obs, obs_targets) shots > 0 && circuit(Braket.Sample, obs, obs_targets) - tasks = (circuit, ir(circuit, Val(:JAQCD)), ir(circuit, Val(:OpenQASM))) + tasks = (circuit, ir(circuit, Val(:OpenQASM))) @testset for task in tasks res = result(device(task, shots = shots)) variance_expectation_sample_result( @@ -379,7 +379,7 @@ end shots = SHOTS circuit = three_qubit_circuit(θ, ϕ, φ, obs, obs_targets) shots > 0 && circuit(Braket.Sample, obs, obs_targets) - tasks = (circuit, ir(circuit, Val(:JAQCD)), ir(circuit, Val(:OpenQASM))) + tasks = (circuit, ir(circuit, Val(:OpenQASM))) for task in tasks res = result(device(task, shots = shots)) variance_expectation_sample_result( @@ -440,7 +440,7 @@ end shots = SHOTS circuit = three_qubit_circuit(θ, ϕ, φ, obs, targets) shots > 0 && circuit(Braket.Sample, obs, targets) - tasks = (circuit, ir(circuit, Val(:JAQCD)), ir(circuit, Val(:OpenQASM))) + tasks = (circuit, ir(circuit, Val(:OpenQASM))) for task in tasks res = result(device(task; shots = shots)) variance_expectation_sample_result( @@ -467,7 +467,7 @@ end circuit = Braket.Circuit([(Braket.Rx, 0, θ), (Braket.Rx, 1, θ), (Braket.Variance, ho), (Braket.Expectation, ho, 0)]) shots > 0 && circuit(Braket.Sample, ho, 1) - tasks = (circuit, ir(circuit, Val(:JAQCD)), ir(circuit, Val(:OpenQASM))) + tasks = (circuit, ir(circuit, Val(:OpenQASM))) for task in tasks res = result(device(task; shots = shots)) tol = get_tol(shots) @@ -541,7 +541,7 @@ end expected_mean2 = 0.849694136476246 expected_mean3 = 1.4499810303182408 - tasks = (circuit, ir(circuit, Val(:JAQCD)), ir(circuit, Val(:OpenQASM))) + tasks = (circuit, ir(circuit, Val(:OpenQASM))) @testset for task in tasks device = DEVICE res = result(device(task, shots = shots)) @@ -556,7 +556,7 @@ end tp = Braket.Observables.TensorProduct(["h", "x"]) circuit = Braket.Expectation(circuit, tp, [0, 1]) circuit = Braket.Expectation(circuit, tp, [1, 0]) - tasks = (circuit, ir(circuit, Val(:JAQCD)), ir(circuit, Val(:OpenQASM))) + tasks = (circuit, ir(circuit, Val(:OpenQASM))) @testset for task in tasks device = DEVICE res = result(device(task, shots = 0)) @@ -569,7 +569,7 @@ end ho = [1 2im; -2im 0] circuit(Braket.Expectation, Braket.Observables.HermitianObservable(ho)) circuit(Braket.Expectation, Braket.Observables.X()) - tasks = (circuit, ir(circuit, Val(:JAQCD)), ir(circuit, Val(:OpenQASM))) + tasks = (circuit, ir(circuit, Val(:OpenQASM))) @testset for task in tasks device = DEVICE res = result(device(task, shots = 0)) @@ -585,7 +585,7 @@ end @test qubit_count(bell) == 4 shots = SHOTS device = DEVICE - @testset for task in (bell, ir(bell, Val(:JAQCD)), bell_qasm) + @testset for task in (bell, bell_qasm) tol = get_tol(shots) res = result(device(task, shots = shots)) @test isapprox(res.values[1], 0, rtol = tol["rtol"], atol = tol["atol"]) @@ -600,7 +600,7 @@ end circuit = bell_circ() circuit(Braket.Expectation, Braket.Observables.H() * Braket.Observables.X(), 0, 1) include_amplitude && circuit(Braket.Amplitude, ["01", "10", "00", "11"]) - tasks = (circuit, ir(circuit, Val(:JAQCD)), ir(circuit, Val(:OpenQASM))) + tasks = (circuit, ir(circuit, Val(:OpenQASM))) @testset for task in tasks device = DEVICE shots = 0 @@ -623,7 +623,7 @@ end if SHOTS > 0 @testset "Multithreaded Bell pair" begin tol = get_tol(SHOTS) - tasks = (bell_circ, (()->ir(bell_circ(), Val(:JAQCD))), (()->ir(bell_circ(), Val(:OpenQASM)))) + tasks = (bell_circ, (()->ir(bell_circ(), Val(:OpenQASM)))) device = DEVICE @testset for task in tasks, task_count in (1, 10) task_array = [task() for ii = 1:task_count] @@ -652,7 +652,7 @@ end shots = SHOTS tol = get_tol(shots) circuit = Braket.Circuit([(Braket.X, 0), (Braket.X, 1), (Braket.BitFlip, 0, 0.1), (Braket.Probability,)]) - tasks = (circuit, ir(circuit, Val(:JAQCD)), ir(circuit, Val(:OpenQASM))) + tasks = (circuit, ir(circuit, Val(:OpenQASM))) device = DEVICE for task in tasks res = result(device(task, shots = shots)) @@ -672,7 +672,7 @@ end K1 = √0.1 * kron([0.0 1.0; 1.0 0.0], [0.0 1.0; 1.0 0.0]) circuit = Braket.Circuit([(Braket.X, 0), (Braket.X, 1), (Braket.Kraus, [0, 1], [K0, K1]), (Braket.Probability,)]) - tasks = (circuit, ir(circuit, Val(:JAQCD)), ir(circuit, Val(:OpenQASM))) + tasks = (circuit, ir(circuit, Val(:OpenQASM))) device = DEVICE for task in tasks res = result(device(task, shots = shots)) diff --git a/test/test_dm_simulator.jl b/test/test_dm_simulator.jl index c76e062..ec517f6 100644 --- a/test/test_dm_simulator.jl +++ b/test/test_dm_simulator.jl @@ -381,7 +381,7 @@ LARGE_TESTS = get(ENV, "BRAKET_SIM_LARGE_TESTS", "false") == "true" end @testset "batch" begin function make_ghz(num_qubits) - ghz = BraketSimulator.Program(BraketSimulator.braketSchemaHeader("braket.ir.jaqcd.program", "1"), BraketSimulator.Instruction[BraketSimulator.Instruction(BraketSimulator.H(), 0)], BraketSimulator.AbstractProgramResult[], BraketSimulator.Instruction[]) + ghz = BraketSimulator.Program(BraketSimulator.braketSchemaHeader("braket.ir.openqasm.program", "1"), BraketSimulator.Instruction[BraketSimulator.Instruction(BraketSimulator.H(), 0)], BraketSimulator.AbstractProgramResult[], BraketSimulator.Instruction[]) for ii in 0:num_qubits-2 push!(ghz.instructions, BraketSimulator.Instruction(BraketSimulator.CNot(), [ii, ii+1])) end diff --git a/test/test_sv_simulator.jl b/test/test_sv_simulator.jl index a96dea2..7f4b26a 100644 --- a/test/test_sv_simulator.jl +++ b/test/test_sv_simulator.jl @@ -398,7 +398,7 @@ LARGE_TESTS = get(ENV, "BRAKET_SIM_LARGE_TESTS", "false") == "true" end @testset "batch" begin function make_ghz(num_qubits) - ghz = BraketSimulator.Program(BraketSimulator.braketSchemaHeader("braket.ir.jaqcd.program", "1"), BraketSimulator.Instruction[BraketSimulator.Instruction(BraketSimulator.H(), 0)], BraketSimulator.AbstractProgramResult[], BraketSimulator.Instruction[]) + ghz = BraketSimulator.Program(BraketSimulator.braketSchemaHeader("braket.ir.openqasm.program", "1"), BraketSimulator.Instruction[BraketSimulator.Instruction(BraketSimulator.H(), 0)], BraketSimulator.AbstractProgramResult[], BraketSimulator.Instruction[]) for ii in 1:num_qubits-1 push!(ghz.instructions, BraketSimulator.Instruction(BraketSimulator.CNot(), [0, ii])) end @@ -529,71 +529,6 @@ LARGE_TESTS = get(ENV, "BRAKET_SIM_LARGE_TESTS", "false") == "true" :shotsRange => [0, new_sv_max_shots], ), :action => Dict( - "braket.ir.jaqcd.program" => Dict( - :actionType => "braket.ir.jaqcd.program", - :version => ["1"], - :supportedOperations => [ - "ccnot", - "cnot", - "cphaseshift", - "cphaseshift00", - "cphaseshift01", - "cphaseshift10", - "cswap", - "cv", - "cy", - "cz", - "ecr", - "h", - "i", - "iswap", - "pswap", - "phaseshift", - "prx", - "rx", - "ry", - "rz", - "s", - "si", - "swap", - "t", - "ti", - "unitary", - "v", - "vi", - "x", - "xx", - "xy", - "y", - "yy", - "z", - "zz", - ], - :supportedResultTypes => [ - Dict( - :name => "Sample", - :observables => new_sv_observables, - :minShots => 1, - :maxShots => new_sv_max_shots, - ), - Dict( - :name => "Expectation", - :observables => new_sv_observables, - :minShots => 0, - :maxShots => new_sv_max_shots, - ), - Dict( - :name => "Variance", - :observables => new_sv_observables, - :minShots => 0, - :maxShots => new_sv_max_shots, - ), - Dict(:name => "Probability", :minShots => 0, :maxShots => new_sv_max_shots), - Dict(:name => "StateVector", :minShots => 0, :maxShots => 0), - Dict(:name => "DensityMatrix", :minShots => 0, :maxShots => 0), - Dict(:name => "Amplitude", :minShots => 0, :maxShots => 0), - ], - ), "braket.ir.openqasm.program" => Dict( :actionType => "braket.ir.openqasm.program", :version => ["1"], diff --git a/test/test_validation.jl b/test/test_validation.jl index 255f167..ec79a97 100644 --- a/test/test_validation.jl +++ b/test/test_validation.jl @@ -9,7 +9,7 @@ using Test, BraketSimulator type::String NotARealIRResult() = new("notarealresult") end - @test_throws ErrorException BraketSimulator._validate_ir_results_compatibility(sim, [NotARealIRResult()], Val(:JAQCD)) + @test_throws ErrorException BraketSimulator._validate_ir_results_compatibility(sim, [NotARealIRResult()], Val(:OpenQASM)) c = BraketSimulator.Circuit() BraketSimulator.add_instruction!(c, BraketSimulator.Instruction(BraketSimulator.Rx(BraketSimulator.FreeParameter(:α)), 0)) @test_throws ErrorException BraketSimulator._validate_input_provided(c) @@ -36,11 +36,11 @@ using Test, BraketSimulator sim = DensityMatrixSimulator(2, 0) @test_logs (:warn, "You are running a noise-free circuit on the density matrix simulator. Consider running this circuit on the state vector simulator: LocalSimulator(\"braket_sv_v2\") for a better user experience.") BraketSimulator._validate_ir_instructions_compatibility(sim, c, Val(:OpenQASM)) - @test_logs (:warn, "You are running a noise-free circuit on the density matrix simulator. Consider running this circuit on the state vector simulator: LocalSimulator(\"braket_sv_v2\") for a better user experience.") BraketSimulator._validate_ir_instructions_compatibility(sim, c, Val(:JAQCD)) + @test_logs (:warn, "You are running a noise-free circuit on the density matrix simulator. Consider running this circuit on the state vector simulator: LocalSimulator(\"braket_sv_v2\") for a better user experience.") BraketSimulator._validate_ir_instructions_compatibility(sim, c, Val(:OpenQASM)) sim = StateVectorSimulator(2, 0) BraketSimulator.add_instruction!(c, BraketSimulator.Instruction(BraketSimulator.BitFlip(0.1), 0)) @test_throws ValidationError BraketSimulator._validate_ir_instructions_compatibility(sim, c, Val(:OpenQASM)) - @test_throws ValidationError BraketSimulator._validate_ir_instructions_compatibility(sim, c, Val(:JAQCD)) + @test_throws ValidationError BraketSimulator._validate_ir_instructions_compatibility(sim, c, Val(:OpenQASM)) mat = rand(4, 4) obs = BraketSimulator.Observables.HermitianObservable(mat + mat') From 990c2601f2c5f0adcc3334c6a8656f210c4009b4 Mon Sep 17 00:00:00 2001 From: Ryan Shaffer <3620100+rmshaffer@users.noreply.github.com> Date: Fri, 26 Jun 2026 11:00:15 -0400 Subject: [PATCH 2/2] minor tweaks --- ext/BraketSimulatorBraketExt/BraketSimulatorBraketExt.jl | 3 --- test/test_validation.jl | 2 -- 2 files changed, 5 deletions(-) diff --git a/ext/BraketSimulatorBraketExt/BraketSimulatorBraketExt.jl b/ext/BraketSimulatorBraketExt/BraketSimulatorBraketExt.jl index e160f33..d5229fb 100644 --- a/ext/BraketSimulatorBraketExt/BraketSimulatorBraketExt.jl +++ b/ext/BraketSimulatorBraketExt/BraketSimulatorBraketExt.jl @@ -142,9 +142,6 @@ Base.convert(::Type{Braket.Instruction}, ix::BraketSimulator.Instruction) = Brak Base.convert(::Type{BraketSimulator.OpenQasmProgram}, p::Braket.OpenQasmProgram) = BraketSimulator.OpenQasmProgram(BraketSimulator.braketSchemaHeader("braket.ir.openqasm.program", "1"), p.source, p.inputs) -# Braket.jl v0.10 has no `Program` struct. A simulator-side `BraketSimulator.Program` -# (which is just a lossless Julia-side container around a Circuit) is mapped back to -# a placeholder `Braket.OpenQasmProgram` for `AdditionalMetadata.action` round-trips. Base.convert(::Type{Braket.AbstractProgram}, p::BraketSimulator.Program) = Braket.OpenQasmProgram(Braket.braketSchemaHeader("braket.ir.openqasm.program", "1"), "", nothing) Base.convert(::Type{Braket.AbstractProgram}, p::BraketSimulator.OpenQasmProgram) = Braket.OpenQasmProgram(Braket.braketSchemaHeader("braket.ir.openqasm.program", "1"), p.source, p.inputs) diff --git a/test/test_validation.jl b/test/test_validation.jl index ec79a97..03fef6d 100644 --- a/test/test_validation.jl +++ b/test/test_validation.jl @@ -36,11 +36,9 @@ using Test, BraketSimulator sim = DensityMatrixSimulator(2, 0) @test_logs (:warn, "You are running a noise-free circuit on the density matrix simulator. Consider running this circuit on the state vector simulator: LocalSimulator(\"braket_sv_v2\") for a better user experience.") BraketSimulator._validate_ir_instructions_compatibility(sim, c, Val(:OpenQASM)) - @test_logs (:warn, "You are running a noise-free circuit on the density matrix simulator. Consider running this circuit on the state vector simulator: LocalSimulator(\"braket_sv_v2\") for a better user experience.") BraketSimulator._validate_ir_instructions_compatibility(sim, c, Val(:OpenQASM)) sim = StateVectorSimulator(2, 0) BraketSimulator.add_instruction!(c, BraketSimulator.Instruction(BraketSimulator.BitFlip(0.1), 0)) @test_throws ValidationError BraketSimulator._validate_ir_instructions_compatibility(sim, c, Val(:OpenQASM)) - @test_throws ValidationError BraketSimulator._validate_ir_instructions_compatibility(sim, c, Val(:OpenQASM)) mat = rand(4, 4) obs = BraketSimulator.Observables.HermitianObservable(mat + mat')