pyqrack 1.29.0__py3-none-win_amd64.whl → 1.72.5__py3-none-win_amd64.whl

pyqrack/qrack_simulator.py

@@ -1,4 +1,4 @@
-# (C) Daniel Strano and the Qrack contributors 2017-2023. All rights reserved.
+# (C) Daniel Strano and the Qrack contributors 2017-2025. All rights reserved.
 #
 # Use of this source code is governed by an MIT-style license that can be
 # found in the LICENSE file or at https://opensource.org/licenses/MIT.
@@ -6,21 +6,24 @@
 import copy
 import ctypes
 import math
+import os
 import re
 from .qrack_system import Qrack
 from .pauli import Pauli
 
 _IS_QISKIT_AVAILABLE = True
 try:
-    from qiskit.circuit import QuantumRegister, Qubit
     from qiskit.circuit.quantumcircuit import QuantumCircuit
     from qiskit.compiler import transpile
-    from qiskit.qobj.qasm_qobj import QasmQobjExperiment
     from qiskit.quantum_info.operators.symplectic.clifford import Clifford
-    from .util import convert_qiskit_circuit_to_qasm_experiment
 except ImportError:
     _IS_QISKIT_AVAILABLE = False
 
+try:
+    from qiskit import qasm3
+except ImportError:
+    pass
+
 _IS_NUMPY_AVAILABLE = True
 try:
     import numpy as np
@@ -29,10 +32,9 @@ except:
 
 
 class QrackSimulator:
-    """Interface for all the QRack functionality.
+    """Interface for all the Qrack functionality.
 
     Attributes:
-        qubitCount(int): Number of qubits that are to be simulated.
         sid(int): Corresponding simulator id.
     """
 
@@ -48,14 +50,18 @@ class QrackSimulator:
         qubitCount=-1,
         cloneSid=-1,
         isTensorNetwork=True,
-        isSchmidtDecomposeMulti=True,
+        isSchmidtDecomposeMulti=False,
         isSchmidtDecompose=True,
-        isStabilizerHybrid=True,
+        isStabilizerHybrid=False,
         isBinaryDecisionTree=False,
         isPaged=True,
         isCpuGpuHybrid=True,
         isOpenCL=True,
-        isHostPointer=False,
+        isHostPointer=(
+            True if os.environ.get("PYQRACK_HOST_POINTER_DEFAULT_ON") else False
+        ),
+        isSparse=False,
+        noise=0,
         pyzxCircuit=None,
         qiskitCircuit=None,
     ):
@@ -74,6 +80,7 @@ class QrackSimulator:
             )
 
         self.is_tensor_network = isTensorNetwork
+        self.is_pure_stabilizer = False
 
         if cloneSid > -1:
             self.sid = Qrack.qrack_lib.init_clone(cloneSid)
@@ -89,14 +96,18 @@ class QrackSimulator:
                 isStabilizerHybrid,
                 isBinaryDecisionTree,
                 isPaged,
-                False,
+                (noise > 0),
                 isCpuGpuHybrid,
                 isOpenCL,
                 isHostPointer,
+                isSparse
             )
 
         self._throw_if_error()
 
+        if noise > 0:
+            self.set_noise_parameter(noise)
+
         if pyzxCircuit is not None:
             self.run_pyzx_gates(pyzxCircuit.gates)
         elif qiskitCircuit is not None:
@@ -113,6 +124,9 @@ class QrackSimulator:
     def _ulonglong_byref(self, a):
         return (ctypes.c_ulonglong * len(a))(*a)
 
+    def _longlong_byref(self, a):
+        return (ctypes.c_longlong * len(a))(*a)
+
     def _double_byref(self, a):
         return (ctypes.c_double * len(a))(*a)
 
@@ -172,9 +186,23 @@ class QrackSimulator:
         self._throw_if_error()
 
     def set_concurrency(self, p):
+        """Set the CPU parallel thread count"""
         Qrack.qrack_lib.set_concurrency(self.sid, p)
         self._throw_if_error()
 
+    def set_device(self, d):
+        """Set the GPU device ID"""
+        Qrack.qrack_lib.set_device(self.sid, d)
+        self._throw_if_error()
+
+    def set_device_list(self, d):
+        """Set the GPU device ID"""
+        Qrack.qrack_lib.set_device_list(self.sid, len(d), self._longlong_byref(d))
+        self._throw_if_error()
+
+    def clone(self):
+        return QrackSimulator(cloneSid=self.sid)
+
     # standard gates
 
     ## single-qubits gates
@@ -330,7 +358,9 @@ class QrackSimulator:
             RuntimeError: QrackSimulator raised an exception.
         """
         if len(m) < 4:
-            raise ValueError("2x2 matrix 'm' in QrackSimulator.mtrx() must contain at least 4 elements.")
+            raise ValueError(
+                "2x2 matrix 'm' in QrackSimulator.mtrx() must contain at least 4 elements."
+            )
         Qrack.qrack_lib.Mtrx(self.sid, self._complex_byref(m), q)
         self._throw_if_error()
 
@@ -548,7 +578,9 @@ class QrackSimulator:
             RuntimeError: QrackSimulator raised an exception.
         """
         if len(m) < 4:
-            raise ValueError("2x2 matrix 'm' in QrackSimulator.mcmtrx() must contain at least 4 elements.")
+            raise ValueError(
+                "2x2 matrix 'm' in QrackSimulator.mcmtrx() must contain at least 4 elements."
+            )
         Qrack.qrack_lib.MCMtrx(
             self.sid, len(c), self._ulonglong_byref(c), self._complex_byref(m), q
         )
@@ -724,7 +756,9 @@ class QrackSimulator:
             RuntimeError: QrackSimulator raised an exception.
         """
         if len(m) < 4:
-            raise ValueError("2x2 matrix 'm' in QrackSimulator.macmtrx() must contain at least 4 elements.")
+            raise ValueError(
+                "2x2 matrix 'm' in QrackSimulator.macmtrx() must contain at least 4 elements."
+            )
         Qrack.qrack_lib.MACMtrx(
             self.sid, len(c), self._ulonglong_byref(c), self._complex_byref(m), q
         )
@@ -747,7 +781,9 @@ class QrackSimulator:
             RuntimeError: QrackSimulator raised an exception.
         """
         if len(m) < 4:
-            raise ValueError("2x2 matrix 'm' in QrackSimulator.ucmtrx() must contain at least 4 elements.")
+            raise ValueError(
+                "2x2 matrix 'm' in QrackSimulator.ucmtrx() must contain at least 4 elements."
+            )
         Qrack.qrack_lib.UCMtrx(
             self.sid, len(c), self._ulonglong_byref(c), self._complex_byref(m), q, p
         )
@@ -769,7 +805,9 @@ class QrackSimulator:
             RuntimeError: QrackSimulator raised an exception.
         """
         if len(m) < ((1 << len(c)) * 4):
-            raise ValueError("Multiplex matrix 'm' in QrackSimulator.multiplex1_mtrx() must contain at least (4 * 2 ** len(c)) elements.")
+            raise ValueError(
+                "Multiplex matrix 'm' in QrackSimulator.multiplex1_mtrx() must contain at least (4 * 2 ** len(c)) elements."
+            )
         Qrack.qrack_lib.Multiplex1Mtrx(
             self.sid, len(c), self._ulonglong_byref(c), q, self._complex_byref(m)
         )
@@ -1017,9 +1055,16 @@ class QrackSimulator:
         Returns:
             Measurement result of all qubits.
         """
-        result = Qrack.qrack_lib.MAll(self.sid)
+        num_q = self.num_qubits()
+        num_words = (num_q + 63) // 64
+        _r = (ctypes.c_ulonglong * num_words)()
+        Qrack.qrack_lib.MAllLong(self.sid, _r)
         self._throw_if_error()
-        return result
+        r = 0
+        for w in range(num_words):
+            r <<= 64
+            r |= _r[w]
+        return r
 
     def measure_pauli(self, b, q):
         """Pauli Measurement gate
@@ -1239,7 +1284,13 @@ class QrackSimulator:
             RuntimeError: QrackSimulator with isTensorNetwork=True option cannot mul()! (Turn off just this option, in the constructor.)
         """
         if self.is_tensor_network:
-            raise RuntimeError("QrackSimulator with isTensorNetwork=True option cannot mul()! (Turn off just this option, in the constructor.)")
+            raise RuntimeError(
+                "QrackSimulator with isTensorNetwork=True option cannot mul()! (Turn off just this option, in the constructor.)"
+            )
+        if self.is_pure_stabilizer:
+            raise RuntimeError(
+                "QrackStabilizer cannot mul()! (Create a QrackSimulator instead, also with isTensorNetwork=False.)"
+            )
 
         if len(q) != len(o):
             raise RuntimeError("Lengths of list parameters are mismatched.")
@@ -1272,7 +1323,13 @@ class QrackSimulator:
             RuntimeError: QrackSimulator with isTensorNetwork=True option cannot div()! (Turn off just this option, in the constructor.)
         """
         if self.is_tensor_network:
-            raise RuntimeError("QrackSimulator with isTensorNetwork=True option cannot div()! (Turn off just this option, in the constructor.)")
+            raise RuntimeError(
+                "QrackSimulator with isTensorNetwork=True option cannot div()! (Turn off just this option, in the constructor.)"
+            )
+        if self.is_pure_stabilizer:
+            raise RuntimeError(
+                "QrackStabilizer cannot div()! (Create a QrackSimulator instead, also with isTensorNetwork=False.)"
+            )
 
         if len(q) != len(o):
             raise RuntimeError("Lengths of list parameters are mismatched.")
@@ -1363,7 +1420,13 @@ class QrackSimulator:
             RuntimeError: QrackSimulator with isTensorNetwork=True option cannot pown()! (Turn off just this option, in the constructor.)
         """
         if self.is_tensor_network:
-            raise RuntimeError("QrackSimulator with isTensorNetwork=True option cannot pown()! (Turn off just this option, in the constructor.)")
+            raise RuntimeError(
+                "QrackSimulator with isTensorNetwork=True option cannot pown()! (Turn off just this option, in the constructor.)"
+            )
+        if self.is_pure_stabilizer:
+            raise RuntimeError(
+                "QrackStabilizer cannot pown()! (Create a QrackSimulator instead, also with isTensorNetwork=False.)"
+            )
 
         if len(q) != len(o):
             raise RuntimeError("Lengths of list parameters are mismatched.")
@@ -1450,7 +1513,13 @@ class QrackSimulator:
             RuntimeError: QrackSimulator with isTensorNetwork=True option cannot mcmul()! (Turn off just this option, in the constructor.)
         """
         if self.is_tensor_network:
