same time operatons in qiskit

Author: J-C-Q

src/Qiskit/Result.jl

@@ -0,0 +1,8 @@
+abstract type Result end
+
+struct QiskitResult <: Result
+    python_interface::Py
+    function QiskitResult(python_interface::Py)
+        new(python_interface)
+    end
+end

src/circuit.jl

@@ -147,16 +147,26 @@ function isClifford(circuit::Circuit)
     return all([isClifford(operation) for operation in circuit.operations])
 end
 
-
+#TODO apply indentitiy operation to all other qubits/maybe with transpile pass.
 function qiskitRepresentation(circuit::Circuit)
     qc = Qiskit.QuantumCircuit(length(circuit.lattice))
+    # iterate execution steps
     for i in unique(circuit.executionOrder)
+        # get all operations in the step
         operationsInStep = _getOperations(circuit, i)
-        for j in operationsInStep
-            ptr = circuit.operationPointers[j]
-            applyToQiskit!(qc, circuit.operations[ptr], circuit.operationPositions[j]...)
+        # get depth of the deepest operation in the step
+        maximumDepth = maximum([depth(circuit.operations[circuit.operationPointers[j]]) for j in operationsInStep])
+        # iterate depth of the operations
+        for k in 1:maximumDepth
+            # iterate operations in the step
+            for j in operationsInStep
+                ptr = circuit.operationPointers[j]
+                # only apply the k-th instruction of the operation, if deep enough
+                if k <= depth(circuit.operations[ptr])
+                    applyToQiskit!(qc, circuit.operations[ptr], Val(k), circuit.operationPositions[j]...)
+                end
+            end
         end
-        qc.barrier()
     end
     return qc
 end
@@ -188,7 +198,7 @@ function runIBMQ(circuit::Circuit, backend::String; verbose::Bool=true)
 
     verbose && println("Job ID: $(job.job_id())")
 end
-
+# job.result()[0].data.c.get_counts().items()
 function runQiskitSimulate(circuit::Circuit; verbose::Bool=true)
     verbose && print("Transpiling circuit to Qiskit...")
     qc = qiskitRepresentation(circuit)

src/operations/XX.jl

@@ -11,14 +11,40 @@ end
 function isClifford(::XX)
     return true
 end
-function applyToQiskit!(qc::Qiskit.QuantumCircuit, ::XX, position::Vararg{Integer})
-    qc.reset(position[2] - 1)
-    qc.h(position[2] - 1)
-    qc.cx(position[2] - 1, position[1] - 1)
-    qc.cx(position[2] - 1, position[3] - 1)
-    qc.measure(position[2] - 1, position[2] - 1)
+function depth(::XX)
+    return 6
 end
 function connectionGraph(::XX)
     # return the connection graph of the operation
     return path_graph(3)
 end
+function applyToQiskit!(qc::Qiskit.QuantumCircuit, ::XX, p1::Integer, p2::Integer, p3::Integer)
+    qc.reset(p2 - 1)
+    qc.h(p2 - 1)
+    qc.cx(p2 - 1, p1 - 1)
+    qc.cx(p2 - 1, p3 - 1)
+    qc.h(p2 - 1)
+    qc.measure(p2 - 1, p2 - 1)
+end
+
+function applyToQiskit!(qc::Qiskit.QuantumCircuit, ::XX, step::Integer, p1::Integer, p2::Integer, p3::Integer)
+    applyToQiskit!(qc, XX(), Val(step), p1, p2, p3)
+end
+function applyToQiskit!(qc::Qiskit.QuantumCircuit, ::XX, ::Val{1}, ::Integer, p2::Integer, ::Integer)
+    qc.reset(p2 - 1)
+end
+function applyToQiskit!(qc::Qiskit.QuantumCircuit, ::XX, ::Val{2}, ::Integer, p2::Integer, ::Integer)
+    qc.h(p2 - 1)
+end
+function applyToQiskit!(qc::Qiskit.QuantumCircuit, ::XX, ::Val{3}, p1::Integer, p2::Integer, ::Integer)
+    qc.cx(p2 - 1, p1 - 1)
+end
+function applyToQiskit!(qc::Qiskit.QuantumCircuit, ::XX, ::Val{4}, ::Integer, p2::Integer, p3::Integer)
+    qc.cx(p2 - 1, p3 - 1)
+end
+function applyToQiskit!(qc::Qiskit.QuantumCircuit, ::XX, ::Val{5}, ::Integer, p2::Integer, ::Integer)
+    qc.h(p2 - 1)
+end
+function applyToQiskit!(qc::Qiskit.QuantumCircuit, ::XX, ::Val{6}, ::Integer, p2::Integer, ::Integer)
+    qc.measure(p2 - 1, p2 - 1)
+end

src/operations/YY.jl

