diff --git a/qcsys/devices/__init__.py b/qcsys/devices/__init__.py
index 2c8dffe..7b85f1b 100644
--- a/qcsys/devices/__init__.py
+++ b/qcsys/devices/__init__.py
@@ -8,8 +8,6 @@
 from .kno import *
 from .transmon import *
 from .tunable_transmon import *
-from .transmon_single_charge_basis import *
-from .squid_transmon import *
 from .fluxonium import *
 from .ats import *
 from .ideal_qubit import *
diff --git a/qcsys/devices/base.py b/qcsys/devices/base.py
index e3cfae1..beea8a5 100644
--- a/qcsys/devices/base.py
+++ b/qcsys/devices/base.py
@@ -19,6 +19,7 @@
 class BasisTypes(str, Enum):
     fock = "fock"
     charge = "charge"
+    single_charge = "single_charge"
 
     @classmethod
     def from_str(cls, string: str):
diff --git a/qcsys/devices/drive.py b/qcsys/devices/drive.py
index 7b23381..7563acd 100644
--- a/qcsys/devices/drive.py
+++ b/qcsys/devices/drive.py
@@ -7,6 +7,7 @@
 from jax import tree_util, Array
 from jax import config
 import jax.numpy as jnp
+import jaxquantum as jqt
 
 config.update("jax_enable_x64", True)
 
@@ -31,20 +32,20 @@ def label(self):
     def ops(self):
         return self.common_ops()
 
-    def common_ops(self) -> Dict[str, Array]:
+    def common_ops(self) -> Dict[str, jqt.Qarray]:
         ops = {}
 
         M_max = self.M_max
 
         # Construct M = ∑ₘ m|m><m| operator in drive charge basis
-        ops["M"] = jnp.diag(jnp.arange(-M_max, M_max + 1))
+        ops["M"] = jqt.jnp2jqt(jnp.diag(jnp.arange(-M_max, M_max + 1)))
 
         # Construct Id = ∑ₘ|m><m| in the drive charge basis
-        ops["Id_drive"] = jnp.identity(2 * M_max + 1)
+        ops["id"] = jqt.jnp2jqt(jnp.identity(2 * M_max + 1))
 
         # Construct M₊ ≡ exp(iθ) and M₋ ≡ exp(-iθ) operators for drive
-        ops["M-"] = jnp.eye(2 * M_max + 1, k=1)
-        ops["M+"] = jnp.eye(2 * M_max + 1, k=-1)
+        ops["M-"] = jqt.jnp2jqt(jnp.eye(2 * M_max + 1, k=1))
+        ops["M+"] = jqt.jnp2jqt(jnp.eye(2 * M_max + 1, k=-1))
 
         # Construct cos(θ) ≡ 1/2 * [M₊ + M₋] = 1/2 * ∑ₘ|m+1><m| + h.c
         ops["cos(θ)"] = 0.5 * (ops["M+"] + ops["M-"])
@@ -54,8 +55,8 @@ def common_ops(self) -> Dict[str, Array]:
 
         # Construct more general drive operators cos(kθ) and sin(kθ)
         for k in range(2, M_max + 1):
-            ops[f"M_+{k}"] = jnp.eye(2 * M_max + 1, k=-k)
-            ops[f"M_-{k}"] = jnp.eye(2 * M_max + 1, k=k)
+            ops[f"M_+{k}"] = jqt.jnp2jqt(jnp.eye(2 * M_max + 1, k=-k))
+            ops[f"M_-{k}"] = jqt.jnp2jqt(jnp.eye(2 * M_max + 1, k=k))
             ops[f"cos({k}θ)"] = 0.5 * (ops[f"M_+{k}"] + ops[f"M_-{k}"])
             ops[f"sin({k}θ)"] = -0.5j * (ops[f"M_+{k}"] - ops[f"M_-{k}"])
 
diff --git a/qcsys/devices/ideal_qubit.py b/qcsys/devices/ideal_qubit.py
index 7f33730..7b81244 100644
--- a/qcsys/devices/ideal_qubit.py
+++ b/qcsys/devices/ideal_qubit.py
@@ -4,7 +4,7 @@
 from jax import config
 import jaxquantum as jqt
 
-from .base import Device
+from .base import Device, BasisTypes, HamiltonianTypes
 
 
 config.update("jax_enable_x64", True)