-            raise RuntimeError("QrackSimulator with isTensorNetwork=True option cannot mcmul()! (Turn off just this option, in the constructor.)")
+            raise RuntimeError(
+                "QrackSimulator with isTensorNetwork=True option cannot mcmul()! (Turn off just this option, in the constructor.)"
+            )
+        if self.is_pure_stabilizer:
+            raise RuntimeError(
+                "QrackStabilizer cannot mcmul()! (Create a QrackSimulator instead, also with isTensorNetwork=False.)"
+            )
 
         if len(q) != len(o):
             raise RuntimeError("Lengths of list parameters are mismatched.")
@@ -1486,7 +1555,13 @@ class QrackSimulator:
             RuntimeError: QrackSimulator with isTensorNetwork=True option cannot mcdiv()! (Turn off just this option, in the constructor.)
         """
         if self.is_tensor_network:
-            raise RuntimeError("QrackSimulator with isTensorNetwork=True option cannot mcdiv()! (Turn off just this option, in the constructor.)")
+            raise RuntimeError(
+                "QrackSimulator with isTensorNetwork=True option cannot mcdiv()! (Turn off just this option, in the constructor.)"
+            )
+        if self.is_pure_stabilizer:
+            raise RuntimeError(
+                "QrackStabilizer cannot mcdiv()! (Create a QrackSimulator instead, also with isTensorNetwork=False.)"
+            )
 
         if len(q) != len(o):
             raise RuntimeError("Lengths of list parameters are mismatched.")
@@ -1588,7 +1663,13 @@ class QrackSimulator:
             RuntimeError: QrackSimulator with isTensorNetwork=True option cannot mcpown()! (Turn off just this option, in the constructor.)
         """
         if self.is_tensor_network:
-            raise RuntimeError("QrackSimulator with isTensorNetwork=True option cannot mcpown()! (Turn off just this option, in the constructor.)")
+            raise RuntimeError(
+                "QrackSimulator with isTensorNetwork=True option cannot mcpown()! (Turn off just this option, in the constructor.)"
+            )
+        if self.is_pure_stabilizer:
+            raise RuntimeError(
+                "QrackStabilizer cannot mcpown()! (Create a QrackSimulator instead, also with isTensorNetwork=False.)"
+            )
 
         if len(q) != len(o):
             raise RuntimeError("Lengths of list parameters are mismatched.")
@@ -1623,7 +1704,13 @@ class QrackSimulator:
             RuntimeError: QrackSimulator with isTensorNetwork=True option cannot lda()! (Turn off just this option, in the constructor.)
         """
         if self.is_tensor_network:
-            raise RuntimeError("QrackSimulator with isTensorNetwork=True option cannot lda()! (Turn off just this option, in the constructor.)")
+            raise RuntimeError(
+                "QrackSimulator with isTensorNetwork=True option cannot lda()! (Turn off just this option, in the constructor.)"
+            )
+        if self.is_pure_stabilizer:
+            raise RuntimeError(
+                "QrackStabilizer cannot lda()! (Create a QrackSimulator instead, also with isTensorNetwork=False.)"
+            )
 
         Qrack.qrack_lib.LDA(
             self.sid,
@@ -1651,7 +1738,13 @@ class QrackSimulator:
             RuntimeError: QrackSimulator with isTensorNetwork=True option cannot adc()! (Turn off just this option, in the constructor.)
         """
         if self.is_tensor_network:
-            raise RuntimeError("QrackSimulator with isTensorNetwork=True option cannot adc()! (Turn off just this option, in the constructor.)")
+            raise RuntimeError(
+                "QrackSimulator with isTensorNetwork=True option cannot adc()! (Turn off just this option, in the constructor.)"
+            )
+        if self.is_pure_stabilizer:
+            raise RuntimeError(
+                "QrackStabilizer cannot adc()! (Create a QrackSimulator instead, also with isTensorNetwork=False.)"
+            )
 
         Qrack.qrack_lib.ADC(
             self.sid,
@@ -1680,7 +1773,13 @@ class QrackSimulator:
             RuntimeError: QrackSimulator with isTensorNetwork=True option cannot sbc()! (Turn off just this option, in the constructor.)
         """
         if self.is_tensor_network:
-            raise RuntimeError("QrackSimulator with isTensorNetwork=True option cannot sbc()! (Turn off just this option, in the constructor.)")
+            raise RuntimeError(
+                "QrackSimulator with isTensorNetwork=True option cannot sbc()! (Turn off just this option, in the constructor.)"
+            )
+        if self.is_pure_stabilizer:
+            raise RuntimeError(
+                "QrackStabilizer cannot sbc()! (Create a QrackSimulator instead, also with isTensorNetwork=False.)"
+            )
 
         Qrack.qrack_lib.SBC(
             self.sid,
@@ -1710,7 +1809,13 @@ class QrackSimulator:
             RuntimeError: QrackSimulator with isTensorNetwork=True option cannot hash()! (Turn off just this option, in the constructor.)
         """
         if self.is_tensor_network:
-            raise RuntimeError("QrackSimulator with isTensorNetwork=True option cannot hash()! (Turn off just this option, in the constructor.)")
+            raise RuntimeError(
+                "QrackSimulator with isTensorNetwork=True option cannot hash()! (Turn off just this option, in the constructor.)"
+            )
+        if self.is_pure_stabilizer:
+            raise RuntimeError(
+                "QrackStabilizer cannot hash()! (Create a QrackSimulator instead, also with isTensorNetwork=False.)"
+            )
 
         Qrack.qrack_lib.Hash(
             self.sid, len(q), self._ulonglong_byref(q), self._to_ubyte(len(q), t)
@@ -2019,7 +2124,9 @@ class QrackSimulator:
             RuntimeError: QrackSimulator with isTensorNetwork=True option cannot compose()! (Turn off just this option, in the constructor.)
         """
         if self.is_tensor_network:
-            raise RuntimeError("QrackSimulator with isTensorNetwork=True option cannot compose()! (Turn off just this option, in the constructor.)")
+            raise RuntimeError(
+                "QrackSimulator with isTensorNetwork=True option cannot compose()! (Turn off just this option, in the constructor.)"
+            )
 
         Qrack.qrack_lib.Compose(self.sid, other.sid, self._ulonglong_byref(q))
         self._throw_if_error()
@@ -2027,9 +2134,7 @@ class QrackSimulator:
     def decompose(self, q):
         """Decompose system
 
-        Decompose the given qubit out of the system.
-        Warning: The qubit subsystem state must be separable, or the behavior 
-        of this method is undefined.
+        Factorize a set of contiguous bits with minimal fidelity loss.
 
         Args:
             q: qubit id
@@ -2039,10 +2144,12 @@ class QrackSimulator:
             RuntimeError: QrackSimulator with isTensorNetwork=True option cannot decompose()! (Turn off just this option, in the constructor.)
 
         Returns:
-            State of the systems.
+            Decomposed subsystem simulator.
         """
         if self.is_tensor_network:
-            raise RuntimeError("QrackSimulator with isTensorNetwork=True option cannot decompose()! (Turn off just this option, in the constructor.)")
+            raise RuntimeError(
+                "QrackSimulator with isTensorNetwork=True option cannot decompose()! (Turn off just this option, in the constructor.)"
+            )
 
         other = QrackSimulator()
         Qrack.qrack_lib.destroy(other.sid)
@@ -2054,10 +2161,8 @@ class QrackSimulator:
     def dispose(self, q):
         """Dispose qubits
 
-        Minimally decompose a set of contiguous bits from the separably
-        composed unit, and discard the separable bits.
-        Warning: The qubit subsystem state must be separable, or the behavior 
-        of this method is undefined.
+        Factorize a set of contiguous bits with minimal fidelity loss,
+        and discard the separable bits.
 
         Args:
             q: qubit
@@ -2065,12 +2170,11 @@ class QrackSimulator:
         Raises:
             RuntimeError: QrackSimulator raised an exception.
             RuntimeError: QrackSimulator with isTensorNetwork=True option cannot dispose()! (Turn off just this option, in the constructor.)
-
-        Returns:
-            State of the systems.
         """
         if self.is_tensor_network:
-            raise RuntimeError("QrackSimulator with isTensorNetwork=True option cannot dispose()! (Turn off just this option, in the constructor.)")
+            raise RuntimeError(
+                "QrackSimulator with isTensorNetwork=True option cannot dispose()! (Turn off just this option, in the constructor.)"
+            )
 
         l = len(q)
         Qrack.qrack_lib.Dispose(self.sid, l, self._ulonglong_byref(q))
@@ -2133,8 +2237,8 @@ class QrackSimulator:
     def in_ket(self, ket):
         """Set state vector
 
-        Set state vector for the selected simulator ID. 
-        Warning: State vector is not always the internal representation leading 
+        Set state vector for the selected simulator ID.
+        Warning: State vector is not always the internal representation leading
         to sub-optimal performance of the method.
 
         Args:
@@ -2147,10 +2251,10 @@ class QrackSimulator:
         self._throw_if_error()
 
     def out_ket(self):
-        """Set state vector
+        """Get state vector
 
         Returns the raw state vector of the simulator.
-        Warning: State vector is not always the internal representation leading 
+        Warning: State vector is not always the internal representation leading
         to sub-optimal performance of the method.
 
         Raises:
@@ -2165,6 +2269,90 @@ class QrackSimulator:
         self._throw_if_error()
         return [complex(r, i) for r, i in self._pairwise(ket)]
 
+    def out_probs(self):
+        """Get basis dimension probabilities
+
+        Returns the probabilities of each basis dimension in the state vector
+        of the simulator.
+
+        Raises:
+            RuntimeError: QrackSimulator raised an exception.
+
+        Returns:
+            list representing the basis dimension probabilities.
+        """
+        prob_count = 1 << self.num_qubits()
+        probs = self._real1_byref([0.0] * prob_count)
+        Qrack.qrack_lib.OutProbs(self.sid, probs)
+        self._throw_if_error()
+        return list(probs)
+
+    def out_rdm(self, q):
+        """Get reduced density matrix
+
+        Returns the raw reduced density matrix of the simulator, for the qubit list.
+        Warning: State vector or is not always the internal representation leading
+        to sub-optimal performance of the method.
+
+        Raises:
+            RuntimeError: QrackSimulator raised an exception.
+
+        Returns:
+            flat list structure representing the reduced density matrix.
+        """
+        amp_count = 1 << len(q)
+        sqr_amp_count = amp_count * amp_count
+        flat_rdm = self._qrack_complex_byref([complex(0, 0)] * sqr_amp_count)
+        Qrack.qrack_lib.OutReducedDensityMatrix(self.sid, len(q), self._ulonglong_byref(q), flat_rdm)
+        self._throw_if_error()
+        return [complex(r, i) for r, i in self._pairwise(flat_rdm)]
+
+    def highest_prob_perm(self):
+        """Get the permutation (bit string) with the highest probability
+
+        Returns the single highest-probability bit string in the Hilbert space
+
+        Raises:
+            RuntimeError: QrackSimulator raised an exception.
+
+        Returns:
+            Highest probability dimension index
+        """
+        num_q = self.num_qubits()
+        num_words = (num_q + 63) // 64
+        _r = (ctypes.c_ulonglong * num_words)()
+        Qrack.qrack_lib.HighestProbAll(self.sid, _r)
+        self._throw_if_error()
+        r = 0
+        for w in range(num_words):
+            r <<= 64
+            r |= _r[w]
+        return r
+
+    def highest_n_prob_perm(self, n):
+        """Get the top n permutations (bit strings) with the highest probability
+
+        Returns the top n highest-probability bit strings in the Hilbert space
+
+        Raises:
+            RuntimeError: QrackSimulator raised an exception.
+
+        Returns:
+            Top n highest probability dimension indices
+        """
+        num_q = self.num_qubits()
+        num_words = (num_q + 63) // 64
+        _r = (ctypes.c_ulonglong * (num_words * n))()
+        Qrack.qrack_lib.HighestProbAllN(self.sid, n, _r)
+        self._throw_if_error()
+        r = [0] * n
+        for i in range(n):
+            r[i] = 0
+            for w in range(num_words):
+                r[i] <<= 64
+                r[i] |= _r[(i * num_words) + w]
+        return r
+
     def prob_all(self, q):
         """Probabilities of all subset permutations
 
@@ -2241,11 +2429,13 @@ class QrackSimulator:
 
         if len(q) != len(c):
             raise RuntimeError("prob_perm argument lengths do not match.")
-        result = Qrack.qrack_lib.PermutationProb(self.sid, len(q), self._ulonglong_byref(q), self._bool_byref(c));
+        result = Qrack.qrack_lib.PermutationProb(
+            self.sid, len(q), self._ulonglong_byref(q), self._bool_byref(c)
+        )
         self._throw_if_error()
         return result
 
-    def prob_perm_rdm(self, q, c, r = True):
+    def prob_perm_rdm(self, q, c, r=True):
         """Probability of permutation, (tracing out the reduced
         density matrix without stabilizer ancillary qubits)
 
@@ -2267,7 +2457,9 @@ class QrackSimulator:
 
         if len(q) != len(c):
             raise RuntimeError("prob_perm argument lengths do not match.")
-        result = Qrack.qrack_lib.PermutationProbRdm(self.sid, len(q), self._ulonglong_byref(q), self._bool_byref(c), r);
+        result = Qrack.qrack_lib.PermutationProbRdm(
+            self.sid, len(q), self._ulonglong_byref(q), self._bool_byref(c), r
+        )
         self._throw_if_error()
         return result
 
@@ -2292,7 +2484,7 @@ class QrackSimulator:
         self._throw_if_error()
         return result
 
-    def permutation_expectation_rdm(self, q, r = True):
+    def permutation_expectation_rdm(self, q, r=True):
         """Permutation expectation value, (tracing out the reduced
         density matrix without stabilizer ancillary qubits)
 
@@ -2341,7 +2533,7 @@ class QrackSimulator:
         self._throw_if_error()
         return result
 
-    def factorized_expectation_rdm(self, q, c, r = True):
+    def factorized_expectation_rdm(self, q, c, r=True):
         """Factorized expectation value, (tracing out the reduced
         density matrix without stabilizer ancillary qubits)
 
@@ -2361,7 +2553,9 @@ class QrackSimulator:
             Expectation value
         """
         if (len(q) << 1) != len(c):
-            raise RuntimeError("factorized_expectation_rdm argument lengths do not match.")
+            raise RuntimeError(
+                "factorized_expectation_rdm argument lengths do not match."
+            )
         m = max([(x.bit_length() + 63) // 64 for x in c])
         result = Qrack.qrack_lib.FactorizedExpectationRdm(
             self.sid, len(q), self._ulonglong_byref(q), m, self._to_ulonglong(m, c), r
@@ -2387,14 +2581,16 @@ class QrackSimulator:
             Expectation value
         """
         if (len(q) << 1) != len(c):
-            raise RuntimeError("factorized_expectation_rdm argument lengths do not match.")
+            raise RuntimeError(
+                "factorized_expectation_rdm argument lengths do not match."
+            )
         result = Qrack.qrack_lib.FactorizedExpectationFp(
             self.sid, len(q), self._ulonglong_byref(q), self._real1_byref(c)
         )
         self._throw_if_error()
         return result
 
-    def factorized_expectation_fp_rdm(self, q, c, r = True):
+    def factorized_expectation_fp_rdm(self, q, c, r=True):
         """Factorized expectation value, (tracing out the reduced
         density matrix without stabilizer ancillary qubits)
 
@@ -2414,7 +2610,9 @@ class QrackSimulator:
             Expectation value
         """
         if (len(q) << 1) != len(c):
-            raise RuntimeError("factorized_expectation_fp_rdm argument lengths do not match.")
+            raise RuntimeError(
+                "factorized_expectation_fp_rdm argument lengths do not match."
+            )
         result = Qrack.qrack_lib.FactorizedExpectationFpRdm(
             self.sid, len(q), self._ulonglong_byref(q), self._real1_byref(c), r
         )
@@ -2486,11 +2684,19 @@ class QrackSimulator:
             Expectation value
         """
         if (3 * len(q)) != len(b):
-            raise RuntimeError("unitary_expectation_eigenval qubit and basis argument lengths do not match.")
+            raise RuntimeError(
+                "unitary_expectation_eigenval qubit and basis argument lengths do not match."
+            )
         if (len(q) << 1) != len(e):
-            raise RuntimeError("unitary_expectation_eigenval qubit and eigenvalue argument lengths do not match.")
+            raise RuntimeError(
+                "unitary_expectation_eigenval qubit and eigenvalue argument lengths do not match."
+            )
         result = Qrack.qrack_lib.UnitaryExpectationEigenVal(
-            self.sid, len(q), self._ulonglong_byref(q), self._real1_byref(b), self._real1_byref(e)
+            self.sid,
+            len(q),
+            self._ulonglong_byref(q),
+            self._real1_byref(b),
+            self._real1_byref(e),
         )
         self._throw_if_error()
         return result
@@ -2512,11 +2718,19 @@ class QrackSimulator:
             Expectation value
         """
         if (len(q) << 2) != len(b):
-            raise RuntimeError("matrix_expectation_eigenval qubit and basis argument lengths do not match.")
+            raise RuntimeError(
+                "matrix_expectation_eigenval qubit and basis argument lengths do not match."
+            )
         if (len(q) << 1) != len(e):
-            raise RuntimeError("matrix_expectation_eigenval qubit and eigenvalue argument lengths do not match.")
+            raise RuntimeError(
+                "matrix_expectation_eigenval qubit and eigenvalue argument lengths do not match."
+            )
         result = Qrack.qrack_lib.MatrixExpectationEigenVal(
-            self.sid, len(q), self._ulonglong_byref(q), self._complex_byref(b), self._real1_byref(e)
+            self.sid,
+            len(q),
+            self._ulonglong_byref(q),
+            self._complex_byref(b),
+            self._real1_byref(e),
         )
         self._throw_if_error()
         return result
@@ -2565,7 +2779,7 @@ class QrackSimulator:
         self._throw_if_error()
         return result
 
-    def variance_rdm(self, q, r = True):
+    def variance_rdm(self, q, r=True):
         """Permutation variance, (tracing out the reduced
         density matrix without stabilizer ancillary qubits)
 
@@ -2614,7 +2828,7 @@ class QrackSimulator:
         self._throw_if_error()
         return result
 
-    def factorized_variance_rdm(self, q, c, r = True):
+    def factorized_variance_rdm(self, q, c, r=True):
         """Factorized variance, (tracing out the reduced
         density matrix without stabilizer ancillary qubits)
 
@@ -2667,7 +2881,7 @@ class QrackSimulator:
         self._throw_if_error()
         return result
 
-    def factorized_variance_fp_rdm(self, q, c, r = True):
+    def factorized_variance_fp_rdm(self, q, c, r=True):
         """Factorized variance, (tracing out the reduced
         density matrix without stabilizer ancillary qubits)
 
@@ -2687,7 +2901,9 @@ class QrackSimulator:
             variance
         """
         if (len(q) << 1) != len(c):
-            raise RuntimeError("factorized_variance_fp_rdm argument lengths do not match.")
+            raise RuntimeError(
+                "factorized_variance_fp_rdm argument lengths do not match."
+            )
         result = Qrack.qrack_lib.FactorizedVarianceFpRdm(
             self.sid, len(q), self._ulonglong_byref(q), self._real1_byref(c), r
         )
@@ -2759,11 +2975,19 @@ class QrackSimulator:
             variance
         """
         if (3 * len(q)) != len(b):
-            raise RuntimeError("unitary_variance_eigenval qubit and basis argument lengths do not match.")
+            raise RuntimeError(
+                "unitary_variance_eigenval qubit and basis argument lengths do not match."
+            )
         if (len(q) << 1) != len(e):
-            raise RuntimeError("unitary_variance_eigenval qubit and eigenvalue argument lengths do not match.")
+            raise RuntimeError(
+                "unitary_variance_eigenval qubit and eigenvalue argument lengths do not match."
+            )
         result = Qrack.qrack_lib.UnitaryVarianceEigenVal(
-            self.sid, len(q), self._ulonglong_byref(q), self._real1_byref(b), self._real1_byref(e)
+            self.sid,
+            len(q),
+            self._ulonglong_byref(q),
+            self._real1_byref(b),
+            self._real1_byref(e),
         )
         self._throw_if_error()
         return result
@@ -2785,11 +3009,19 @@ class QrackSimulator:
             variance
         """
         if (len(q) << 2) != len(b):
-            raise RuntimeError("matrix_variance_eigenval qubit and basis argument lengths do not match.")
+            raise RuntimeError(
+                "matrix_variance_eigenval qubit and basis argument lengths do not match."
+            )
         if (len(q) << 1) != len(e):
-            raise RuntimeError("matrix_variance_eigenval qubit and eigenvalue argument lengths do not match.")
+            raise RuntimeError(
+                "matrix_variance_eigenval qubit and eigenvalue argument lengths do not match."
+            )
         result = Qrack.qrack_lib.MatrixVarianceEigenVal(
-            self.sid, len(q), self._ulonglong_byref(q), self._complex_byref(b), self._real1_byref(e)
+            self.sid,
+            len(q),
+            self._ulonglong_byref(q),
+            self._complex_byref(b),
+            self._real1_byref(e),
         )
         self._throw_if_error()
         return result
@@ -2858,7 +3090,13 @@ class QrackSimulator:
             RuntimeError: QrackSimulator with isTensorNetwork=True option cannot phase_parity()! (Turn off just this option, in the constructor.)
         """
         if self.is_tensor_network:
-            raise RuntimeError("QrackSimulator with isTensorNetwork=True option cannot phase_parity()! (Turn off just this option, in the constructor.)")
+            raise RuntimeError(
+                "QrackSimulator with isTensorNetwork=True option cannot phase_parity()! (Turn off just this option, in the constructor.)"
+            )
+        if self.is_pure_stabilizer:
+            raise RuntimeError(
+                "QrackStabilizer cannot phase_parity()! (Create a QrackSimulator instead, also with isTensorNetwork=False.)"
+            )
 
         Qrack.qrack_lib.PhaseParity(
             self.sid, ctypes.c_double(la), len(q), self._ulonglong_byref(q)
@@ -2879,11 +3117,15 @@ class QrackSimulator:
             RuntimeError: QrackSimulator with isTensorNetwork=True option cannot phase_root_n()! (Turn off just this option, in the constructor.)
         """
         if self.is_tensor_network:
-            raise RuntimeError("QrackSimulator with isTensorNetwork=True option cannot phase_root_n()! (Turn off just this option, in the constructor.)")
+            raise RuntimeError(
+                "QrackSimulator with isTensorNetwork=True option cannot phase_root_n()! (Turn off just this option, in the constructor.)"
+            )
+        if self.is_pure_stabilizer:
+            raise RuntimeError(
+                "QrackStabilizer cannot phase_root_n()! (Create a QrackSimulator instead, also with isTensorNetwork=False.)"
+            )
 
-        Qrack.qrack_lib.PhaseRootN(
-            self.sid, n, len(q), self._ulonglong_byref(q)
-        )
+        Qrack.qrack_lib.PhaseRootN(self.sid, n, len(q), self._ulonglong_byref(q))
         self._throw_if_error()
 
     def try_separate_1qb(self, qi1):
@@ -2945,6 +3187,20 @@ class QrackSimulator:
         self._throw_if_error()
         return result
 
+    def separate(self, qs):
+        """Force manual multi-qubits seperation
+
+        Force separation as per `try_separate_tolerance`.
+
+        Args:
+            qs: list of qubits to be decomposed
+
+        Raises:
+            Runtimeerror: QrackSimulator raised an exception.
+        """
+        result = Qrack.qrack_lib.Separate(self.sid, len(qs), self._ulonglong_byref(qs))
+        self._throw_if_error()
+
     def get_unitary_fidelity(self):
         """Get fidelity estimate
 
@@ -3051,6 +3307,35 @@ class QrackSimulator:
         Qrack.qrack_lib.SetTInjection(self.sid, iti)
         self._throw_if_error()
 
+    def set_noise_parameter(self, np):
+        """Set noise parameter option
+
+        If noisy simulation is on, then this set the depolarization
+        parameter per qubit per gate. (Default is 0.01.)
+
+        Args:
+            np: depolarizing noise parameter
+
+        Raises:
+            RuntimeError: QrackSimulator raised an exception.
+        """
+        Qrack.qrack_lib.SetNoiseParameter(self.sid, np)
+        self._throw_if_error()
+
+    def normalize(self):
+        """Normalize the state
+
+        This should never be necessary to use unless
+        decompose() is "abused." ("Abusing" decompose()
+        might lead to efficient entanglement-breaking
+        channels, though.)
+
+        Raises:
+            RuntimeError: QrackSimulator raised an exception.
+        """
+        Qrack.qrack_lib.Normalize(self.sid)
+        self._throw_if_error()
+
     def out_to_file(self, filename):
         """Output state to file (stabilizer only!)
 
@@ -3059,10 +3344,18 @@ class QrackSimulator:
         Args:
             filename: Name of file
         """
-        Qrack.qrack_lib.qstabilizer_out_to_file(self.sid, filename.encode('utf-8'))
+        Qrack.qrack_lib.qstabilizer_out_to_file(self.sid, filename.encode("utf-8"))
         self._throw_if_error()
 
-    def in_from_file(filename, is_binary_decision_tree = False, is_paged = True, is_cpu_gpu_hybrid = True, is_opencl = True, is_host_pointer = False):
+    def in_from_file(
+        filename,
+        is_binary_decision_tree=False,
+        is_paged=True,
+        is_cpu_gpu_hybrid=False,
+        is_opencl=True,
+        is_host_pointer=False,
+        is_noisy=False,
+    ):
         """Input state from file (stabilizer only!)
 
         Reads in a hybrid stabilizer state from file.
@@ -3083,9 +3376,10 @@ class QrackSimulator:
             isPaged=is_paged,
             isCpuGpuHybrid=is_cpu_gpu_hybrid,
             isOpenCL=is_opencl,
-            isHostPointer=is_host_pointer
+            isHostPointer=is_host_pointer,
+            isNoisy=is_noisy,
         )
-        Qrack.qrack_lib.qstabilizer_in_from_file(out.sid, filename.encode('utf-8'))
+        Qrack.qrack_lib.qstabilizer_in_from_file(out.sid, filename.encode("utf-8"))
         out._throw_if_error()
 
         return out
@@ -3110,7 +3404,7 @@ class QrackSimulator:
             )
 
         lines = []
