nice

Author: J-C-Q

src/Backends/Qiskit/IBMBackend.jl

@@ -51,25 +51,7 @@ function MQC.execute(backend::IBMBackend; shots=1)
     println("Job ID: $(job.job_id())")
 end
 
-function execute(circuit::MQC.Circuit, backend::IBMBackend; verbose::Bool=true)
-    verbose && print("Transpiling circuit to Qiskit...")
-    qc = MQC.translate(QuantumCircuit, circuit)
-    verbose && println("✓")
 
-    verbose && print("Transpiling circuit to backend...")
-    transpile!(qc, backend)
-    verbose && println("✓")
-
-    verbose && print("Initializing sampler...")
-    sampler = Sampler(backend)
-    verbose && println("✓")
-
-    verbose && print("Submitting job...")
-    job = run(sampler, qc)
-    verbose && println("✓")
-
-    verbose && println("Job ID: $(job.job_id())")
-end
 
 function isSimulator(::IBMBackend)
     return false

src/Backends/Qiskit/QuantumCircuit.jl

@@ -25,17 +25,4 @@ function nQubits(circuit::Circuit)
     return circuit.num_qubits
 end
 
-function depth(operation::MQC.Operation, ::Type{Circuit})
-    throw(ArgumentError("depth in Qiskit is not implemented for $(typeof(operation)). Please implement this method for your custom operation."))
-end
 
-function translate(::Type{Circuit}, circuit::MQC.CompiledCircuit)
-    _checkinit_qiskit()
-    total_qubits = circuit.n_qubits + circuit.n_ancilla
-    qc = Circuit(total_qubits, total_qubits)
-    for i in 1:MQC.depth(circuit)
-        operation, position, ancilla = circuit[i]
-        apply!(qc, MQC.getOperationByIndex(circuit, operation), position, ancilla)
-    end
-    return qc
-end

src/Backends/Qiskit/Result.jl

@@ -8,26 +8,26 @@
 #     end
 # end
 
-struct QiskitResult #<: MQC.Result
-    measurementOutcomes::Matrix{Bool}
-    # measuredQubits::Vector{Vector{Int64}}
-    nativeResult::PythonCall.Py
-
-    function QiskitResult(nativeResult::PythonCall.Py, circuit::MQC.CompiledCircuit)
-        _checkinit_qiskit()
-        # nMeasurements = MQC.nMeasurements(circuit)
-        bitstrings = PythonCall.pyconvert(Vector{String}, nativeResult.data.c.get_bitstrings())
-        measurementOutcomes = hcat(map(s -> [c == '1' for c in reverse(s)], bitstrings)...)
-
-
-        # measuredQubits = zeros(Int, nMeasurements)
-        new(measurementOutcomes, nativeResult)
-    end
-end
-
-function Base.show(io::IO, ::MIME"text/plain", obj::QiskitResult)
-    print(io, obj.measurementOutcomes)
-end
+# struct QiskitResult #<: MQC.Result
+#     measurementOutcomes::Matrix{Bool}
+#     # measuredQubits::Vector{Vector{Int64}}
+#     nativeResult::PythonCall.Py
+
+#     function QiskitResult(nativeResult::PythonCall.Py, circuit::MQC.CompiledCircuit)
+#         _checkinit_qiskit()
+#         # nMeasurements = MQC.nMeasurements(circuit)
+#         bitstrings = PythonCall.pyconvert(Vector{String}, nativeResult.data.c.get_bitstrings())
+#         measurementOutcomes = hcat(map(s -> [c == '1' for c in reverse(s)], bitstrings)...)
+
+
+#         # measuredQubits = zeros(Int, nMeasurements)
+#         new(measurementOutcomes, nativeResult)
+#     end
+# end
+
+# function Base.show(io::IO, ::MIME"text/plain", obj::QiskitResult)
+#     print(io, obj.measurementOutcomes)
+# end
 
 
 # function QiskitResult(Backend::Type{AerSimulator}, python_interface::PythonCall.Py)

src/Backends/Qiskit/Simulation.jl

@@ -95,28 +95,3 @@ function MQC.execute(backend::AerSimulator; shots=1)
     return nativeResult
 end
 
-function MQC.execute(circuit::MQC.CompiledCircuit, backend::AerSimulator; shots=1024)
-    verbose = false
-    verbose && print("Transpiling circuit to Qiskit...")
-    qc = translate(Circuit, circuit)
-    verbose && println("✓")
-
-    verbose && print("Transpiling circuit to backend...")
-    transpile!(qc, backend)
-    verbose && println("✓")
-
-    verbose && print("Initializing sampler...")
-    sampler = Sampler(backend)
-    verbose && println("✓")
-
-    verbose && print("Simulating circuit...")
-    job = run(sampler, qc; shots)
-
-
-    nativeResult = job.result()[0]
-    verbose && println("✓")
-    result = QiskitResult(nativeResult, circuit)
-
-    # verbose && println("Job ID: $(job.job_id())")
-    return result
-end

src/Backends/QuantumClifford/Simulation.jl

@@ -8,22 +8,52 @@ struct TableauSimulator <: MonitoredQuantumCircuits.Simulator
     state::QC.MixedDestabilizer{QC.Tableau{Vector{UInt8},Matrix{UInt64}}}
     operator::QC.PauliOperator{Array{UInt8,0},Vector{UInt64}}
     measurements::BitVector
-    function TableauSimulator(qubits::Integer; mixed=true, basis=:Z)
+    measured_qubits::Vector{Int64}
+    ancillas::Int64
+    function TableauSimulator(qubits::Integer; ancillas=0, mixed=true, basis=:Z)
         if mixed
             state = QC.MixedDestabilizer(zero(QC.Stabilizer, qubits))
             operator = QC.zero(QC.PauliOperator, qubits)