@@ -16,8 +16,16 @@ class IdealQubit(Device):
     Ideal qubit Device.
     """
 
+    @classmethod
+    def param_validation(cls, N, N_pre_diag, params, hamiltonian, basis):
+        """ This can be overridden by subclasses."""
+        assert basis == BasisTypes.fock, "IdealQubit is a two-level system defined in the Fock basis." 
+        assert hamiltonian == HamiltonianTypes.full, "IdealQubit requires a full Hamiltonian."
+        assert N == N_pre_diag == 2, "IdealQubit is a two-level system."
+        assert "ω" in params, "IdealQubit requires a frequency parameter 'ω'."
+
     def common_ops(self):
-        """ Written in the linear basis. """
+        """Written in the linear basis."""
         ops = {}
 
         assert self.N_pre_diag == 2
@@ -25,21 +33,23 @@ def common_ops(self):
 
         N = self.N_pre_diag
         ops["id"] = jqt.identity(N)
-        ops["sigma_z"] = jqt.sigmaz()
-        ops["sigma_x"] = jqt.sigmax()
+        ops["sigmaz"] = jqt.sigmaz()
+        ops["sigmax"] = jqt.sigmax()
+        ops["sigmay"] = jqt.sigmay()
+        ops["sigmam"] = jqt.sigmam()
+        ops["sigmap"] = jqt.sigmap()
 
         return ops
 
     def get_linear_ω(self):
         """Get frequency of linear terms."""
-        return self.params["frequency"]
+        return self.params["ω"]
 
     def get_H_linear(self):
         """Return linear terms in H."""
         w = self.get_linear_ω()
-        return w * self.linear_ops["sigma_z"]
+        return (w / 2) * self.linear_ops["sigma_z"]
 
     def get_H_full(self):
         """Return full H in linear basis."""
-        H = self.get_H_linear()
-        return H
\ No newline at end of file
+        return self.get_H_linear()
\ No newline at end of file
diff --git a/qcsys/devices/kno.py b/qcsys/devices/kno.py
index 3d707d9..7708823 100644
--- a/qcsys/devices/kno.py
+++ b/qcsys/devices/kno.py
@@ -1,10 +1,11 @@
 """ Kerr Nonlinear Oscillator """
+
 from flax import struct
 from jax import config
 import jaxquantum as jqt
 import jax.numpy as jnp
 
-from qcsys.devices.base import Device
+from qcsys.devices.base import Device, BasisTypes, HamiltonianTypes
 
 config.update("jax_enable_x64", True)
 
@@ -16,9 +17,12 @@ class KNO(Device):
     """
 
     @classmethod
-    def create(cls, N, params, label=0, use_linear=False):
-        return cls(N, params, label, use_linear)
-
+    def param_validation(cls, N, N_pre_diag, params, hamiltonian, basis):
+        """ This can be overridden by subclasses."""
+        assert basis == BasisTypes.fock, "Kerr Nonlinear Oscillator must be defined in the Fock basis." 
+        assert hamiltonian == HamiltonianTypes.full, "Kerr Nonlinear Oscillator uses a full Hamiltonian."
+        assert "ω" in params and "α" in params, "Kerr Nonlinear Oscillator requires frequency 'ω' and anharmonicity 'α' as parameters."
+        
     def common_ops(self):
         ops = {}
 