-        with open(filename, 'r') as file:
+        with open(filename, "r") as file:
             lines = file.readlines()
 
         logical_qubits = int(lines[0])
@@ -3118,9 +3412,7 @@ class QrackSimulator:
 
         stabilizer_count = int(lines[2])
 
-        reg = QuantumRegister(stabilizer_qubits, name="q")
-        circ_qubits = [Qubit(reg, i) for i in range(stabilizer_qubits)]
-        clifford_circ = QuantumCircuit(reg)
+        clifford_circ = None
         line_number = 3
         for i in range(stabilizer_count):
             shard_map_size = int(lines[line_number])
@@ -3132,14 +3424,10 @@ class QrackSimulator:
                 line_number += 1
                 shard_map[int(line[0])] = int(line[1])
 
-            sub_reg = []
-            for index, _ in sorted(shard_map.items(), key=lambda x: x[1]):
-                sub_reg.append(circ_qubits[index])
-
             line_number += 1
             tableau = []
             row_count = shard_map_size << 1
-            for line in lines[line_number:(line_number + row_count)]:
+            for line in lines[line_number : (line_number + row_count)]:
                 bits = line.split()
                 if len(bits) != (row_count + 1):
                     raise QrackException("Invalid Qrack hybrid stabilizer file!")
@@ -3148,31 +3436,23 @@ class QrackSimulator:
                     row.append(bool(int(bits[b])))
                 row.append(bool((int(bits[-1]) >> 1) & 1))
                 tableau.append(row)
-            line_number += (shard_map_size << 1)
+            line_number += shard_map_size << 1
             tableau = np.array(tableau, bool)
 
             clifford = Clifford(tableau, validate=False, copy=False)
-            circ = clifford.to_circuit()
-
-            for instr in circ.data:
-                qubits = instr.qubits
-                n_qubits = []
-                for qubit in qubits:
-                    n_qubits.append(sub_reg[circ.find_bit(qubit)[0]])
-                instr.qubits = tuple(n_qubits)
-                clifford_circ.data.append(instr)
-            del circ
+            clifford_circ = clifford.to_circuit()
+            clifford_circ = QrackSimulator._reorder_qubits(clifford_circ, shard_map)
 
         non_clifford_gates = []
         g = 0
         for line in lines[line_number:]:
             i = 0
             tokens = line.split()
-            op = np.zeros((2,2), dtype=complex)
+            op = np.zeros((2, 2), dtype=complex)
             row = []
             for _ in range(2):
-                amp = tokens[i].replace("(","").replace(")","").split(',')
-                row.append(float(amp[0]) + float(amp[1])*1j)
+                amp = tokens[i].replace("(", "").replace(")", "").split(",")
+                row.append(float(amp[0]) + float(amp[1]) * 1j)
                 i = i + 1
             l = math.sqrt(np.real(row[0] * np.conj(row[0]) + row[1] * np.conj(row[1])))
             op[0][0] = row[0] / l
@@ -3185,8 +3465,8 @@ class QrackSimulator:
 
             row = []
             for _ in range(2):
-                amp = tokens[i].replace("(","").replace(")","").split(',')
-                row.append(float(amp[0]) + float(amp[1])*1j)
+                amp = tokens[i].replace("(", "").replace(")", "").split(",")
+                row.append(float(amp[0]) + float(amp[1]) * 1j)
                 i = i + 1
             l = math.sqrt(np.real(row[0] * np.conj(row[0]) + row[1] * np.conj(row[1])))
             op[1][0] = row[0] / l
@@ -3205,9 +3485,27 @@ class QrackSimulator:
             non_clifford_gates.append(op)
             g = g + 1
 