-            new(state, operator, falses(0))
+            new(state, operator, falses(0), Int64[], ancillas)
         else
             state = QC.MixedDestabilizer(one(QC.Stabilizer, qubits; basis))
             operator = QC.zero(QC.PauliOperator, qubits)
-            new(state, operator, falses(0))
+            new(state, operator, falses(0), Int64[], ancillas)
         end
     end
 end
 function setInitialState!(sim::TableauSimulator, state::QC.MixedDestabilizer)
-    sim.initial_state.tab.phases .= state.tab.phases
-    sim.initial_state.tab.xzs .= state.tab.xzs
-    sim.initial_state.rank = state.rank
+    sim.state.tab.phases .= state.tab.phases
+    sim.state.tab.xzs .= state.tab.xzs
+    sim.state.rank = state.rank
+end
+function aux(backend::TableauSimulator)
+    return backend.state.tab.nqubits + backend.ancillas + 1
+end
+
+function MonitoredQuantumCircuits.reset!(backend::TableauSimulator; mixed=true, basis=:Z)
+    qubits = backend.state.tab.nqubits
+    #? maybe this can be done in place
+    if mixed
+        state = QC.MixedDestabilizer(zero(QC.Stabilizer, qubits))
+    else
+        state = QC.MixedDestabilizer(one(QC.Stabilizer, qubits; basis))
+    end
+    setInitialState!(backend, state)
+    empty!(backend.measurements)
+    empty!(backend.measured_qubits)
+    return backend
+end
+
+function Base.show(io::IO, backend::TableauSimulator)
+    println(io, "TableauSimulator Backend powerd by QuantumClifford.jl")
+    println(io, "Number of qubits: ", backend.state.tab.nqubits)
+    println(io, "Number of ancillas: ", backend.ancillas)
+    if !isempty(backend.measurements)
+        println(io, "Recorded measurements: ", length(backend.measurements))
+    else
+        println(io, "No measurements recorded.")
+    end
 end
 
 """
@@ -49,10 +79,10 @@ function MonitoredQuantumCircuits.execute(simulator::TableauSimulator)
     return simulator.state, simulator.measurements
 end
 
-function MonitoredQuantumCircuits.executeParallel(circuit::MonitoredQuantumCircuits.CompiledCircuit, simulator::TableauSimulator; samples=1)
-    MPI, rank, size = MonitoredQuantumCircuits.get_mpi_ref()
-    Threads.@threads for i in 1:samples÷size
-        MonitoredQuantumCircuits.execute(circuit, simulator)
+# function MonitoredQuantumCircuits.executeParallel(circuit::MonitoredQuantumCircuits.CompiledCircuit, simulator::TableauSimulator; samples=1)
+#     MPI, rank, size = MonitoredQuantumCircuits.get_mpi_ref()
+#     Threads.@threads for i in 1:samples÷size
+#         MonitoredQuantumCircuits.execute(circuit, simulator)
 
-    end
-end
+#     end
+# end

src/Backends/QuantumClifford/operations/Measure_X.jl

@@ -18,6 +18,7 @@ function MonitoredQuantumCircuits.apply!(
         _, res = QC.projectXrand!(backend.state, p)
         res = Bool(res/2)
         push!(backend.measurements, res)
+        push!(backend.measured_qubits, p)
     else
         QC.projectX!(backend.state, p; keep_result)
         res = false

src/Backends/QuantumClifford/operations/Measure_Y.jl

@@ -18,6 +18,7 @@ function MonitoredQuantumCircuits.apply!(
         _, res = QC.projectYrand!(backend.state, p)
         res = Bool(res/2)
         push!(backend.measurements, res)
+        push!(backend.measured_qubits, p)
     else
         QC.projectY!(backend.state, p; keep_result)
         res = false

src/Backends/QuantumClifford/operations/Measure_Z.jl

@@ -18,6 +18,7 @@ function MonitoredQuantumCircuits.apply!(
         _, res = QC.projectZrand!(backend.state, p)
         res = Bool(res/2)
         push!(backend.measurements, res)
+        push!(backend.measured_qubits, p)
     else
         QC.projectZ!(backend.state, p; keep_result)
         res = false

src/Backends/QuantumClifford/operations/Pauli.jl

@@ -22,6 +22,7 @@ function MonitoredQuantumCircuits.apply!(
     P::MonitoredQuantumCircuits.NPauli{N},
     p::Vararg{Int,N};
     keep_result=true,
+    ancilla=aux(backend),  # Default to the number of qubits + ancillas + 1
     kwargs...) where N
 
     options = ((true, false), (true, true), (false, true))
@@ -35,6 +36,7 @@ function MonitoredQuantumCircuits.apply!(
         _, res = QC.projectrand!(backend.state, operator)
         res = Bool(res/2)
         push!(backend.measurements, res)
+        push!(backend.measured_qubits, ancilla)
     else
         QC.project!(backend.state, operator)
         res = false

src/Backends/QuantumClifford/operations/XX.jl

@@ -5,12 +5,14 @@ function MonitoredQuantumCircuits.apply!(
     p1::Integer,
     p2::Integer;
     keep_result=true,
+    ancilla=aux(backend),  # Default to the number of qubits + ancillas + 1
     kwargs...)
 
     if keep_result
         _, res = projectXXrand!(backend.state, p1, p2)
         res = Bool(res/2)
         push!(backend.measurements, res)
+        push!(backend.measured_qubits, ancilla) 
     else
         projectXX!(backend.state, p1,p2; keep_result)
         res = false