diff --git a/qcsys/devices/squid_transmon.py b/qcsys/devices/squid_transmon.py
deleted file mode 100644
index a8f92b3..0000000
--- a/qcsys/devices/squid_transmon.py
+++ /dev/null
@@ -1,133 +0,0 @@
-""" SQUID Transmon.
-
-TODO: this needs to be updated to work with standard truncation scheme.
-
-"""
-
-from flax import struct
-from jax import config
-import jaxquantum as jqt
-import jax.numpy as jnp
-import jax.scipy as jsp
-
-from qcsys.devices.base import Device
-
-config.update("jax_enable_x64", True)
-
-
-@struct.dataclass
-class SymmetricSQUIDTransmon(Device):
-    """
-    Flux-Tunable Symmetric SQUID Transmon Device, written in single-charge
-    basis. Here, the two junctions Ej1 = Ej2 = Ej are assumed to be identical.
-
-    Required params:
-    - Ec: Charging Energy
-    - Ej: Josephson Energy
-    - ng: Gate offset charge
-    - N_max_charge: Maximum number of charge levels to consider
-
-    """
-
-    N_max_charge: int = struct.field(pytree_node=False)
-
-    @classmethod
-    def create(cls, N, N_max_charge, params, label=0, use_linear=False):
-        return cls(N, params, label, use_linear, N_max_charge)
-
-    def common_ops(self):
-        """
-        Operators defined in the single charge basis.
-        """
-        ops = {}
-
-        # Ensure truncation is valid
-        assert self.N <= 2 * self.N_max_charge + 1
-
-        ops["n"] = self.build_n_op()
-        ops["cos(φ)"] = self.build_cos_phi_op()
-        ops["cos(φ/2)"] = self.build_cos_phi_2_op()
-        ops["sin(φ/2)"] = self.build_sin_phi_2_op()
-        ops["H_charge"] = self.build_H_charge_op()
-        return ops
-
-    def build_n_op(self):
-        # We define n = ∑ₙ n|n⟩⟨n| in the single charge basis. Here n counts electrons, not Cooper pairs.
-        return jnp.diag(jnp.arange(-self.N_max_charge, self.N_max_charge + 1))
-
-    def build_cos_phi_op(self):
-        # We define cos(φ) = 1/2 * ∑ₙ|n⟩⟨n+2| + h.c. in the single charge basis
-        return 0.5 * (
-            jnp.eye(2 * self.N_max_charge + 1, k=2)
-            + jnp.eye(2 * self.N_max_charge + 1, k=-2)
-        )
-
-    def build_cos_phi_2_op(self):
-        # We define cos(φ/2) = 1/2 * ∑ₙ|n⟩⟨n+1| + h.c. in the single charge basis
-        return 0.5 * (
-            jnp.eye(2 * self.N_max_charge + 1, k=1)
-            + jnp.eye(2 * self.N_max_charge + 1, k=-1)
-        )
-
-    def build_sin_phi_2_op(self):
-        # We define sin(φ/2) = i/2 * ∑ₙ|n⟩⟨n+1| + h.c. in the single charge basis
-        return 0.5j * (
-            jnp.eye(2 * self.N_max_charge + 1, k=1)
-            - jnp.eye(2 * self.N_max_charge + 1, k=-1)
-        )
-
-    def build_H_charge_op(self):
-        """
-        Construct the "charge" (i.e. the "Ec" part) of the Hamiltonian in the single charge basis.
-        Defined as H = Ec (n - 2ng)² where n counts the number of electrons, not Cooper pairs.
-        """
-
-        # (n - 2*ng)
-        n_minus_ng_array = jnp.arange(
-            -self.N_max_charge, self.N_max_charge + 1
-        ) - 2 * self.params["ng"] * jnp.ones(2 * self.N_max_charge + 1)
-
-        return jnp.diag(self.params["Ec"] * n_minus_ng_array**2)
-
-    @property
-    def Ej_eff(self):
-        return 2 * self.params["Ej"] * jnp.cos(self.params["phi_ext"] / 2)
-
-    @property
-    def phi_zpf(self):
-        """Return Phase ZPF"""
-        return (2 * self.params["Ec"] / self.Ej_eff) ** (0.25)
-
-    @property
-    def n_zpf(self):
-        """Return charge ZPF"""
-        return (self.Ej_eff / (32.0 * self.params["Ec"])) ** (0.25)
-
-    def get_linear_ω(self):
-        """Get frequency of linear terms"""
-        return jnp.sqrt(8 * self.params["Ec"] * self.Ej_eff)
-
-    def get_H_linear(self):
-        raise NotImplemented(
-            "No linear oscillator basis for single charge transmon. Set _use_linear = False."
-        )
-
-    def get_H_full(self):
-        """
-        Return full Hamiltonian H = Ec (n - 2ng)² - 2Ej cos(φext/2) cos(φ) in the single charge basis. Using
-        Eq. (5.36) of Kyle Serniak's thesis, we have H = Ec ∑ₙ(n - 2*ng) |n⟩⟨n| - Ej * cos(φext/2) * ∑ₙ|n⟩⟨n+2| + h.c
-        where now n counts the number of electrons, not Cooper pairs.
-        """
-        phi_ext = self.params["phi_ext"]
-        return (
-            self.linear_ops["H_charge"]
-            - 2 * self.params["Ej"] * jnp.cos(phi_ext / 2) * self.linear_ops["cos(φ)"]
-        )
-
-    def get_op_in_H_eigenbasis(self, op):
-        """
-        We overwrite this function to effectively truncate to the first N levels out of N_max_charge
-        """
-        evecs = self.eig_systems["vecs"][:, : self.N]
-        op = jnp.dot(jnp.conjugate(evecs.transpose()), jnp.dot(op, evecs))
-        return op
diff --git a/qcsys/devices/transmon.py b/qcsys/devices/transmon.py
index 6302d8a..c38d85e 100644
--- a/qcsys/devices/transmon.py
+++ b/qcsys/devices/transmon.py
@@ -25,7 +25,11 @@ def param_validation(cls, N, N_pre_diag, params, hamiltonian, basis):
         elif hamiltonian == HamiltonianTypes.truncated:
             assert basis == BasisTypes.fock, "Truncated Hamiltonian only works with Fock basis."
         elif hamiltonian == HamiltonianTypes.full:
-            assert basis == BasisTypes.charge, "Full Hamiltonian only works with charge basis."
+            assert basis in [BasisTypes.charge, BasisTypes.single_charge], "Full Hamiltonian only works with Cooper pair charge or single-electron charge bases."
+        
+        # Set the gate offset charge to zero if not provided
+        if "ng" not in params:
+            params["ng"] = 0.0
         
         assert (N_pre_diag - 1) % 2 == 0, "N_pre_diag must be odd."
 
@@ -44,11 +48,37 @@ def common_ops(self):
             ops["n"] = 1j * self.n_zpf() * (ops["a_dag"] - ops["a"])
 
         elif self.basis == BasisTypes.charge:
+            """
+            Here H = 4 * Ec (n - ng)² - Ej cos(φ) in the Cooper pair charge basis. 
+            """
             ops["id"] = jqt.identity(N)
             ops["cos(φ)"] = 0.5*(jqt.jnp2jqt(jnp.eye(N,k=1) + jnp.eye(N,k=-1)))
+            ops["sin(φ)"] = 0.5j*(jqt.jnp2jqt(jnp.eye(N,k=1) - jnp.eye(N,k=-1)))
+            n_max = (N - 1) // 2
+            ops["n"] = jqt.jnp2jqt(jnp.diag(jnp.arange(-n_max, n_max + 1)))
+
+            n_minus_ng_array = jnp.arange(-n_max, n_max + 1) - self.params["ng"] * jnp.ones(N)
+            ops["H_charge"] = jqt.jnp2jqt(jnp.diag(4 * self.params["Ec"] * n_minus_ng_array**2))
+
+        elif self.basis == BasisTypes.single_charge:
+            """
+            Here H = Ec (n - 2ng)² - Ej cos(φ) in the single-electron charge basis. Using Eq. (5.36) of Kyle Serniak's
+            thesis, we have H = Ec ∑ₙ(n - 2*ng) |n⟩⟨n| - Ej/2 * ∑ₙ|n⟩⟨n+2| + h.c where n counts the number of electrons, 
+            not Cooper pairs. Note, we use 2ng instead of ng to match the gate offset charge convention of the transmon 
+            (as done in Kyle's thesis).
+            """
             n_max = (N - 1) // 2
+
+            ops["id"] = jqt.identity(N)
+            ops["cos(φ)"] = 0.5*(jqt.jnp2jqt(jnp.eye(N,k=2) + jnp.eye(N,k=-2)))
+            ops["sin(φ)"] = 0.5j*(jqt.jnp2jqt(jnp.eye(N,k=2) - jnp.eye(N,k=-2)))
+            ops["cos(φ/2)"] = 0.5*(jqt.jnp2jqt(jnp.eye(N,k=1) + jnp.eye(N,k=-1)))
+            ops["sin(φ/2)"] = 0.5j*(jqt.jnp2jqt(jnp.eye(N,k=1) - jnp.eye(N,k=-1)))
             ops["n"] = jqt.jnp2jqt(jnp.diag(jnp.arange(-n_max, n_max + 1)))
 