-        basis_gates = ["rz", "h", "x", "y", "z", "sx", "sxdg", "sy", "sydg", "s", "sdg", "t", "tdg", "cx", "cy", "cz", "swap"]
+        basis_gates = [
+            "rz",
+            "h",
+            "x",
+            "y",
+            "z",
+            "sx",
+            "sxdg",
+            "s",
+            "sdg",
+            "t",
+            "tdg",
+            "cx",
+            "cy",
+            "cz",
+            "swap",
+        ]
         try:
-            circ = transpile(clifford_circ, basis_gates=basis_gates, optimization_level=2)
+            circ = transpile(
+                clifford_circ, basis_gates=basis_gates, optimization_level=2
+            )
         except:
             circ = clifford_circ
 
@@ -3222,6 +3520,35 @@ class QrackSimulator:
 
         return circ
 
+    def _reorder_qubits(circuit, mapping):
+        """
+        Reorders qubits in the circuit according to the given mapping using SWAP gates.
+        (Thanks to "Elara," an OpenAI GPT, for this implementation)
+
+        Parameters:
+        - circuit (QuantumCircuit): The circuit to modify.
+        - mapping (dict): Dictionary mapping internal qubit indices to logical qubit indices.
+
+        Returns:
+        - QuantumCircuit: The modified circuit with qubits reordered.
+        """
+        swaps = []
+
+        # Determine swaps to fix the order
+        for logical_index in sorted(mapping):
+            internal_index = mapping[logical_index]
+            if logical_index != internal_index:
+                swaps.append((logical_index, internal_index))
+                # Update the reverse mapping for subsequent swaps
+                mapping[logical_index] = logical_index
+                mapping[internal_index] = internal_index
+
+        # Apply the swaps to the circuit
+        for qubit1, qubit2 in swaps:
+            circuit.swap(qubit1, qubit2)
+
+        return circuit
+
     def file_to_optimized_qiskit_circuit(filename):
         """Convert an output state file to a Qiskit circuit
 
@@ -3239,7 +3566,7 @@ class QrackSimulator:
                 QrackCircuit, you must install Qiskit, numpy, and math!
         """
         circ = QrackSimulator.file_to_qiskit_circuit(filename)
-        
+
         width = 0
         with open(filename, "r", encoding="utf-8") as file:
             width = int(file.readline())
@@ -3248,7 +3575,7 @@ class QrackSimulator:
         sqrt_ni = np.sqrt(-1j)
         sqrt1_2 = 1 / math.sqrt(2)
         ident = np.eye(2, dtype=np.complex128)
-        # passable_gates = ["unitary", "rz", "h", "x", "y", "z", "sx", "sxdg", "sy", "sydg", "s", "sdg", "t", "tdg"]
+        # passable_gates = ["unitary", "rz", "h", "x", "y", "z", "sx", "sxdg", "s", "sdg", "t", "tdg"]
 
         passed_swaps = []
         for i in range(0, circ.width()):
@@ -3259,40 +3586,104 @@ class QrackSimulator:
                 op = circ.data[j].operation
                 qubits = circ.data[j].qubits
                 if len(qubits) > 2:
-                    raise RuntimeError("Something went wrong while optimizing circuit! (Found a gate with 3 or more qubits)")
+                    raise RuntimeError(
+                        "Something went wrong while optimizing circuit! (Found a gate with 3 or more qubits)"
+                    )
                 q1 = circ.find_bit(qubits[0])[0]
                 if (len(qubits) < 2) and (q1 == i):
                     if op.name == "unitary":
                         non_clifford = np.matmul(op.params[0], non_clifford)
                     elif op.name == "rz":
                         lm = float(op.params[0])
-                        non_clifford = np.matmul([[np.exp(-1j * lm / 2), 0], [0, np.exp(1j * lm / 2)]], non_clifford)
+                        non_clifford = np.matmul(
+                            [[np.exp(-1j * lm / 2), 0], [0, np.exp(1j * lm / 2)]],
+                            non_clifford,
+                        )
                     elif op.name == "h":
-                        non_clifford = np.matmul(np.array([[sqrt1_2, sqrt1_2], [sqrt1_2, -sqrt1_2]], np.complex128), non_clifford)
+                        non_clifford = np.matmul(
+                            np.array(
+                                [[sqrt1_2, sqrt1_2], [sqrt1_2, -sqrt1_2]], np.complex128
+                            ),
+                            non_clifford,
+                        )
                     elif op.name == "x":
-                        non_clifford = np.matmul(np.array([[0, 1], [1, 0]], np.complex128), non_clifford)
+                        non_clifford = np.matmul(
+                            np.array([[0, 1], [1, 0]], np.complex128), non_clifford
+                        )
                     elif op.name == "y":
-                        non_clifford = np.matmul(np.array([[0, -1j], [1j, 0]], np.complex128), non_clifford)
+                        non_clifford = np.matmul(
+                            np.array([[0, -1j], [1j, 0]], np.complex128), non_clifford
+                        )
                     elif op.name == "z":
-                        non_clifford = np.matmul(np.array([[1, 0], [0, -1]], np.complex128), non_clifford)
+                        non_clifford = np.matmul(
+                            np.array([[1, 0], [0, -1]], np.complex128), non_clifford
+                        )
                     elif op.name == "sx":
-                        non_clifford = np.matmul(np.array([[(1+1j)/2, (1-1j)/2], [(1-1j)/2, (1+1j)/2]], np.complex128), non_clifford)
+                        non_clifford = np.matmul(
+                            np.array(
+                                [
+                                    [(1 + 1j) / 2, (1 - 1j) / 2],
+                                    [(1 - 1j) / 2, (1 + 1j) / 2],
+                                ],
+                                np.complex128,
+                            ),
+                            non_clifford,
+                        )
                     elif op.name == "sxdg":
-                        non_clifford = np.matmul(np.array([[(1-1j)/2, (1+1j)/2], [(1+1j)/2, (1-1j)/2]], np.complex128), non_clifford)
+                        non_clifford = np.matmul(
+                            np.array(
+                                [
+                                    [(1 - 1j) / 2, (1 + 1j) / 2],
+                                    [(1 + 1j) / 2, (1 - 1j) / 2],
+                                ],
+                                np.complex128,
+                            ),
+                            non_clifford,
+                        )
                     elif op.name == "sy":
-                        non_clifford = np.matmul(np.array([[(1+1j)/2, -(1+1j)/2], [(1+1j)/2, (1+1j)/2]], np.complex128), non_clifford)
+                        non_clifford = np.matmul(
+                            np.array(
+                                [
+                                    [(1 + 1j) / 2, -(1 + 1j) / 2],
+                                    [(1 + 1j) / 2, (1 + 1j) / 2],
+                                ],
+                                np.complex128,
+                            ),
+                            non_clifford,
+                        )
                     elif op.name == "sydg":
-                        non_clifford = np.matmul(np.array([[(1-1j)/2, (1-1j)/2], [(-1+1j)/2, (1-1j)/2]], np.complex128), non_clifford)
+                        non_clifford = np.matmul(
+                            np.array(
+                                [
+                                    [(1 - 1j) / 2, (1 - 1j) / 2],
+                                    [(-1 + 1j) / 2, (1 - 1j) / 2],
+                                ],
+                                np.complex128,
+                            ),
+                            non_clifford,
+                        )
                     elif op.name == "s":
-                        non_clifford = np.matmul(np.array([[1, 0], [0, 1j]], np.complex128), non_clifford)
+                        non_clifford = np.matmul(
+                            np.array([[1, 0], [0, 1j]], np.complex128), non_clifford
+                        )
                     elif op.name == "sdg":
-                        non_clifford = np.matmul(np.array([[1, 0], [0, -1j]], np.complex128), non_clifford)
+                        non_clifford = np.matmul(
+                            np.array([[1, 0], [0, -1j]], np.complex128), non_clifford
+                        )
                     elif op.name == "t":
-                        non_clifford = np.matmul(np.array([[1, 0], [0, sqrt_pi]], np.complex128), non_clifford)
+                        non_clifford = np.matmul(
+                            np.array([[1, 0], [0, sqrt_pi]], np.complex128),
+                            non_clifford,
+                        )
                     elif op.name == "tdg":
-                        non_clifford = np.matmul(np.array([[1, 0], [0, sqrt_ni]], np.complex128), non_clifford)
+                        non_clifford = np.matmul(
+                            np.array([[1, 0], [0, sqrt_ni]], np.complex128),
+                            non_clifford,
+                        )
                     else:
-                        raise RuntimeError("Something went wrong while optimizing circuit! (Dropped a single-qubit gate.)")
+                        raise RuntimeError(
+                            "Something went wrong while optimizing circuit! (Dropped a single-qubit gate.)"
+                        )
 
                     del circ.data[j]
                     continue
@@ -3308,7 +3699,7 @@ class QrackSimulator:
                     continue
 
                 if op.name == "swap":
-                    i = (q2 if i == q1 else q1)
+                    i = q2 if i == q1 else q1
 
                     if circ.data[j] in passed_swaps:
                         passed_swaps.remove(circ.data[j])
@@ -3318,26 +3709,30 @@ class QrackSimulator:
                     passed_swaps.append(circ.data[j])
 
                     j += 1
-                    continue 
+                    continue
 
-                if (q1 == i) and ((op.name == "cx") or (op.name == "cy") or (op.name == "cz")):
-                    if (np.isclose(np.abs(non_clifford[0][1]), 0) and np.isclose(np.abs(non_clifford[1][0]), 0)):
+                if (q1 == i) and (
+                    (op.name == "cx") or (op.name == "cy") or (op.name == "cz")
+                ):
+                    if np.isclose(np.abs(non_clifford[0][1]), 0) and np.isclose(
+                        np.abs(non_clifford[1][0]), 0
+                    ):
                         # If we're not buffering anything but phase, the blocking gate has no effect, and we're safe to continue.
                         del circ.data[j]
                         continue
 
-                    if (np.isclose(np.abs(non_clifford[0][0]), 0) and np.isclose(np.abs(non_clifford[1][1]), 0)):
+                    if np.isclose(np.abs(non_clifford[0][0]), 0) and np.isclose(
+                        np.abs(non_clifford[1][1]), 0
+                    ):
                         # If we're buffering full negation (plus phase), the control qubit can be dropped.
-                        c = QuantumCircuit(1)
+                        c = QuantumCircuit(circ.qubits)
                         if op.name == "cx":
