Arraylias integration - Rotating frame -

docs/tutorials/dynamics_backend.rst

@@ -318,8 +318,9 @@ To enable running of the single qubit experiments, we add the following to the `
   backend. 
 - Add definitions of ``RZ`` gates as phase shifts. These instructions control the phase of the drive
   channels, as well as any control channels acting on a given qubit.
-- Add a ``CX`` gate which applies to all qubits. While this tutorial will not be utilizing it, this
-  ensures that validation steps checking that the device is fully connected will pass.
+- Add a ``CX`` gate between qubits :math:`(0, 1)` and :math:`(1, 0)`. While this tutorial will not 
+  be utilizing it, this ensures that validation steps checking that the device is fully connected 
+  will pass.
 
 .. jupyter-execute::
 
@@ -336,7 +337,7 @@ To enable running of the single qubit experiments, we add the following to the `
     target.add_instruction(XGate(), properties={(0,): None, (1,): None})
     target.add_instruction(SXGate(), properties={(0,): None, (1,): None})
 
-    target.add_instruction(CXGate())
+    target.add_instruction(CXGate(), properties={(0, 1): None, (1, 0): None})
 
     # Add RZ instruction as phase shift for drag cal
     phi = Parameter("phi")
@@ -472,11 +473,6 @@ values for the single qubit gates calibrated above.
 
     from qiskit_experiments.library import CrossResonanceHamiltonian
 
