much better design (without circuit)

Author: J-C-Q

CondaPkg.toml

@@ -1,7 +1,7 @@
 [deps]
-qiskit-aer = "0.16.1.*"
-qiskit-ibm-runtime = "0.37.0.*"
-qiskit = "1.4.2.*"
+qiskit-aer = ""
+qiskit-ibm-runtime = ""
+qiskit = ""
 
 [pip.deps]
 stim = ""

src/Backends/Qiskit/IBMBackend.jl

@@ -6,23 +6,24 @@ A Qiskit backend that runs on IBM's quantum computers.
 """
 struct IBMBackend <: MQC.QuantumComputer
     python_interface::PythonCall.Py
+    circuit::Circuit
 
-    function IBMBackend(backend::PythonCall.Py)
+    function IBMBackend(backend::PythonCall.Py, nqubits::Integer)
         _checkinit_qiskit()
-        new(backend)
+        new(backend, Circuit(nqubits+1,nqubits+1))
     end
 
-    function IBMBackend(name::String)
+    function IBMBackend(nqubits::Integer)
         _checkinit_qiskit()
         runtime = QiskitRuntimeService()
-        backend = getBackend(runtime, name)
-        new(backend)
+        backend = least_buisy(runtime,nqubits)
+        new(backend, Circuit(nqubits+1,nqubits+1))
     end
-    function IBMBackend(name::String, api_key::String)
+    function IBMBackend(nqubits::Integer, api_key::String)
         _checkinit_qiskit()
         runtime = QiskitRuntimeService(api_key)
-        backend = runtime.get_backend(name)
-        new(backend)
+        backend = least_buisy(runtime,nqubits)
+        new(backend,Circuit(nqubits+1,nqubits+1))
     end
 end
 function Base.getproperty(qc::IBMBackend, prop::Symbol)
@@ -33,10 +34,21 @@ function Base.getproperty(qc::IBMBackend, prop::Symbol)
     end
 end
 
+function get_circuit(backend::IBMBackend)
+    return getfield(backend,:circuit)
+end
+
 function Base.show(io::IO, ::MIME"text/plain", obj::IBMBackend)
     println(io, "Name: $(obj.name)")
-    println(io, "Qubits: $(obj.num_qubits)")
-    println(io, "Max shots: $(obj.max_shots)")
+    println(io, get_circuit(obj).python_interface)
+end
+
+function MQC.execute(backend::IBMBackend; shots=1)
+    qc = get_circuit(backend)
+    transpile!(qc, backend)
+    sampler = Sampler(backend)
+    job = run(sampler, qc)
+    println("Job ID: $(job.job_id())")
 end
 
 function execute(circuit::MQC.Circuit, backend::IBMBackend; verbose::Bool=true)

src/Backends/Qiskit/Qiskit.jl

@@ -95,5 +95,7 @@ include("operations/Weak_XX.jl")
 include("operations/Weak_YY.jl")
 include("operations/Pauli.jl")
 include("operations/I.jl")
-
+include("operations/X.jl")
+include("operations/Y.jl")
+include("operations/Z.jl")
 end

src/Backends/Qiskit/QiskitRuntimeService.jl

@@ -4,16 +4,17 @@ struct QiskitRuntimeService
     function QiskitRuntimeService()
         _checkinit_qiskit()
         try
-            runtimeService = qiskit_ibm_runtime.QiskitRuntimeService(channel="ibm_quantum")
+            runtimeService = qiskit_ibm_runtime.QiskitRuntimeService()
             new(runtimeService)
         catch
             throw(ArgumentError("Could not connect to IBM Quantum. Please provide an API key."))
         end
     end
     function QiskitRuntimeService(api_key::String)
         _checkinit_qiskit()
-        runtimeService = qiskit_ibm_runtime.QiskitRuntimeService(token=api_key, channel="ibm_quantum")
-        runtimeService.save_account(token=api_key, channel="ibm_quantum", overwrite=true)
+        qiskit_ibm_runtime.QiskitRuntimeService.save_account(token=api_key, set_as_default=true)
+        runtimeService = qiskit_ibm_runtime.QiskitRuntimeService()
+
         new(runtimeService)
     end
 end
@@ -33,6 +34,11 @@ function getBackend(qc::QiskitRuntimeService, name::String)
     backend = qc.get_backend(name)
     return IBMBackend(backend)
 end
+function least_buisy(qc::QiskitRuntimeService,nqubits::Integer)
+    qc.least_busy(
+    operational=true, simulator=false, min_num_qubits=nqubits
+)
+end
 
 function Base.show(io::IO, ::MIME"text/plain", obj::QiskitRuntimeService)
     account_info = activeAccount(obj)

src/Backends/Qiskit/QuantumCircuit.jl

@@ -22,7 +22,7 @@ Base.show(io::IO, ::MIME"text/plain", obj::Circuit) = print(io, obj.python_inter
 
 
 function nQubits(circuit::Circuit)
-    return circuit.n_qubits
+    return circuit.num_qubits
 end
 
 function depth(operation::MQC.Operation, ::Type{Circuit})

src/Backends/Qiskit/Sampler.jl

@@ -2,11 +2,11 @@ struct Sampler
     python_interface::PythonCall.Py
     function Sampler(backend::String)
         _checkinit_qiskit()
-        new(qiskit_ibm_runtime.SamplerV2(backend=backend))
+        new(qiskit_ibm_runtime.SamplerV2(backend))
     end
     function Sampler(backend::IBMBackend)
         _checkinit_qiskit()
-        new(qiskit_ibm_runtime.SamplerV2(backend=backend.python_interface))
+        new(qiskit_ibm_runtime.SamplerV2(backend.python_interface))
     end
     function Sampler(backend::AerSimulator)
         _checkinit_qiskit()

src/Backends/Qiskit/Simulation.jl

@@ -1,69 +1,72 @@
 
 struct AerSimulator <: MQC.Simulator
     python_interface::PythonCall.Py
+    circuit::Circuit
 end
 """
     GPUStateVectorSimulator()
 
 A Qiskit Aer statevector simulator that runs on the GPU.
 """
-function GPUStateVectorSimulator()
+function GPUStateVectorSimulator(nqubits::Integer)
     _checkinit_qiskit_aer(; gpu=true)
     AerSimulator(qiskit_aer.AerSimulator(
         method="statevector",
         device="GPU",
         cuStateVec_enable=true,
         enable_truncation=false,
-        target=[0]
-    ))
+        target=[0]),
+        Circuit(nqubits+1,nqubits+1))
 end
 
 """
     StateVectorSimulator()
 
 A Qiskit Aer statevector simulator.
 """
-function StateVectorSimulator()
+function StateVectorSimulator(nqubits::Integer)
     _checkinit_qiskit_aer()
-    AerSimulator(qiskit_aer.AerSimulator(
+    AerSimulator(
+        qiskit_aer.AerSimulator(
         method="statevector",
-        enable_truncation=false
-    ))
+        enable_truncation=false),
+        Circuit(nqubits+1,nqubits+1))
 end
 
 """
     CliffordSimulator()
 
 A Qiskit Aer stabilizer simulator.
 """
-function CliffordSimulator()
+function CliffordSimulator(nqubits::Integer)
     _checkinit_qiskit_aer()
-    AerSimulator(qiskit_aer.AerSimulator(method="stabilizer"))
+    AerSimulator(
+        qiskit_aer.AerSimulator(method="stabilizer"),
+        Circuit(nqubits+1,nqubits+1))
 end
 
 """
     GPUTensorNetworkSimulator()
 
 A Qiskit Aer tensor network simulator that runs on the GPU.
 """
-function GPUTensorNetworkSimulator()
+function GPUTensorNetworkSimulator(nqubits::Integer)
     _checkinit_qiskit_aer(; gpu=true)
     AerSimulator(qiskit_aer.AerSimulator(
         method="tensor_network",
         device="GPU",
         cuStateVec_enable=true,
         use_cuTensorNet_autotuning=true,
         enable_truncation=false,
-        target=[0]
-    ))
+        target=[0]),
+        Circuit(nqubits+1,nqubits+1))
 end
 function isSimulator(::AerSimulator)
     return true
 end
 
 function Base.show(io::IO, ::MIME"text/plain", obj::AerSimulator)
-    println(io, "Name: $(obj.name)")
-    println(io, "Qubits: $(obj.num_qubits)")
+    println(io, get_circuit(obj).python_interface)
 end
 
 function Base.getproperty(qc::AerSimulator, prop::Symbol)
@@ -74,6 +77,24 @@ function Base.getproperty(qc::AerSimulator, prop::Symbol)
     end
 end
 
+function get_circuit(qc::AerSimulator)
+    return getfield(qc, :circuit)
+end
+
+function aux(backend::Union{AerSimulator,IBMBackend})
+    # Ancilla qubit is the last qubit in the circuit
+    return nQubits(get_circuit(backend))
+end
+
+function MQC.execute(backend::AerSimulator; shots=1)
+    qc = get_circuit(backend)
+    transpile!(qc, backend)
+    sampler = Sampler(backend)
+    job = run(sampler, qc; shots)
+    nativeResult = job.result()[0]
+    return nativeResult
+end
+
 function MQC.execute(circuit::MQC.CompiledCircuit, backend::AerSimulator; shots=1024)
     verbose = false
     verbose && print("Transpiling circuit to Qiskit...")

src/Backends/Qiskit/Transpiler.jl

@@ -8,3 +8,11 @@ function transpile!(circuit::Circuit, backend::AerSimulator; optimization::Integ
     0 <= optimization <= 3 || throw(ArgumentError("Degree must be between 0 and 3"))
     circuit.python_interface = qiskit.compiler.transpile(circuit.python_interface, backend.python_interface, optimization_level=optimization)
 end
+
+
+function transpile!(backend::Union{AerSimulator,IBMBackend}; optimization::Integer=3)
+    0 <= optimization <= 3 || throw(ArgumentError("Degree must be between 0 and 3"))
+    qc = circuit(backend)
+    qc.python_interface = qiskit.compiler.transpile(qc.python_interface, backend.python_interface, optimization_level=optimization)
+    return qc
+end

src/Backends/Qiskit/operations/CNOT.jl

@@ -1,5 +1,15 @@
-function apply!(qc::Circuit, ::MQC.CNOT, p::SubArray, ::Integer)
-    p1 = p[1]
-    p2 = p[2]
+# function apply!(qc::Circuit, ::MQC.CNOT, p::SubArray, ::Integer)
+#     p1 = p[1]
+#     p2 = p[2]
+#     qc.cx(p1 - 1, p2 - 1)
+# end
+
+function MQC.apply!(
+    backend::Union{AerSimulator,IBMBackend},
+    ::MQC.CNOT,
+    p1::Integer,
+    p2::Integer)
+    qc = get_circuit(backend)
     qc.cx(p1 - 1, p2 - 1)
+    return qc
 end

src/Backends/Qiskit/operations/H.jl

@@ -1,4 +1,13 @@
-function apply!(qc::Circuit, ::MQC.H, p::SubArray, ::Integer)
-    p1 = p[1]
-    qc.h(p1 - 1)
+# function apply!(qc::Circuit, ::MQC.H, p::SubArray, ::Integer)
+#     p1 = p[1]
+#     qc.h(p1 - 1)
+# end
+
+function MQC.apply!(
+    backend::Union{AerSimulator,IBMBackend},
+    ::MQC.H,
+    p::Integer)
+    qc = get_circuit(backend)
+    qc.h(p - 1)
+    return qc
 end