-                            c.x(0)
+                            c.x(qubits[1])
                         elif op.name == "cy":
-                            c.y(0)
+                            c.y(qubits[1])
                         else:
-                            c.z(0)
-                        instr = c.data[0]
-                        instr.qubits = (qubits[1],)
-                        circ.data[j] = copy.deepcopy(instr)
+                            c.z(qubits[1])
+                        circ.data[j] = copy.deepcopy(c.data[0])
 
                         j += 1
                         continue
@@ -3348,11 +3743,9 @@ class QrackSimulator:
                     break
 
                 # We're blocked, so we insert our buffer at this place in the circuit definition.
-                c = QuantumCircuit(1)
-                c.unitary(non_clifford, 0)
-                instr = c.data[0]
-                instr.qubits = (qubits[0],)
-                circ.data.insert(j, copy.deepcopy(instr))
+                c = QuantumCircuit(circ.qubits)
+                c.unitary(non_clifford, qubits[0])
+                circ.data.insert(j, copy.deepcopy(c.data[0]))
 
                 non_clifford = np.copy(ident)
                 break
@@ -3370,40 +3763,104 @@ class QrackSimulator:
                 op = circ.data[j].operation
                 qubits = circ.data[j].qubits
                 if len(qubits) > 2:
-                    raise RuntimeError("Something went wrong while optimizing circuit! (Found a gate with 3 or more qubits.)")
+                    raise RuntimeError(
+                        "Something went wrong while optimizing circuit! (Found a gate with 3 or more qubits.)"
+                    )
                 q1 = circ.find_bit(qubits[0])[0]
                 if (len(qubits) < 2) and (q1 == i):
                     if op.name == "unitary":
                         non_clifford = np.matmul(non_clifford, op.params[0])
                     elif op.name == "rz":
                         lm = float(op.params[0])
-                        non_clifford = np.matmul(non_clifford, [[np.exp(-1j * lm / 2), 0], [0, np.exp(1j * lm / 2)]])
+                        non_clifford = np.matmul(
+                            non_clifford,
+                            [[np.exp(-1j * lm / 2), 0], [0, np.exp(1j * lm / 2)]],
+                        )
                     elif op.name == "h":
-                        non_clifford = np.matmul(non_clifford, np.array([[sqrt1_2, sqrt1_2], [sqrt1_2, -sqrt1_2]], np.complex128))
+                        non_clifford = np.matmul(
+                            non_clifford,
+                            np.array(
+                                [[sqrt1_2, sqrt1_2], [sqrt1_2, -sqrt1_2]], np.complex128
+                            ),
+                        )
                     elif op.name == "x":
-                        non_clifford = np.matmul(non_clifford, np.array([[0, 1], [1, 0]], np.complex128))
+                        non_clifford = np.matmul(
+                            non_clifford, np.array([[0, 1], [1, 0]], np.complex128)
+                        )
                     elif op.name == "y":
-                        non_clifford = np.matmul(non_clifford, np.array([[0, -1j], [1j, 0]], np.complex128))
+                        non_clifford = np.matmul(
+                            non_clifford, np.array([[0, -1j], [1j, 0]], np.complex128)
+                        )
                     elif op.name == "z":
-                        non_clifford = np.matmul(non_clifford, np.array([[1, 0], [0, -1]], np.complex128))
+                        non_clifford = np.matmul(
+                            non_clifford, np.array([[1, 0], [0, -1]], np.complex128)
+                        )
                     elif op.name == "sx":
-                        non_clifford = np.matmul(non_clifford, np.array([[(1+1j)/2, (1-1j)/2], [(1-1j)/2, (1+1j)/2]], np.complex128))
+                        non_clifford = np.matmul(
+                            non_clifford,
+                            np.array(
+                                [
+                                    [(1 + 1j) / 2, (1 - 1j) / 2],
+                                    [(1 - 1j) / 2, (1 + 1j) / 2],
+                                ],
+                                np.complex128,
+                            ),
+                        )
                     elif op.name == "sxdg":
-                        non_clifford = np.matmul(non_clifford, np.array([[(1-1j)/2, (1+1j)/2], [(1+1j)/2, (1-1j)/2]], np.complex128))
+                        non_clifford = np.matmul(
+                            non_clifford,
+                            np.array(
+                                [
+                                    [(1 - 1j) / 2, (1 + 1j) / 2],
+                                    [(1 + 1j) / 2, (1 - 1j) / 2],
+                                ],
+                                np.complex128,
+                            ),
+                        )
                     elif op.name == "sy":
-                        non_clifford = np.matmul(non_clifford, np.array([[(1+1j)/2, -(1+1j)/2], [(1+1j)/2, (1+1j)/2]], np.complex128))
+                        non_clifford = np.matmul(
+                            non_clifford,
+                            np.array(
+                                [
+                                    [(1 + 1j) / 2, -(1 + 1j) / 2],
+                                    [(1 + 1j) / 2, (1 + 1j) / 2],
+                                ],
+                                np.complex128,
+                            ),
+                        )
                     elif op.name == "sydg":
-                        non_clifford = np.matmul(non_clifford, np.array([[(1-1j)/2, (1-1j)/2], [(-1+1j)/2, (1-1j)/2]], np.complex128))
+                        non_clifford = np.matmul(
+                            non_clifford,
+                            np.array(
+                                [
+                                    [(1 - 1j) / 2, (1 - 1j) / 2],
+                                    [(-1 + 1j) / 2, (1 - 1j) / 2],
+                                ],
+                                np.complex128,
+                            ),
+                        )
                     elif op.name == "s":
-                        non_clifford = np.matmul(non_clifford, np.array([[1, 0], [0, 1j]], np.complex128))
+                        non_clifford = np.matmul(
+                            non_clifford, np.array([[1, 0], [0, 1j]], np.complex128)
+                        )
                     elif op.name == "sdg":
-                        non_clifford = np.matmul(non_clifford, np.array([[1, 0], [0, -1j]], np.complex128))
+                        non_clifford = np.matmul(
+                            non_clifford, np.array([[1, 0], [0, -1j]], np.complex128)
+                        )
                     elif op.name == "t":
-                        non_clifford = np.matmul(non_clifford, np.array([[1, 0], [0, sqrt_pi]], np.complex128))
+                        non_clifford = np.matmul(
+                            non_clifford,
+                            np.array([[1, 0], [0, sqrt_pi]], np.complex128),
+                        )
                     elif op.name == "tdg":
-                        non_clifford = np.matmul(non_clifford, np.array([[1, 0], [0, sqrt_ni]], np.complex128))
+                        non_clifford = np.matmul(
+                            non_clifford,
+                            np.array([[1, 0], [0, sqrt_ni]], np.complex128),
+                        )
                     else:
-                        raise RuntimeError("Something went wrong while optimizing circuit! (Dropped a single-qubit gate.)")
+                        raise RuntimeError(
+                            "Something went wrong while optimizing circuit! (Dropped a single-qubit gate.)"
+                        )
 
                     del circ.data[j]
                     j -= 1
@@ -3420,7 +3877,7 @@ class QrackSimulator:
                     continue
 
                 if (op.name == "swap") and (q1 >= width) and (q2 >= width):
-                    i = (q2 if i == q1 else q1)
+                    i = q2 if i == q1 else q1
                     if circ.data[j] in passed_swaps:
                         passed_swaps.remove(circ.data[j])
                         del circ.data[j]
@@ -3430,7 +3887,14 @@ class QrackSimulator:
                     j -= 1
                     continue
 
-                if (q1 == i) and ((op.name == "cx") or (op.name == "cy") or (op.name == "cz")) and (np.isclose(np.abs(non_clifford[0][1]), 0) and np.isclose(np.abs(non_clifford[1][0]), 0)):
+                if (
+                    (q1 == i)
+                    and ((op.name == "cx") or (op.name == "cy") or (op.name == "cz"))
+                    and (
+                        np.isclose(np.abs(non_clifford[0][1]), 0)
+                        and np.isclose(np.abs(non_clifford[1][0]), 0)
+                    )
+                ):
                     # If we're not buffering anything but phase, this commutes with control, and we're safe to continue.
                     j -= 1
                     continue
@@ -3439,21 +3903,18 @@ class QrackSimulator:
                     orig_instr = circ.data[j]
                     del circ.data[j]
 
-                    h = QuantumCircuit(1)
-                    h.h(0)
-                    instr = h.data[0]
-
                     # We're replacing CNOT with CNOT in the opposite direction plus four H gates
-                    instr.qubits = (qubits[0],)
-                    circ.data.insert(j, copy.deepcopy(instr))
-                    instr.qubits = (qubits[1],)
-                    circ.data.insert(j, copy.deepcopy(instr))
-                    orig_instr.qubits = (qubits[1], qubits[0])
-                    circ.data.insert(j, copy.deepcopy(orig_instr))
-                    instr.qubits = (qubits[0],)
-                    circ.data.insert(j, copy.deepcopy(instr))
-                    instr.qubits = (qubits[1],)
-                    circ.data.insert(j, copy.deepcopy(instr))
+                    rep = QuantumCircuit(circ.qubits)
+                    rep.h(qubits[0])
+                    circ.data.insert(j, copy.deepcopy(rep.data[0]))
+                    rep.h(qubits[1])
+                    circ.data.insert(j, copy.deepcopy(rep.data[1]))
+                    rep.cx(qubits[1], qubits[0])
+                    circ.data.insert(j, copy.deepcopy(rep.data[2]))
+                    rep.h(qubits[0])
+                    circ.data.insert(j, copy.deepcopy(rep.data[3]))
+                    rep.h(qubits[1])
+                    circ.data.insert(j, copy.deepcopy(rep.data[4]))
 
                     j += 4
                     continue
@@ -3464,38 +3925,62 @@ class QrackSimulator:
                         break
 
                     # We're blocked, so we insert our buffer at this place in the circuit definition.
-                    c = QuantumCircuit(1)
-                    c.unitary(non_clifford, 0)
-                    instr = c.data[0]
-                    instr.qubits = (qubits[0],)
-                    circ.data.insert(j + 1, copy.deepcopy(instr))
+                    c = QuantumCircuit(circ.qubits)
+                    c.unitary(non_clifford, qubits[0])
+                    circ.data.insert(j + 1, copy.deepcopy(c.data[0]))
 
                     break
 
                 # Re-injection branch (apply gadget to target)