+            n_minus_ng_array = jnp.arange(-n_max, n_max + 1) - 2 * self.params["ng"] * jnp.ones(N)
+            ops["H_charge"] = jqt.jnp2jqt(jnp.diag(self.params["Ec"] * n_minus_ng_array**2))
+
         return ops
 
     @property
@@ -74,10 +104,7 @@ def get_H_linear(self):
 
     def get_H_full(self):
         """Return full H in specified basis."""
-        
-        cos_phi_op = self.original_ops["cos(φ)"]
-        n_op = self.original_ops["n"]
-        return 4*self.params["Ec"]*n_op@n_op - self.Ej * cos_phi_op
+        return self.original_ops["H_charge"] - self.Ej * self.original_ops["cos(φ)"]
     
     def get_H_truncated(self):
         """Return truncated H in specified basis."""
@@ -95,7 +122,6 @@ def _get_H_in_original_basis(self):
             return self.get_H_full()
         elif self.hamiltonian == HamiltonianTypes.truncated:
             return self.get_H_truncated()
-    
 
     def potential(self, phi):
         """Return potential energy for a given phi."""
@@ -115,6 +141,8 @@ def calculate_wavefunctions(self, phi_vals):
 
         if self.basis == BasisTypes.fock:
             return super().calculate_wavefunctions(phi_vals)
+        elif self.basis == BasisTypes.single_charge:
+            raise NotImplementedError("Wavefunctions for single charge basis not yet implemented.")
         elif self.basis == BasisTypes.charge:
             phi_vals = jnp.array(phi_vals)
 