@@ -11,14 +11,40 @@ end
 function isClifford(::YY)
     return true
 end
-function applyToQiskit!(qc::Qiskit.QuantumCircuit, ::YY, position::Vararg{Integer})
-    qc.reset(position[2] - 1)
-    qc.sdg(position[2] - 1)
-    qc.cx(position[2] - 1, position[1] - 1)
-    qc.cx(position[2] - 1, position[3] - 1)
-    qc.measure(position[2] - 1, position[2] - 1)
+function depth(::YY)
+    return 6
 end
 function connectionGraph(::YY)
     # return the connection graph of the operation
     return path_graph(3)
 end
+function applyToQiskit!(qc::Qiskit.QuantumCircuit, ::YY, p1::Integer, p2::Integer, p3::Integer)
+    qc.reset(p2 - 1)
+    qc.sdg(p2 - 1)
+    qc.cx(p2 - 1, p1 - 1)
+    qc.cx(p2 - 1, p3 - 1)
+    qc.h(p2 - 1)
+    qc.measure(p2 - 1, p2 - 1)
+end
+
+function applyToQiskit!(qc::Qiskit.QuantumCircuit, ::YY, step::Integer, p1::Integer, p2::Integer, p3::Integer)
+    applyToQiskit!(qc, YY(), Val(step), p1, p2, p3)
+end
+function applyToQiskit!(qc::Qiskit.QuantumCircuit, ::YY, ::Val{1}, ::Integer, p2::Integer, ::Integer)
+    qc.reset(p2 - 1)
+end
+function applyToQiskit!(qc::Qiskit.QuantumCircuit, ::YY, ::Val{2}, ::Integer, p2::Integer, ::Integer)
+    qc.sdg(p2 - 1)
+end
+function applyToQiskit!(qc::Qiskit.QuantumCircuit, ::YY, ::Val{3}, p1::Integer, p2::Integer, ::Integer)
+    qc.cx(p2 - 1, p1 - 1)
+end
+function applyToQiskit!(qc::Qiskit.QuantumCircuit, ::YY, ::Val{4}, ::Integer, p2::Integer, p3::Integer)
+    qc.cx(p2 - 1, p3 - 1)
+end
+function applyToQiskit!(qc::Qiskit.QuantumCircuit, ::YY, ::Val{5}, ::Integer, p2::Integer, ::Integer)
+    qc.h(p2 - 1)
+end
+function applyToQiskit!(qc::Qiskit.QuantumCircuit, ::YY, ::Val{6}, ::Integer, p2::Integer, ::Integer)
+    qc.measure(p2 - 1, p2 - 1)
+end

src/operations/ZZ.jl

@@ -11,13 +11,31 @@ end
 function isClifford(::ZZ)
     return true
 end
-function applyToQiskit!(qc::Qiskit.QuantumCircuit, ::ZZ, position::Vararg{Integer})
-    qc.reset(position[2] - 1)
-    qc.cx(position[1] - 1, position[2] - 1)
-    qc.cx(position[3] - 1, position[2] - 1)
-    qc.measure(position[2] - 1, position[2] - 1)
+function depth(::ZZ)
+    return 4
 end
 function connectionGraph(::ZZ)
     # return the connection graph of the operation
     return path_graph(3)
 end
+function applyToQiskit!(qc::Qiskit.QuantumCircuit, ::ZZ, p1::Integer, p2::Integer, p3::Integer)
+    qc.reset(p2 - 1)
+    qc.cx(p1 - 1, p2 - 1)
+    qc.cx(p3 - 1, p2 - 1)
+    qc.measure(p2 - 1, p2 - 1)
+end
+function applyToQiskit!(qc::Qiskit.QuantumCircuit, ::ZZ, step::Integer, p1::Integer, p2::Integer, p3::Integer)
+    applyToQiskit!(qc, ZZ(), Val(step), p1, p2, p3)
+end
+function applyToQiskit!(qc::Qiskit.QuantumCircuit, ::ZZ, ::Val{1}, ::Integer, p2::Integer, ::Integer)
+    qc.reset(p2 - 1)
+end
+function applyToQiskit!(qc::Qiskit.QuantumCircuit, ::ZZ, ::Val{2}, p1::Integer, p2::Integer, ::Integer)
+    qc.cx(p1 - 1, p2 - 1)
+end
+function applyToQiskit!(qc::Qiskit.QuantumCircuit, ::ZZ, ::Val{3}, ::Integer, p2::Integer, p3::Integer)
+    qc.cx(p3 - 1, p2 - 1)
+end
+function applyToQiskit!(qc::Qiskit.QuantumCircuit, ::ZZ, ::Val{4}, ::Integer, p2::Integer, ::Integer)
+    qc.measure(p2 - 1, p2 - 1)
+end