-                to_inject = np.matmul(non_clifford, np.array([[sqrt1_2, sqrt1_2], [sqrt1_2, -sqrt1_2]]))
+                to_inject = np.matmul(
+                    non_clifford, np.array([[sqrt1_2, sqrt1_2], [sqrt1_2, -sqrt1_2]])
+                )
                 if np.allclose(to_inject, ident):
                     # No buffer content to write to circuit definition
                     del circ.data[j]
                     j -= 1
                     continue
 
-                c = QuantumCircuit(1)
-                c.unitary(to_inject, 0)
-                instr = c.data[0]
-                instr.qubits = (qubits[0],)
-                circ.data[j] = copy.deepcopy(instr)
+                c = QuantumCircuit(circ.qubits)
+                c.unitary(to_inject, qubits[0])
+                circ.data.insert(j, copy.deepcopy(c.data[0]))
                 j -= 1
 
-        basis_gates=["u", "rz", "h", "x", "y", "z", "sx", "sxdg", "sy", "sydg", "s", "sdg", "t", "tdg", "cx", "cy", "cz", "swap"]
+        basis_gates = [
+            "u",
+            "rz",
+            "h",
+            "x",
+            "y",
+            "z",
+            "sx",
+            "sxdg",
+            "s",
+            "sdg",
+            "t",
+            "tdg",
+            "cx",
+            "cy",
+            "cz",
+            "swap",
+        ]
         circ = transpile(circ, basis_gates=basis_gates, optimization_level=2)
 
-        #Eliminate unused ancillae
-        qasm = circ.qasm()
-        qasm = qasm.replace("qreg q[" + str(circ.width()) + "];", "qreg q[" + str(width) + "];")
-        highest_index = max([int(x) for x in re.findall(r"\[(.*?)\]", qasm) if x.isdigit()])
+        # Eliminate unused ancillae
+        try:
+            qasm = qasm3.dumps(circ)
+        except:
+            qasm = circ.qasm()
+        qasm = qasm.replace(
+            "qreg q[" + str(circ.width()) + "];", "qreg q[" + str(width) + "];"
+        )
+        highest_index = max(
+            [int(x) for x in re.findall(r"\[(.*?)\]", qasm) if x.isdigit()]
+        )
         if highest_index != width:
-            qasm = qasm.replace("qreg q[" + str(width) + "];", "qreg q[" + str(highest_index) + "];")
+            qasm = qasm.replace(
+                "qreg q[" + str(width) + "];", "qreg q[" + str(highest_index) + "];"
+            )
 
         orig_circ = circ
         try:
@@ -3561,11 +4046,11 @@ class QrackSimulator:
     def _apply_op(self, operation):
         name = operation.name
 
-        if (name == 'id') or (name == 'barrier'):
+        if (name == "id") or (name == "barrier"):
             # Skip measurement logic
             return
 
-        conditional = getattr(operation, 'conditional', None)
+        conditional = getattr(operation, "conditional", None)
         if isinstance(conditional, int):
             conditional_bit_set = (self._classical_register >> conditional) & 1
             if not conditional_bit_set:
@@ -3580,154 +4065,191 @@ class QrackSimulator:
                 if value != int(conditional.val, 16):
                     return
 
-        if (name == 'u1') or (name == 'p'):
-            self._sim.u(operation.qubits[0], 0, 0, float(operation.params[0]))
-        elif name == 'u2':
+        if (name == "u1") or (name == "p"):
+            self._sim.u(operation.qubits[0]._index, 0, 0, float(operation.params[0]))
+        elif name == "u2":
             self._sim.u(
-                operation.qubits[0],
+                operation.qubits[0]._index,
                 math.pi / 2,
                 float(operation.params[0]),
                 float(operation.params[1]),
             )
-        elif (name == 'u3') or (name == 'u'):
+        elif (name == "u3") or (name == "u"):
             self._sim.u(
-                operation.qubits[0],
+                operation.qubits[0]._index,
                 float(operation.params[0]),
                 float(operation.params[1]),
                 float(operation.params[2]),
             )
-        elif (name == 'unitary') and (len(operation.qubits) == 1):
-            self._sim.mtrx(operation.params[0].flatten(), operation.qubits[0])
-        elif name == 'r':
+        elif (name == "unitary") and (len(operation.qubits) == 1):
+            self._sim.mtrx(operation.params[0].flatten(), operation.qubits[0]._index)
+        elif name == "r":
             self._sim.u(
-                operation.qubits[0],
+                operation.qubits[0]._index,
                 float(operation.params[0]),
                 float(operation.params[1]) - math.pi / 2,
                 (-1 * float(operation.params[1])) + math.pi / 2,
             )
-        elif name == 'rx':
-            self._sim.r(Pauli.PauliX, float(operation.params[0]), operation.qubits[0])
-        elif name == 'ry':
-            self._sim.r(Pauli.PauliY, float(operation.params[0]), operation.qubits[0])
-        elif name == 'rz':
-            self._sim.r(Pauli.PauliZ, float(operation.params[0]), operation.qubits[0])
-        elif name == 'h':
-            self._sim.h(operation.qubits[0])
-        elif name == 'x':
-            self._sim.x(operation.qubits[0])
-        elif name == 'y':
-            self._sim.y(operation.qubits[0])
-        elif name == 'z':
-            self._sim.z(operation.qubits[0])
-        elif name == 's':
-            self._sim.s(operation.qubits[0])
-        elif name == 'sdg':
-            self._sim.adjs(operation.qubits[0])
-        elif name == 'sx':
+        elif name == "rx":
+            self._sim.r(
+                Pauli.PauliX, float(operation.params[0]), operation.qubits[0]._index
+            )
+        elif name == "ry":
+            self._sim.r(
+                Pauli.PauliY, float(operation.params[0]), operation.qubits[0]._index
+            )
+        elif name == "rz":
+            self._sim.r(
+                Pauli.PauliZ, float(operation.params[0]), operation.qubits[0]._index
+            )
+        elif name == "h":
+            self._sim.h(operation.qubits[0]._index)
+        elif name == "x":
+            self._sim.x(operation.qubits[0]._index)
+        elif name == "y":
+            self._sim.y(operation.qubits[0]._index)
+        elif name == "z":
+            self._sim.z(operation.qubits[0]._index)
+        elif name == "s":
+            self._sim.s(operation.qubits[0]._index)
+        elif name == "sdg":
+            self._sim.adjs(operation.qubits[0]._index)
+        elif name == "sx":
             self._sim.mtrx(
                 [(1 + 1j) / 2, (1 - 1j) / 2, (1 - 1j) / 2, (1 + 1j) / 2],
-                operation.qubits[0],
+                operation.qubits[0]._index,
             )
-        elif name == 'sxdg':
+        elif name == "sxdg":
             self._sim.mtrx(
                 [(1 - 1j) / 2, (1 + 1j) / 2, (1 + 1j) / 2, (1 - 1j) / 2],
-                operation.qubits[0],
+                operation.qubits[0]._index,
             )
-        elif name == 't':
-            self._sim.t(operation.qubits[0])
-        elif name == 'tdg':
-            self._sim.adjt(operation.qubits[0])
-        elif name == 'cu1':
+        elif name == "t":
+            self._sim.t(operation.qubits[0]._index)
+        elif name == "tdg":
+            self._sim.adjt(operation.qubits[0]._index)
+        elif name == "cu1":
             self._sim.mcu(
-                operation.qubits[0:1], operation.qubits[1], 0, 0, float(operation.params[0])
+                [q._index for q in operation.qubits[0:1]],
+                operation.qubits[1]._index,
+                0,
+                0,
+                float(operation.params[0]),
             )
-        elif name == 'cu2':
+        elif name == "cu2":
             self._sim.mcu(
-                operation.qubits[0:1],
-                operation.qubits[1],
+                [q._index for q in operation.qubits[0:1]],
+                operation.qubits[1]._index,
                 math.pi / 2,
                 float(operation.params[0]),
                 float(operation.params[1]),
             )
-        elif (name == 'cu3') or (name == 'cu'):
+        elif (name == "cu3") or (name == "cu"):
             self._sim.mcu(
-                operation.qubits[0:1],
-                operation.qubits[1],
+                [q._index for q in operation.qubits[0:1]],
+                operation.qubits[1]._index,
                 float(operation.params[0]),
                 float(operation.params[1]),
                 float(operation.params[2]),
             )
-        elif name == 'cx':
-            self._sim.mcx(operation.qubits[0:1], operation.qubits[1])
-        elif name == 'cy':
-            self._sim.mcy(operation.qubits[0:1], operation.qubits[1])
-        elif name == 'cz':
-            self._sim.mcz(operation.qubits[0:1], operation.qubits[1])
-        elif name == 'ch':
-            self._sim.mch(operation.qubits[0:1], operation.qubits[1])
-        elif name == 'cp':
+        elif name == "cx":
+            self._sim.mcx(
+                [q._index for q in operation.qubits[0:1]], operation.qubits[1]._index
+            )
+        elif name == "cy":
+            self._sim.mcy(
+                [q._index for q in operation.qubits[0:1]], operation.qubits[1]._index
+            )
+        elif name == "cz":
+            self._sim.mcz(
+                [q._index for q in operation.qubits[0:1]], operation.qubits[1]._index
+            )
+        elif name == "ch":
+            self._sim.mch(
+                [q._index for q in operation.qubits[0:1]], operation.qubits[1]._index
+            )
+        elif name == "cp":
             self._sim.mcmtrx(
-                operation.qubits[0:1],
+                [q._index for q in operation.qubits[0:1]],
                 [
                     1,
                     0,
                     0,
-                    math.cos(float(operation.params[0])) + 1j * math.sin(float(operation.params[0])),
+                    math.cos(float(operation.params[0]))
+                    + 1j * math.sin(float(operation.params[0])),
                 ],
-                operation.qubits[1],
+                operation.qubits[1]._index,
             )
-        elif name == 'csx':
+        elif name == "csx":
             self._sim.mcmtrx(
-                operation.qubits[0:1],
+                [q._index for q in operation.qubits[0:1]],
                 [(1 + 1j) / 2, (1 - 1j) / 2, (1 - 1j) / 2, (1 + 1j) / 2],
-                operation.qubits[1],
+                operation.qubits[1]._index,
             )