diff --git a/qcsys/devices/transmon_single_charge_basis.py b/qcsys/devices/transmon_single_charge_basis.py
deleted file mode 100644
index f1f6862..0000000
--- a/qcsys/devices/transmon_single_charge_basis.py
+++ /dev/null
@@ -1,118 +0,0 @@
-""" Transmon.
-
-TODO: this needs to be updated to work with standard truncation scheme.
-
-"""
-
-from flax import struct
-from jax import config
-import jaxquantum as jqt
-import jax.numpy as jnp
-import jax.scipy as jsp
-
-from qcsys.devices.base import Device
-
-config.update("jax_enable_x64", True)
-
-
-@struct.dataclass
-class SingleChargeTransmon(Device):
-    """
-    Offset-Charge Sensitive Transmon Device, written in single-charge basis.
-
-    Required params:
-    - Ec: Charging Energy
-    - Ej: Josephson Energy
-    - ng: Gate offset charge
-    - N_max_charge: Maximum number of charge levels to consider
-
-    """
-
-    N_max_charge: int = struct.field(pytree_node=False)
-
-    @classmethod
-    def create(cls, N, N_max_charge, params, label=0, use_linear=False):
-        return cls(N, params, label, use_linear, N_max_charge)
-
-    def common_ops(self):
-        """
-        Operators defined in the single charge basis.
-        """
-        ops = {}
-
-        # Ensure truncation is valid
-        assert self.N <= 2 * self.N_max_charge + 1
-
-        ops["n"] = self.build_n_op()
-        ops["cos(φ)"] = self.build_cos_phi_op()
-        ops["cos(φ/2)"] = self.build_cos_phi_2_op()
-        ops["sin(φ/2)"] = self.build_sin_phi_2_op()
-        return ops
-
-    def build_n_op(self):
-        # We define n = ∑ₙ n|n⟩⟨n| in the single charge basis. Here n counts electrons, not Cooper pairs.
-        return jnp.diag(jnp.arange(-self.N_max_charge, self.N_max_charge + 1))
-
-    def build_cos_phi_op(self):
-        # We define cos(φ) = 1/2 * ∑ₙ|n⟩⟨n+2| + h.c. in the single charge basis
-        return 0.5 * (
-            jnp.eye(2 * self.N_max_charge + 1, k=2)
-            + jnp.eye(2 * self.N_max_charge + 1, k=-2)
-        )
-
-    def build_cos_phi_2_op(self):
-        # We define cos(φ/2) = 1/2 * ∑ₙ|n⟩⟨n+1| + h.c. in the single charge basis
-        return 0.5 * (
-            jnp.eye(2 * self.N_max_charge + 1, k=1)
-            + jnp.eye(2 * self.N_max_charge + 1, k=-1)
-        )
-
-    def build_sin_phi_2_op(self):
-        # We define sin(φ/2) = i/2 * ∑ₙ|n⟩⟨n+1| + h.c. in the single charge basis
-        return 0.5j * (
-            jnp.eye(2 * self.N_max_charge + 1, k=1)
-            - jnp.eye(2 * self.N_max_charge + 1, k=-1)
-        )
-
-    @property
-    def phi_zpf(self):
-        """Return Phase ZPF"""
-        return (2 * self.params["Ec"] / self.params["Ej"]) ** (0.25)
-
-    @property
-    def n_zpf(self):
-        """Return charge ZPF"""
-        return (self.params["Ej"] / (32.0 * self.params["Ec"])) ** (0.25)
-
-    def get_linear_ω(self):
-        """Get frequency of linear terms"""
-        return jnp.sqrt(8 * self.params["Ec"] * self.params["Ej"])
-
-    def get_H_linear(self):
-        raise NotImplemented(
-            "No linear oscillator basis for single charge transmon. Set _use_linear = False."
-        )
-
-    def get_H_full(self):
-        """
-        Return full Hamiltonian H = Ec (n - 2ng)² - Ej cos(φ) in the single charge basis. Using Eq. (5.36)
-        of Kyle Serniak's thesis, we have H = Ec ∑ₙ(n - 2*ng) |n⟩⟨n| - Ej/2 * ∑ₙ|n⟩⟨n+2| + h.c where now n
-        counts the number of electrons, not Cooper pairs.
-        """
-        # (n - 2*ng)
-        n_minus_ng_array = jnp.arange(
-            -self.N_max_charge, self.N_max_charge + 1
-        ) - 2 * self.params["ng"] * jnp.ones(2 * self.N_max_charge + 1)
-
-        return (
-            jnp.diag(self.params["Ec"] * n_minus_ng_array**2)
-            - self.params["Ej"] * self.linear_ops["cos(φ)"]
-        )
-
-    def get_op_in_H_eigenbasis(self, op):
-        """
-        We overwrite this function to effectively truncate to the first N levels out of N_max_charge
-        """
-        evecs = self.eig_systems["vecs"][:, : self.N]
-        op = jnp.dot(jnp.conjugate(evecs.transpose()), jnp.dot(op, evecs))
-        return op
diff --git a/tutorials/6-floquet.ipynb b/tutorials/6-floquet.ipynb
new file mode 100644
index 0000000..3a44e97
--- /dev/null
+++ b/tutorials/6-floquet.ipynb
@@ -0,0 +1,278 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 1 - Imports"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%load_ext autoreload\n",
+    "%autoreload 2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from jax import jit, vmap, config\n",
+    "import jaxquantum as jqt\n",
+    "import qcsys as qs\n",
+    "import jax.numpy as jnp\n",
+    "from tqdm import tqdm\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "config.update(\"jax_enable_x64\", True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 2 - Set Up Bare Qubit"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In this tutorial, we will demonstrate how to analyze a driven qubit using Floquet theory. For the bare qubit, here we will use a Kerr nonlinear oscillator with a Hamiltonian of the form\n",
+    "$$\n",
+    "\\hat{H}_0 = \\omega \\hat{a}^\\dagger \\hat{a} + \\frac{\\alpha}{2}\\hat{a}^\\dagger{}^2 \\hat{a}^2\n",
+    "$$\n",
+    "where $\\omega$ and $\\alpha$ are the frequency and anharmonicity, respectively. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Array([ 0.  ,  5.  ,  9.85, 14.55, 19.1 ], dtype=float64)"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "qubit = qs.KNO.create(N=5, params={\"ω\": 5, \"α\": -0.15})\n",
+    "bare_ω_ge = qubit.eig_systems['vals'][1] - qubit.eig_systems['vals'][0]\n",
+    "qubit.eig_systems['vals']"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 3 - Create Floquet qubit"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's consider a \"charge\"-like drive on the Kerr nonlinear oscillator above. Specifically, we will consider a time-dependent Hamiltonian of the form\n",
+    "$$\n",
+    "\\hat{H}(t) = \\hat{H}_0 + \\Omega(\\hat{a} + \\hat{a}^\\dagger)\\cos(\\omega_d t),\n",
+    "$$\n",
+    "where $\\Omega$ is the effective drive amplitude and $\\omega_d$ is the drive frequency. This Hamiltonian is time-periodic with $\\hat{H}(t) = \\hat{H}(t + T)$, where $T = 2\\pi/\\omega_d$. Therefore, we can study this system in the Floquet basis by making use of the Floquet theorem. Specifically,  we know that the above Hamiltonian admits a set of quasi-energies and Floquet modes that are solutions of the Schrodinger equation:\n",
+    "$$\n",
+    "|\\psi_\\alpha(t)\\rangle = e^{-i\\epsilon_\\alpha t/\\hbar}\\,\\, |u_\\alpha(t)\\rangle,\n",
+    "$$\n",
+    "where $\\epsilon_\\alpha$ are called the quasi-energies (unique mod. $\\hbar \\omega_d)$ and $|u_\\alpha\\rangle$ are called the Floquet modes, which are time-periodic: $|u_\\alpha(t)\\rangle = |u_\\alpha(t + T)\\rangle$. We can rewrite the Schrodinger equation:\n",
+    "$$\n",
+    "\\Big[\\hat{H}(t) - i\\partial_t\\Big] |u_\\alpha(t)\\rangle = \\epsilon_\\alpha |u_\\alpha(t)\\rangle\n",
+    "$$\n",
+    "\n",
+    "and the Hamiltonian on the right hand side is known as the Floquet Hamiltonian $\\hat{H}_F \\equiv H(t) - i\\partial / \\partial t$. \n",
+    "\n",
+    "\n",
+    "-----------------\n",
+    "\n",
+    "\n",
+    "In this tutorial, we use a generalized version of the Sambe/Shirley extended Hilbert space formalism to treat the Floquet Hamiltonian. Specifically, we can write the phase of the drive as $\\theta(t) = \\omega_d t$ here. We then can write the Floquet Hamiltonian above as:\n",
+    "$$\n",
+    "\\hat{H}_F = \\hat{H}_0 + \\Omega(\\hat{a} + \\hat{a}^\\dagger)\\cos(\\theta(t)) -i\\omega_d \\partial_\\theta\n",
+    "$$\n",
+    "\n",
+    "In the extended Hilbert space approach to Floquet theory, our next step is to rewrite $\\hat{H}_F$ in terms of its Fourier components, and then reorganize the resulting Hamiltonian into an infinite-dimensional matrix. We then truncate to a finite number of Fourier components to get the Floquet Hamiltonian in the expanded space. However, a shortcut to doing this is to realize that this transformation is equivalent to simply promoting $\\theta(t)$ to a $2\\pi$-periodic quantum degree of freedom $\\theta(t) \\to \\hat{\\vartheta}$. The extended Hilbert space is then the tensor product of the bare qubit Hilbert space and the fictitious one associated with this new degree of freedom. Thus: \n",
+    "$$\n",
+    "\\hat{H}_F = \\hat{H}_0 + \\Omega(\\hat{a} + \\hat{a}^\\dagger)\\cos(\\hat{\\vartheta}) + \\omega_d \\hat{m},\n",
+    "$$\n",
+    "where we also introduce $\\hat{m}$ as the conjugate variable to $\\hat{\\vartheta}$, satisfying $[\\hat{\\vartheta}, \\hat{m}] = i$. Numerically, $\\hat{\\vartheta}$ and $\\hat{m}$ are constructed just like the phase and charge operators for a transmon qubit, i.e. $\\hat{m} = \\sum_m m |m\\rangle\\langle m|$ and $\\cos(\\hat{\\vartheta}) = \\sum_m |m+1\\rangle\\langle m| + {\\rm h.c.}$\n",
+    "\n",
+    "\n",
+    "Within the framework of `qcsys`, we can now interpret the Floquet Hamiltonian $\\hat{H}_F$ as a coupled quantum system. The bare qubit has a Hamiltonian $\\hat{H}_0$, and the \"bare drive\" is an infinite ladder $\\omega_d \\hat{m}$. The operator coupling the qubit and the drive is the drive Hamiltonian $\\Omega(\\hat{a} + \\hat{a}^\\dagger)\\otimes\\cos(\\hat{\\vartheta})$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def create_H_F(Ω, ωd):\n",
+    "    # The drive has 2*M_max + 1 levels\n",
+    "    drive = qs.Drive.create(M_max=5, ωd=ωd)\n",
+    "\n",
+    "    # Define system\n",
+    "    coupling = jqt.tensor(Ω * (qubit.ops[\"a\"] + qubit.ops[\"a_dag\"]), drive.ops[\"cos(θ)\"])\n",
+    "    system = qs.System.create([qubit, drive], [coupling])\n",
+    "\n",
+    "    return system"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Quantum array: dims = [[5, 11], [5, 11]], shape = (55, 55), type = oper\n",
+       "Qarray data =\n",
+       "[[-40. +0.j   0. +0.j   0. +0.j ...   0. +0.j   0. +0.j   0. +0.j]\n",
+       " [  0. +0.j -32. +0.j   0. +0.j ...   0. +0.j   0. +0.j   0. +0.j]\n",
+       " [  0. +0.j   0. +0.j -24. +0.j ...   0. +0.j   0. +0.j   0. +0.j]\n",
+       " ...\n",
+       " [  0. +0.j   0. +0.j   0. +0.j ...  43.1+0.j   0. +0.j   0. +0.j]\n",
+       " [  0. +0.j   0. +0.j   0. +0.j ...   0. +0.j  51.1+0.j   0. +0.j]\n",
+       " [  0. +0.j   0. +0.j   0. +0.j ...   0. +0.j   0. +0.j  59.1+0.j]]"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Create Floquet qubit\n",
+    "fq = create_H_F(0, 8)\n",
+    "fq.get_H()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 4 - AC Stark Shift"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Since $\\hat{H}_F$ is comprised of two coupled systems, it must have two quantum numbers. We labels these as $\\alpha$ for the qubit and $m$ for the drive. Therefore, diagonalizing $\\hat{H}_F$, we will get a list of energy eigenvalues $E_{\\alpha, m}$ and eigenvectors $|v_{\\alpha, m}\\rangle$. However, a Floquet system is different from a regular coupled system in that the various drive levels $m$ are redundant, i.e. they are identical Floquet replicates, i.e., we have :\n",
+    "$$E_{\\alpha, m} = E_{\\alpha, 0} + m\\omega_d$$ \n",
+    "\n",
+    "We can thus pick any drive index $m$ to look at the driven eigenstates, since only $N$ of the $N \\times (2 M_{\\rm max} + 1)$ levels correspond to unique states in the lab frame. The conventional choice is $m = 0$, since here the Floquet dressed energies $E_{\\alpha, 0}$ match up with the bare spectrum of the qubit. Another choice is to take all energies modulo $\\omega_d$, in which case the energies match up with the Floquet quasi-energies $\\epsilon_\\alpha$ above. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_qubit_energies(Ω, ωd):\n",
+    "    \"\"\" \n",
+    "    Note: the index m of the drive runs from -M_max to M_max. Therefore, the m = 0 state is at numerical index M_max.\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    fq = create_H_F(Ω, ωd)\n",
+    "    eval, _ = fq.calculate_eig()\n",
+    "\n",
+    "    return eval[:, fq.devices[1].M_max]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "get_qubit_energies_vs_Ω = jit(vmap(get_qubit_energies, in_axes=(0, None)))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "drive_amps = jnp.linspace(0, 0.2, 101) # Up to 200 MHz Rabi rate\n",
+    "drive_freq = bare_ω_ge + 0.1 # 100 MHz detuned from the qubit\n",
+    "energies = get_qubit_energies_vs_Ω(drive_amps, 5.1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0, 0.5, 'Qubit frequency $f_{\\\\rm ge}$ (MHz)')"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 2000x1500 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, ax = plt.subplots(figsize=(4, 3), dpi=500)\n",
+    "\n",
+    "ax.plot(drive_amps * 1e3, energies[:, 1] - energies[:, 0])\n",
+    "ax.set_xlabel(r\"Drive amplitude $\\Omega$ (MHz)\")\n",
+    "ax.set_ylabel(r\"Qubit frequency $f_{\\rm ge}$ (MHz)\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "bosonic-jax-env",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.16"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/tutorials/6-normal-mode-approach-to-fluxonium.ipynb b/tutorials/7-normal-mode-approach-to-fluxonium.ipynb
similarity index 100%
rename from tutorials/6-normal-mode-approach-to-fluxonium.ipynb
rename to tutorials/7-normal-mode-approach-to-fluxonium.ipynb