-    backend.target.add_instruction(
-        instruction=CrossResonanceHamiltonian.CRPulseGate(width=Parameter("width")), 
-        properties={(0, 1): None, (1, 0): None}
-    )
-
     cr_ham_experiment = CrossResonanceHamiltonian(
         qubits=(0, 1), 
         flat_top_widths=np.linspace(0, 5000, 17), 

qiskit_dynamics/arraylias/arraylias_state.py

@@ -0,0 +1,52 @@
+from typing import Union
+from collections.abc import Iterable
+from arraylias import numpy_alias
+from scipy.sparse import spmatrix
+from qiskit.quantum_info.operators import Operator
+from .asarray import register_to_asarray
+from .to_dense import register_to_dense
+from .to_numeric_matrix_type import register_to_numeric_matrix_type
+from .to_sparse import register_to_sparse
+from .matmul import register_matmul
+from .rmatmul import register_rmatmul
+from .multiply import register_multiply
+
+from ..array import Array
+
+
+DYNAMICS_ALIAS = numpy_alias()
+
+# Set qiskit_dynamics.array.Array to be dispatched to numpy
+DYNAMICS_ALIAS.register_type(Array, "numpy")
+
+# register required custom versions of functions for sparse type here
+DYNAMICS_ALIAS.register_type(spmatrix, lib="scipy_sparse")
+
+try:
+    from jax.experimental.sparse import BCOO
+
+    # register required custom versions of functions for BCOO type here
+    DYNAMICS_ALIAS.register_type(BCOO, lib="jax_sparse")
+except ImportError:
+    pass
+
+# register required custom versions of functions for Operator type here
+DYNAMICS_ALIAS.register_type(Operator, lib="operator")
+
+# register required custom versions of functions for List type here
+# need to discuss registering List type because the coverage of List is too broad.
+DYNAMICS_ALIAS.register_type(list, lib="list")
+
+
+register_to_asarray(alias=DYNAMICS_ALIAS)
+register_to_dense(alias=DYNAMICS_ALIAS)
+register_to_numeric_matrix_type(alias=DYNAMICS_ALIAS)
+register_to_sparse(alias=DYNAMICS_ALIAS)
+register_matmul(alias=DYNAMICS_ALIAS)
+register_multiply(alias=DYNAMICS_ALIAS)
+register_rmatmul(alias=DYNAMICS_ALIAS)
+
+DYNAMICS_NUMPY = DYNAMICS_ALIAS()
+
+
+ArrayLike = Union[DYNAMICS_ALIAS.registered_types()]

qiskit_dynamics/arraylias/asarray.py

@@ -0,0 +1,32 @@
+import numpy as np
+from scipy.sparse import csr_matrix, issparse
+
+
+def register_to_asarray(alias):
+    @alias.register_function(lib="scipy_sparse", path="asarray")
+    def _(arr):
+        if issparse(arr):
+            return arr
+        return csr_matrix(arr)
+
+    @alias.register_function(lib="list", path="asarray")
+    def _(arr):
+        if len(arr) == 0 or isinstance(arr[0], (list, tuple)):
+            return np.asarray(arr)
+        return alias(like=arr[0]).asarray([alias().asarray(sub_arr) for sub_arr in arr])
+
+    @alias.register_fallback(path="asarray")
+    def _(arr):
+        return np.asarray(arr)
+
+    try:
+        from jax.experimental.sparse import BCOO
+
+        @alias.register_function(lib="jax_sparse", path="asarray")
+        def _(arr):
+            if type(arr).__name__ == "BCOO":
+                return arr
+            return BCOO.fromdense(arr)
+
+    except ImportError:
+        pass

qiskit_dynamics/arraylias/matmul.py

@@ -0,0 +1,17 @@
+def register_matmul(alias):
+    @alias.register_function(lib="scipy_sparse", path="matmul")
+    def _(x, y):
+        return x * y
+
+    try:
+        from jax.experimental import sparse as jsparse
+        import jax.numpy as jnp
+
+        jsparse_matmul = jsparse.sparsify(jnp.matmul)
+
+        @alias.register_function(lib="jax_sparse", path="matmul")
+        def _(x, y):
+            return jsparse_matmul(x, y)
+
+    except:
+        pass

qiskit_dynamics/arraylias/multiply.py

@@ -0,0 +1,17 @@
+def register_multiply(alias):
+    @alias.register_function(lib="scipy_sparse", path="multiply")
+    def _(x, y):
+        return x.multiply(y)
+
+    try:
+        from jax.experimental import sparse as jsparse
+        import jax.numpy as jnp
+
+        jsparse_multiply = jsparse.sparsify(jnp.multiply)
+
+        @alias.register_function(lib="jax_sparse", path="multiply")
+        def _(x, y):
+            return jsparse_multiply(x, y)
+
+    except:
+        pass

qiskit_dynamics/arraylias/rmatmul.py

@@ -0,0 +1,28 @@
+import numpy as np
+
+
+def register_rmatmul(alias):
+    @alias.register_function(lib="numpy", path="rmatmul")
+    def _(x, y):
+        return np.matmul(y, x)
+
+    @alias.register_function(lib="scipy_sparse", path="rmatmul")
+    def _(x, y):
+        return y * x
+
+    try:
+        from jax.experimental import sparse as jsparse
+        import jax.numpy as jnp
+
+        jsparse_matmul = jsparse.sparsify(jnp.matmul)
+
+        @alias.register_function(lib="jax", path="rmatmul")
+        def _(x, y):
+            return jnp.matmul(y, x)
+
+        @alias.register_function(lib="jax_sparse", path="rmatmul")
+        def _(x, y):
+            return jsparse_matmul(y, x)
+
+    except:
+        pass

qiskit_dynamics/arraylias/to_dense.py

@@ -0,0 +1,38 @@
+import numpy as np
+
+
+def register_to_dense(alias):
+    @alias.register_default(path="to_dense")
+    def _(op):
+        if op is None:
+            return None
+        return op
+
+    @alias.register_function(lib="numpy", path="to_dense")
+    def _(op):
+        return op
+
+    try:
+
+        @alias.register_function(lib="jax", path="to_dense")
+        def _(op):
+            return op
+
+        @alias.register_function(lib="jax_sparse", path="to_dense")
+        def _(op):
+            return op.todense()
+
+    except:
+        pass
+
+    @alias.register_function(lib="scipy_sparse", path="to_dense")
+    def _(op):
+        return op.toarray()
+
+    @alias.register_fallback(path="to_dense")
+    def _(op):
+        return np.asarray(op)
+
+    @alias.register_function(lib="list", path="to_dense")
+    def _(op):
+        return alias().asarray([alias().to_dense(sub_op) for sub_op in op])

qiskit_dynamics/arraylias/to_numeric_matrix_type.py

@@ -0,0 +1,47 @@
+from scipy.sparse import spmatrix
+from qiskit_dynamics.type_utils import isinstance_qutip_qobj
+
+
+def register_to_numeric_matrix_type(alias):
+    @alias.register_default(path="to_numeric_matrix_type")
+    def _(op):
+        if op is None:
+            return None
+        if isinstance_qutip_qobj(op):
+            return alias().to_sparse(op.data)
+        return op
+
+    @alias.register_function(lib="numpy", path="to_numeric_matrix_type")
+    def _(op):
+        return op
+
+    @alias.register_function(lib="operator", path="to_numeric_matrix_type")
+    def _(op):
+        return alias().to_dense(op)
+
+    try:
+
+        @alias.register_function(lib="jax", path="to_numeric_matrix_type")
+        def _(op):
+            return op
+
+        @alias.register_function(lib="jax_sparse", path="to_numeric_matrix_type")
+        def _(op):
+            return op
+
+    except:
+        pass
+
+    @alias.register_function(lib="scipy_sparse", path="to_numeric_matrix_type")
+    def _(op):
+        return op
+
+    @alias.register_function(lib="list", path="to_numeric_matrix_type")
+    def _(op):
+        if isinstance(op[0], spmatrix) or isinstance_qutip_qobj(op[0]):
+            return [alias().to_sparse(sub_op) for sub_op in op]
+        return alias().asarray([alias().to_dense(sub_op) for sub_op in op])
+
+    @alias.register_fallback(path="to_numeric_matrix_type")
+    def _(op):
+        return op

qiskit_dynamics/arraylias/to_sparse.py

@@ -0,0 +1,52 @@
+import numpy as np
+from scipy.sparse import csr_matrix
+from qiskit_dynamics.type_utils import isinstance_qutip_qobj
+
+
+def register_to_sparse(alias):
+    @alias.register_default(path="to_sparse")
+    def _(op):
+        if op is None:
+            return None
+        if isinstance_qutip_qobj(op):
+            return op.data
+        return op
+
+    @alias.register_function(lib="numpy", path="to_sparse")
+    def _(op):
+        if op.ndim < 3:
+            return csr_matrix(op)
+        return np.array([csr_matrix(sub_op) for sub_op in op])
+
+    try:
+        from jax.experimental.sparse import BCOO
+
+        @alias.register_function(lib="jax", path="to_sparse")
+        def _(op):
+            return BCOO.fromdense(op)
+
+        @alias.register_function(lib="jax_sparse", path="to_sparse")
+        def _(op):
+            return op
+
+    except ImportError:
+        pass
+
+    @alias.register_function(lib="scipy_sparse", path="to_sparse")
+    def _(op):
+        return op
+
+    @alias.register_fallback(path="to_sparse")
+    def _(op):
+        return csr_matrix(op)
+
+    @alias.register_function(lib="list", path="to_sparse")
+    def _(op):
+        try:
+            import jax.numpy as jnp
+
+            if isinstance(op[0], jnp.ndarray):
+                return BCOO.fromdense(op)
+        except ImportError:
+            return np.array([csr_matrix(sub_op) for sub_op in op])
+        return np.array([csr_matrix(sub_op) for sub_op in op])