-        elif name == 'csxdg':
+        elif name == "csxdg":
             self._sim.mcmtrx(
-                operation.qubits[0:1],
+                [q._index for q in operation.qubits[0:1]],
                 [(1 - 1j) / 2, (1 + 1j) / 2, (1 + 1j) / 2, (1 - 1j) / 2],
-                operation.qubits[1],
-            )
-        elif name == 'dcx':
-            self._sim.mcx(operation.qubits[0:1], operation.qubits[1])
-            self._sim.mcx(operation.qubits[1:2], operation.qubits[0])
-        elif name == 'ccx':
-            self._sim.mcx(operation.qubits[0:2], operation.qubits[2])
-        elif name == 'ccy':
-            self._sim.mcy(operation.qubits[0:2], operation.qubits[2])
-        elif name == 'ccz':
-            self._sim.mcz(operation.qubits[0:2], operation.qubits[2])
-        elif name == 'mcx':
-            self._sim.mcx(operation.qubits[0:-1], operation.qubits[-1])
-        elif name == 'mcy':
-            self._sim.mcy(operation.qubits[0:-1], operation.qubits[-1])
-        elif name == 'mcz':
-            self._sim.mcz(operation.qubits[0:-1], operation.qubits[-1])
-        elif name == 'swap':
-            self._sim.swap(operation.qubits[0], operation.qubits[1])
-        elif name == 'iswap':
-            self._sim.iswap(operation.qubits[0], operation.qubits[1])
-        elif name == 'iswap_dg':
-            self._sim.adjiswap(operation.qubits[0], operation.qubits[1])
-        elif name == 'cswap':
+                operation.qubits[1]._index,
+            )
+        elif name == "dcx":
+            self._sim.mcx(
+                [q._index for q in operation.qubits[0:1]], operation.qubits[1]._index
+            )
+            self._sim.mcx(operation.qubits[1:2]._index, operation.qubits[0]._index)
+        elif name == "ccx":
+            self._sim.mcx(
+                [q._index for q in operation.qubits[0:2]], operation.qubits[2]._index
+            )
+        elif name == "ccy":
+            self._sim.mcy(
+                [q._index for q in operation.qubits[0:2]], operation.qubits[2]._index
+            )
+        elif name == "ccz":
+            self._sim.mcz(
+                [q._index for q in operation.qubits[0:2]], operation.qubits[2]._index
+            )
+        elif name == "mcx":
+            self._sim.mcx(
+                [q._index for q in operation.qubits[0:-1]], operation.qubits[-1]._index
+            )
+        elif name == "mcy":
+            self._sim.mcy(
+                [q._index for q in operation.qubits[0:-1]], operation.qubits[-1]._index
+            )
+        elif name == "mcz":
+            self._sim.mcz(
+                [q._index for q in operation.qubits[0:-1]], operation.qubits[-1]._index
+            )
+        elif name == "swap":
+            self._sim.swap(operation.qubits[0]._index, operation.qubits[1]._index)
+        elif name == "iswap":
+            self._sim.iswap(operation.qubits[0]._index, operation.qubits[1]._index)
+        elif name == "iswap_dg":
+            self._sim.adjiswap(operation.qubits[0]._index, operation.qubits[1]._index)
+        elif name == "cswap":
             self._sim.cswap(
-                operation.qubits[0:1], operation.qubits[1], operation.qubits[2]
+                [q._index for q in operation.qubits[0:1]],
+                operation.qubits[1]._index,
+                operation.qubits[2]._index,
             )
-        elif name == 'mcswap':
+        elif name == "mcswap":
             self._sim.cswap(
-                operation.qubits[:-2], operation.qubits[-2], operation.qubits[-1]
+                [q._index for q in operation.qubits[:-2]],
+                operation.qubits[-2]._index,
+                operation.qubits[-1]._index,
             )
-        elif name == 'reset':
+        elif name == "reset":
             qubits = operation.qubits
             for qubit in qubits:
-                if self._sim.m(qubit):
-                    self._sim.x(qubit)
-        elif name == 'measure':
+                if self._sim.m(qubit._index):
+                    self._sim.x(qubit._index)
+        elif name == "measure":
             qubits = operation.qubits
-            clbits = operation.memory
+            clbits = operation.clbits
             cregbits = (
                 operation.register
-                if hasattr(operation, 'register')
+                if hasattr(operation, "register")
                 else len(operation.qubits) * [-1]
             )
 
@@ -3737,7 +4259,7 @@ class QrackSimulator:
 
             if not self._sample_measure:
                 for index in range(len(qubits)):
-                    qubit_outcome = self._sim.m(qubits[index])
+                    qubit_outcome = self._sim.m(qubits[index]._index)
 
                     clbit = clbits[index]
                     clmask = 1 << clbit
@@ -3754,30 +4276,30 @@ class QrackSimulator:
                         self._classical_register & (~regbit)
                     ) | (qubit_outcome << cregbit)
 
-        elif name == 'bfunc':
+        elif name == "bfunc":
             mask = int(operation.mask, 16)
             relation = operation.relation
             val = int(operation.val, 16)
 
             cregbit = operation.register
-            cmembit = operation.memory if hasattr(operation, 'memory') else None
+            cmembit = operation.memory if hasattr(operation, "memory") else None
 
             compared = (self._classical_register & mask) - val
 
-            if relation == '==':
+            if relation == "==":
                 outcome = compared == 0
-            elif relation == '!=':
+            elif relation == "!=":
                 outcome = compared != 0
-            elif relation == '<':
+            elif relation == "<":
                 outcome = compared < 0
-            elif relation == '<=':
+            elif relation == "<=":
                 outcome = compared <= 0
-            elif relation == '>':
+            elif relation == ">":
                 outcome = compared > 0
-            elif relation == '>=':
+            elif relation == ">=":
                 outcome = compared >= 0
             else:
-                raise QrackError('Invalid boolean function relation.')
+                raise QrackError("Invalid boolean function relation.")
 
             # Store outcome in register and optionally memory slot
             regbit = 1 << cregbit
@@ -3811,28 +4333,30 @@ class QrackSimulator:
         measure_clbit = [clbit for clbit in sample_clbits]
 
         # Sample and convert to bit-strings
-        data = []
         if num_samples == 1:
             sample = self._sim.m_all()
             result = 0
             for index in range(len(measure_qubit)):
-                qubit = measure_qubit[index]
+                qubit = measure_qubit[index]._index
                 qubit_outcome = (sample >> qubit) & 1
                 result |= qubit_outcome << index
             measure_results = [result]
         else:
-            measure_results = self._sim.measure_shots(measure_qubit, num_samples)
+            measure_results = self._sim.measure_shots(
+                [q._index for q in measure_qubit], num_samples
+            )
 
+        data = []
         for sample in measure_results:
             for index in range(len(measure_qubit)):
                 qubit_outcome = (sample >> index) & 1
-                clbit = measure_clbit[index]
+                clbit = measure_clbit[index]._index
                 clmask = 1 << clbit
                 self._classical_memory = (self._classical_memory & (~clmask)) | (
                     qubit_outcome << clbit
                 )
 
-            data.append(hex(int(bin(self._classical_memory)[2:], 2)))
+            data.append(bin(self._classical_memory)[2:].zfill(self.num_qubits()))
 
         return data
 
@@ -3842,12 +4366,9 @@ class QrackSimulator:
                 "Before trying to run_qiskit_circuit() with QrackSimulator, you must install Qiskit!"
             )
 
-        if isinstance(experiment, QuantumCircuit):
-            experiment = convert_qiskit_circuit_to_qasm_experiment(experiment)
-
         instructions = []
-        if isinstance(experiment, QasmQobjExperiment):
-            instructions = experiment.instructions
+        if isinstance(experiment, QuantumCircuit):
+            instructions = experiment.data
         else:
             raise RuntimeError('Unrecognized "run_input" argument specified for run().')
 
@@ -3857,7 +4378,6 @@ class QrackSimulator:
         self._sample_cregbits = []
         self._sample_measure = True
         _data = []
-        shotsPerLoop = self._shots
         shotLoopMax = 1
 
         is_initializing = True
@@ -3866,21 +4386,21 @@ class QrackSimulator:
         for opcount in range(len(instructions)):
             operation = instructions[opcount]
 
-            if operation.name == 'id' or operation.name == 'barrier':
+            if operation.name == "id" or operation.name == "barrier":
                 continue
 
             if is_initializing and (
-                (operation.name == 'measure') or (operation.name == 'reset')
+                (operation.name == "measure") or (operation.name == "reset")
             ):
                 continue
 
             is_initializing = False
 
-            if (operation.name == 'measure') or (operation.name == 'reset'):
+            if (operation.name == "measure") or (operation.name == "reset"):
                 if boundary_start == -1:
                     boundary_start = opcount
 
-            if (boundary_start != -1) and (operation.name != 'measure'):
+            if (boundary_start != -1) and (operation.name != "measure"):
                 shotsPerLoop = 1
                 shotLoopMax = self._shots
                 self._sample_measure = False
@@ -3923,7 +4443,7 @@ class QrackSimulator:
                 self._apply_op(operation)
 
             if not self._sample_measure and (len(self._sample_qubits) > 0):
-                _data += [hex(int(bin(self._classical_memory)[2:], 2))]
+                _data += [bin(self._classical_memory)[2:].zfill(self.num_qubits())]
                 self._sample_qubits = []
                 self._sample_clbits = []
                 self._sample_cregbits = []
@@ -3936,3 +4456,43 @@ class QrackSimulator:
         del self._sim
 
         return _data
+
+    def get_qiskit_basis_gates():
+        return [
+            "id",
+            "u",
+            "u1",
+            "u2",
+            "u3",
+            "r",
+            "rx",
+            "ry",
+            "rz",
+            "h",
+            "x",
+            "y",
+            "z",
+            "s",
+            "sdg",
+            "sx",
+            "sxdg",
+            "p",
+            "t",
+            "tdg",
+            "cu",
+            "cu1",
+            "cu3",
+            "cx",
+            "cy",
+            "cz",
+            "ch",
+            "cp",
+            "csx",
+            "ccx",
+            "ccz",
+            "swap",
+            "iswap",
+            "cswap",
+            "reset",
+            "measure",
+        ]