Base classes

---

AbstractDoF

Bases: Module

Abstract base class for degrees of freedom (DoF) in quantum systems.

Degrees of freedom classify the physical encoding of quantum information. Each DoF subclass represents a different physical implementation for encoding quantum states, which can be useful for enforcing circuit validity and distinguishing between different physical platforms.

Subclasses

DV: Discrete variable systems (qubits, qudits) Fock: Fock second-quantized systems (optical modes)

Source code in src/squint/interface/base.py

class AbstractDoF(eqx.Module):
    """
    Abstract base class for degrees of freedom (DoF) in quantum systems.

    Degrees of freedom classify the physical encoding of quantum information.
    Each DoF subclass represents a different physical implementation for
    encoding quantum states, which can be useful for enforcing circuit
    validity and distinguishing between different physical platforms.

    Subclasses:
        DV: Discrete variable systems (qubits, qudits)
        Fock: Fock second-quantized systems (optical modes)
    """

    pass

DV

Bases: AbstractDoF

Discrete variable degree of freedom.

Represents finite-dimensional quantum systems such as qubits (dim=2) or qudits (dim>2). These systems have a finite number of basis states and are commonly implemented in platforms like superconducting circuits, trapped ions, and spin systems.

Example

wire = Wire(dim=2, dof=DV, idx=0)  # A qubit wire

Source code in src/squint/interface/base.py

class DV(AbstractDoF):
    """
    Discrete variable degree of freedom.

    Represents finite-dimensional quantum systems such as qubits (dim=2)
    or qudits (dim>2). These systems have a finite number of basis states
    and are commonly implemented in platforms like superconducting circuits,
    trapped ions, and spin systems.

    Example:
        ```python
        wire = Wire(dim=2, dof=DV, idx=0)  # A qubit wire
        ```
    """

    pass

Fock

Bases: AbstractDoF

Fock space degree of freedom.

Represents infinite-dimensional Fock space systems, typically optical modes with photon number states. In practice, the Hilbert space is truncated at a finite photon number cutoff specified by the wire dimension.

Example

wire = Wire(dim=10, dof=Fock, idx=0)  # Optical mode with 10 photon cutoff

Source code in src/squint/interface/base.py

class Fock(AbstractDoF):
    """
    Fock space degree of freedom.

    Represents infinite-dimensional Fock space systems, typically optical
    modes with photon number states. In practice, the Hilbert space is
    truncated at a finite photon number cutoff specified by the wire dimension.

    Example:
        ```python
        wire = Wire(dim=10, dof=Fock, idx=0)  # Optical mode with 10 photon cutoff
        ```
    """

    pass

Wire

Bases: Module

Represents a quantum subsystem (wire) in a circuit.

A Wire defines a single quantum subsystem with a specific Hilbert space dimension and degree of freedom type. Wires are the fundamental building blocks that connect quantum operations in a circuit, determining how operators act on different parts of the composite quantum system.

Attributes:

Name	Type	Description
dim	int	The dimension of the local Hilbert space. For qubits, dim=2; for qudits, dim>2; for Fock spaces, dim is the photon number cutoff.
dof	type[AbstractDoF]	The type of degree of freedom this wire represents (e.g., DV for discrete variable, CV for continuous variable).
idx	str | int	Unique identifier for the wire, used to track which operations act on which subsystems.

Example

from squint.ops.base import Wire, DV, CV

# Create a qubit wire
qubit = Wire(dim=2, dof=DV, idx=0)

# Create an optical mode wire with photon cutoff of 5
mode = Wire(dim=5, dof=CV, idx="signal")

# Use wires in operations
from squint.ops.dv import DiscreteVariableState, HGate
state = DiscreteVariableState(wires=(qubit,), n=(0,))
gate = HGate(wires=(qubit,))

Source code in src/squint/interface/base.py

class Wire(eqx.Module):
    """
    Represents a quantum subsystem (wire) in a circuit.

    A Wire defines a single quantum subsystem with a specific Hilbert space dimension
    and degree of freedom type. Wires are the fundamental building blocks that connect
    quantum operations in a circuit, determining how operators act on different parts
    of the composite quantum system.

    Attributes:
        dim (int): The dimension of the local Hilbert space. For qubits, dim=2;
            for qudits, dim>2; for Fock spaces, dim is the photon number cutoff.
        dof (type[AbstractDoF]): The type of degree of freedom this wire represents
            (e.g., DV for discrete variable, CV for continuous variable).
        idx (str | int): Unique identifier for the wire, used to track which
            operations act on which subsystems.

    Example:
        ```python
        from squint.ops.base import Wire, DV, CV

        # Create a qubit wire
        qubit = Wire(dim=2, dof=DV, idx=0)

        # Create an optical mode wire with photon cutoff of 5
        mode = Wire(dim=5, dof=CV, idx="signal")

        # Use wires in operations
        from squint.ops.dv import DiscreteVariableState, HGate
        state = DiscreteVariableState(wires=(qubit,), n=(0,))
        gate = HGate(wires=(qubit,))
        ```
    """

    idx: int | str = 0
    dim: int
    dof: type[AbstractDoF]
    # info: type[AbstractInformationType]

    @beartype
    def __init__(
        self,
        dim: int,
        dof: Optional[type[AbstractDoF]] = AbstractDoF,
        idx: Optional[int | str] = None,
        # info: Optional[type[AbstractInformationType]] = Quantum,
    ):
        """
        Initialize a Wire.

        Args:
            dim (int): The dimension of the local Hilbert space. Must be >= 2.
                For qubits use dim=2, for qudits use dim>2, for Fock spaces
                this is the photon number cutoff.
            dof (type[AbstractDoF], optional): Type of degree of freedom that
                this wire represents. Can be used to enforce circuit validity
                and distinguish between different physical encodings.
                Defaults to AbstractDoF.
            idx (str | int, optional): Unique identifier for the wire. If not
                provided, a random id is generated.

        Raises:
            ValueError: If dim < 2.
        """
        if dim < 1:
            raise ValueError("Dimension should be 1 or greater.")
        if isinstance(idx, int):
            if idx < 0:
                raise ValueError(
                    "Wire.idx integers must be positive. Negative integers are reserved for autogenerated identities."
                )
        self.dim = dim
        self.dof = dof
        # self.info = info

        # self.idx = idx if idx is not None else str(uuid4())
        # self.idx = idx if idx is not None else next(_wire_id)
        # self.idx = idx if idx is not None else f"__w{next(_wire_id)}"
        self.idx = idx if idx is not None else -next(_wire_id) - 1

    def __eq__(self, other: object) -> bool:
        return isinstance(other, Wire) and self.idx == other.idx

    def __hash__(self) -> int:
        return hash(self.idx)

__init__(dim: int, dof: Optional[type[AbstractDoF]] = AbstractDoF, idx: Optional[int | str] = None)

Initialize a Wire.

Parameters:

Name	Type	Description	Default
dim	int	The dimension of the local Hilbert space. Must be >= 2. For qubits use dim=2, for qudits use dim>2, for Fock spaces this is the photon number cutoff.	required
dof	type[AbstractDoF]	Type of degree of freedom that this wire represents. Can be used to enforce circuit validity and distinguish between different physical encodings. Defaults to AbstractDoF.	AbstractDoF
idx	str | int	Unique identifier for the wire. If not provided, a random id is generated.	None

Raises:

Type	Description
ValueError	If dim < 2.

Source code in src/squint/interface/base.py

@beartype
def __init__(
    self,
    dim: int,
    dof: Optional[type[AbstractDoF]] = AbstractDoF,
    idx: Optional[int | str] = None,
    # info: Optional[type[AbstractInformationType]] = Quantum,
):
    """
    Initialize a Wire.

    Args:
        dim (int): The dimension of the local Hilbert space. Must be >= 2.
            For qubits use dim=2, for qudits use dim>2, for Fock spaces
            this is the photon number cutoff.
        dof (type[AbstractDoF], optional): Type of degree of freedom that
            this wire represents. Can be used to enforce circuit validity
            and distinguish between different physical encodings.
            Defaults to AbstractDoF.
        idx (str | int, optional): Unique identifier for the wire. If not
            provided, a random id is generated.

    Raises:
        ValueError: If dim < 2.
    """
    if dim < 1:
        raise ValueError("Dimension should be 1 or greater.")
    if isinstance(idx, int):
        if idx < 0:
            raise ValueError(
                "Wire.idx integers must be positive. Negative integers are reserved for autogenerated identities."
            )
    self.dim = dim
    self.dof = dof
    # self.info = info

    # self.idx = idx if idx is not None else str(uuid4())
    # self.idx = idx if idx is not None else next(_wire_id)
    # self.idx = idx if idx is not None else f"__w{next(_wire_id)}"
    self.idx = idx if idx is not None else -next(_wire_id) - 1

AbstractContainer

Bases: Module

Source code in src/squint/interface/base.py

class AbstractContainer(eqx.Module):
    """ """

    pass  # TODO: flesh this out

AbstractProcess

Bases: Module

An abstract base class for all quantum objects, including states, gates, channels, and measurements. It provides a common interface for various quantum objects, ensuring consistency and reusability across different types of quantum operations.

Attributes:

Name	Type	Description
wires	tuple[int, ...]	A tuple of nonnegative integers representing the quantum wires on which the operation acts. Each wire corresponds to a specific subsystem in the composite quantum system.

Source code in src/squint/interface/base.py

class AbstractProcess(eqx.Module):
    """
    An abstract base class for all quantum objects, including states, gates, channels, and measurements.
    It provides a common interface for various quantum objects, ensuring consistency and reusability across different types
    of quantum operations.

    Attributes:
        wires (tuple[int, ...]): A tuple of nonnegative integers representing the quantum wires
                                 on which the operation acts. Each wire corresponds to a specific subsystem
                                 in the composite quantum system.
    """

    wires: tuple[Wire, ...]

    _registry: ClassVar[list[type]] = []

    def __init_subclass__(cls, **kwargs):
        super().__init_subclass__(**kwargs)
        AbstractProcess._registry.append(cls)

    def __init__(
        self,
        wires: Sequence[Wire],
    ):
        """
        Initializes the AbstractProcess instance.

        Args:
            wires (tuple[int, ...], optional): A tuple of nonnegative integers representing the quantum wires
                                               on which the operation acts. Defaults to (0, 1).

        Raises:
            TypeError: If any wire in the provided tuple is not a nonnegative integer.
        """
        self.wires = wires
        return

    # TODO: test proper dispatch
    def __call__(self, backend: AbstractBackend):
        return self.lower(backend)

__init__(wires: Sequence[Wire])

Initializes the AbstractProcess instance.

Parameters:

Name	Type	Description	Default
wires	tuple[int, ...]	A tuple of nonnegative integers representing the quantum wires on which the operation acts. Defaults to (0, 1).	required

Raises:

Type	Description
TypeError	If any wire in the provided tuple is not a nonnegative integer.

Source code in src/squint/interface/base.py

def __init__(
    self,
    wires: Sequence[Wire],
):
    """
    Initializes the AbstractProcess instance.

    Args:
        wires (tuple[int, ...], optional): A tuple of nonnegative integers representing the quantum wires
                                           on which the operation acts. Defaults to (0, 1).

    Raises:
        TypeError: If any wire in the provided tuple is not a nonnegative integer.
    """
    self.wires = wires
    return

AbstractState

Bases: AbstractProcess

An abstract base class for all quantum states.

Source code in src/squint/interface/base.py

class AbstractState(AbstractProcess):
    r"""
    An abstract base class for all quantum states.
    """

    def __init__(
        self,
        wires: Sequence[Wire],
    ):
        super().__init__(wires=wires)
        return

AbstractPureState

Bases: AbstractState

An abstract base class for all pure quantum states, equivalent to the state vector formalism. Pure states are associated with a Hilbert space of size \(|\psi\rangle \in \mathcal{H}^{d_1 \times \dots \times d_w}\) where \(w\) = len(wires) and \(d\) is assigned at compile time.

Source code in src/squint/interface/base.py

class AbstractPureState(AbstractState):
    r"""
    An abstract base class for all pure quantum states, equivalent to the state vector formalism.
    Pure states are associated with a Hilbert space of size
    $|\psi\rangle \in \mathcal{H}^{d_1 \times \dots \times d_w}$
    where $w$ = `len(wires)` and $d$ is assigned at compile time.
    """

    def __init__(
        self,
        wires: Sequence[Wire],
    ):
        super().__init__(wires=wires)
        return

AbstractMixedState

Bases: AbstractState

An abstract base class for all mixed quantum states, equivalent to the density matrix formalism. Mixed states are associated with a Hilbert space of size \(\rho \in \mathcal{H}^{d_1 \times \dots \times d_w \times d_1 \times \dots \times d_w}\) where \(w\) = len(wires) and \(d\) is assigned at compile time.

Source code in src/squint/interface/base.py

class AbstractMixedState(AbstractState):
    r"""
    An abstract base class for all mixed quantum states, equivalent to the density matrix formalism.
    Mixed states are associated with a Hilbert space of size
    $\rho \in \mathcal{H}^{d_1 \times \dots \times d_w \times d_1 \times \dots \times d_w}$
    where $w$ = `len(wires)` and $d$ is assigned at compile time.
    """

    def __init__(
        self,
        wires: Sequence[Wire],
    ):
        super().__init__(wires=wires)
        return

AbstractGate

Bases: AbstractProcess

An abstract base class for all unitary quantum gates, which transform an input state in a reversible way. \(U \in \mathcal{H}^{d_1 \times \dots \times d_w \times d_1 \times \dots \times d_w}\) where \(w\) = len(wires) and \(d\) is assigned at compile time.

Source code in src/squint/interface/base.py

class AbstractGate(AbstractProcess):
    r"""
    An abstract base class for all unitary quantum gates, which transform an input state in a reversible way.
    $U \in \mathcal{H}^{d_1 \times \dots \times d_w \times d_1 \times \dots \times d_w}$
    where $w$ = `len(wires)` and $d$ is assigned at compile time.
    """

    def __init__(
        self,
        wires: Sequence[Wire],
    ):
        super().__init__(wires=wires)
        return

AbstractChannel

Bases: AbstractProcess

An abstract base class for quantum channels, including channels expressed as Kraus operators, erasure (partial trace), and others.

Source code in src/squint/interface/base.py

class AbstractChannel(AbstractProcess):
    r"""
    An abstract base class for quantum channels, including channels expressed as Kraus operators, erasure (partial trace), and others.
    """

    def __init__(
        self,
        wires: Sequence[Wire],
    ):
        super().__init__(wires=wires)
        return

AbstractMeasurement

Bases: AbstractProcess

An abstract base class for quantum measurements. Currently, this is not supported, and measurements are projective measurements in the computational basis.

Source code in src/squint/interface/base.py

class AbstractMeasurement(AbstractProcess):
    r"""
    An abstract base class for quantum measurements.
    Currently, this is not supported, and measurements are projective measurements in the computational basis.
    """

    def __init__(
        self,
        wires: Sequence[Wire],
    ):
        super().__init__(wires=wires)
        return

AbstractInstrument

Bases: AbstractProcess

An abstract base class for all quantum instruments.

Source code in src/squint/interface/base.py

class AbstractInstrument(AbstractProcess):
    r"""
    An abstract base class for all quantum instruments.
    """

    def __init__(
        self,
        wires: Sequence[Wire],
    ):
        super().__init__(wires=wires)
        return

SharedGate

Bases: AbstractContainer

A class representing a shared quantum gate, which allows for the sharing of parameters or attributes across multiple copies of a quantum operation. This is useful for scenarios where multiple gates share the same underlying structure or parameters, such as in variational quantum circuits. This is most commonly used when applying the same parameterized gate across different wires, e.g., phase gates, for studying phase estimation protocols.

Attributes:

Name	Type	Description
op	AbstractProcess	The base quantum operation that is shared across multiple copies.
copies	Sequence[AbstractProcess]	A sequence of copies of the base operation, each acting on different wires.
where	Callable	A function that determines which attributes of the operation are shared across copies.
get	Callable	A function that retrieves the shared attributes from the base operation.

Source code in src/squint/interface/base.py

class SharedGate(AbstractContainer):
    # class SharedGate(eqx.Module):
    r"""
    A class representing a shared quantum gate, which allows for the sharing of parameters or attributes
    across multiple copies of a quantum operation. This is useful for scenarios where multiple gates
    share the same underlying structure or parameters, such as in variational quantum circuits.
    This is most commonly used when applying the same parameterized gate across different wires,
    e.g., phase gates, for studying phase estimation protocols.

    Attributes:
        op (AbstractProcess): The base quantum operation that is shared across multiple copies.
        copies (Sequence[AbstractProcess]): A sequence of copies of the base operation, each acting on different wires.
        where (Callable): A function that determines which attributes of the operation are shared across copies.
        get (Callable): A function that retrieves the shared attributes from the base operation.
    """

    op: AbstractProcess
    copies: Sequence[AbstractProcess]
    where: Callable
    get: Callable

    @beartype
    def __init__(
        self,
        op: AbstractProcess,
        wires: Union[Sequence[Wire], Sequence[Sequence[Wire]]],
        where: Optional[Callable] = None,
        get: Optional[Callable] = None,
    ):
        # todo: handle the wires coming from both main and the shared wires
        copies = [eqx.tree_at(lambda op: op.wires, op, (wire,)) for wire in wires]
        self.copies = copies
        self.op = op

        if is_bearable(wires, Sequence[Wire]):
            wires = op.wires + wires

        elif is_bearable(wires, Sequence[Sequence[Wire]]):
            wires = op.wires + tuple(itertools.chain.from_iterable(wires))

        # use a default where/get sharing mechanism, such that all ArrayLike attributes are shared exactly
        attrs = [key for key, val in op.__dict__.items() if eqx.is_array_like(val)]

        if where is None:  # todo: check  get/where functions if it is user-defined
            where = lambda pytree: sum(
                [[copy.__dict__[key] for copy in pytree.copies] for key in attrs], []
            )
        if get is None:
            get = lambda pytree: sum(
                [[pytree.op.__dict__[key] for _ in pytree.copies] for key in attrs], []
            )
        self.where = where
        self.get = get

        return

    def __check_init__(self):
        return object.__setattr__(
            self,
            "__dict__",
            eqx.tree_at(self.where, self, replace_fn=lambda _: None).__dict__,
        )

AbstractKrausChannel

Bases: AbstractChannel

An abstract base class for quantum channels expressed as Kraus operators. The channel \(K\) is of shape \((d_1 \times \dots \times d_w \times d_1 \times \dots \times d_w)\) where \(w\) = len(wires) and \(d\) is assigned at compile time.

Source code in src/squint/interface/base.py

class AbstractKrausChannel(AbstractChannel):
    r"""
    An abstract base class for quantum channels expressed as Kraus operators.
    The channel $K$ is of shape $(d_1 \times \dots \times d_w \times d_1 \times \dots \times d_w)$
    where $w$ = `len(wires)` and $d$ is assigned at compile time.
    """

    def __init__(
        self,
        wires: Sequence[Wire],
    ):
        super().__init__(wires=wires)
        return

AbstractErasureChannel

Bases: AbstractChannel

This channel traces out the local Hilbert space associated with the wires

Source code in src/squint/interface/base.py

class AbstractErasureChannel(AbstractChannel):
    """
    This channel traces out the local Hilbert space associated with the `wires`
    """

    @beartype
    def __init__(self, wires: Sequence[Wire]):
        super().__init__(wires=wires)
        return

Block

Bases: AbstractContainer

A block operation that groups a sequence of quantum operations.

Blocks allow organizing multiple operations into a single logical unit. They can be nested within circuits or other blocks, and support the same add and unwrap interface as Circuit. Unlike Circuit, Block does not specify a backend and is purely for organizational purposes.

Attributes:

Name	Type	Description
ops	OrderedDict	Ordered dictionary mapping keys to operations or nested blocks.

Example

from squint.ops.base import Block, Wire
from squint.ops.dv import RXGate, RYGate

wire = Wire(dim=2, idx=0)
block = Block()
block.add(RXGate(wires=(wire,), phi=0.1), "rx")
block.add(RYGate(wires=(wire,), phi=0.2), "ry")

# Use in a circuit
circuit.add(block, "rotation_block")

Source code in src/squint/interface/base.py

class Block(AbstractContainer):
    """
    A block operation that groups a sequence of quantum operations.

    Blocks allow organizing multiple operations into a single logical unit.
    They can be nested within circuits or other blocks, and support the same
    `add` and `unwrap` interface as Circuit. Unlike Circuit, Block does not
    specify a backend and is purely for organizational purposes.

    Attributes:
        ops (OrderedDict): Ordered dictionary mapping keys to operations or nested blocks.

    Example:
        ```python
        from squint.ops.base import Block, Wire
        from squint.ops.dv import RXGate, RYGate

        wire = Wire(dim=2, idx=0)
        block = Block()
        block.add(RXGate(wires=(wire,), phi=0.1), "rx")
        block.add(RYGate(wires=(wire,), phi=0.2), "ry")

        # Use in a circuit
        circuit.add(block, "rotation_block")
        ```
    """

    ops: OrderedDict[Union[str, int], Union[AbstractProcess, AbstractContainer]]

    @beartype
    def __init__(
        self,
        ops: dict | OrderedDict = {},
        # ops: OrderedDict = OrderedDict()
    ):
        """
        Initialize an empty Block.

        Creates a new Block with no operations. Operations can be added
        using the `add` method.
        """
        self.ops = OrderedDict(ops)

    @beartype
    def add(
        self, op: Union[AbstractProcess, AbstractContainer], key: str = None
    ) -> None:
        """
        Add an operator to the block.

        Operators are added sequentially. When this block is used in a circuit,
        the operations will be applied in the order they were added.

        Args:
            op (AbstractProcess | Block): The operator or nested block to add.
            key (str, optional): A string key for indexing into the block's ops
                dictionary. If None, an integer counter is used as the key.
        """

        if key is None:
            key = len(self.ops)
        self.ops[key] = op

__init__(ops: dict | OrderedDict = {})

Initialize an empty Block.

Creates a new Block with no operations. Operations can be added using the add method.

Source code in src/squint/interface/base.py

@beartype
def __init__(
    self,
    ops: dict | OrderedDict = {},
    # ops: OrderedDict = OrderedDict()
):
    """
    Initialize an empty Block.

    Creates a new Block with no operations. Operations can be added
    using the `add` method.
    """
    self.ops = OrderedDict(ops)

add(op: Union[AbstractProcess, AbstractContainer], key: str = None) -> None

Add an operator to the block.

Operators are added sequentially. When this block is used in a circuit, the operations will be applied in the order they were added.

Parameters:

Name	Type	Description	Default
op	AbstractProcess | Block	The operator or nested block to add.	required
key	str	A string key for indexing into the block's ops dictionary. If None, an integer counter is used as the key.	None

Source code in src/squint/interface/base.py

@beartype
def add(
    self, op: Union[AbstractProcess, AbstractContainer], key: str = None
) -> None:
    """
    Add an operator to the block.

    Operators are added sequentially. When this block is used in a circuit,
    the operations will be applied in the order they were added.

    Args:
        op (AbstractProcess | Block): The operator or nested block to add.
        key (str, optional): A string key for indexing into the block's ops
            dictionary. If None, an integer counter is used as the key.
    """

    if key is None:
        key = len(self.ops)
    self.ops[key] = op

create(dim) cached

Returns the create operator for a Hilbert space of dimension dim. The create operator is a matrix that adds one excitation to a quantum system, effectively increasing the energy level by one. Args: dim (int): The dimension of the Hilbert space. Returns: jnp.ndarray: A 2D array of shape (dim, dim) representing the create operator.

Source code in src/squint/interface/base.py

@functools.cache
def create(dim):
    """
    Returns the create operator for a Hilbert space of dimension `dim`.
    The create operator is a matrix that adds one excitation to a quantum system,
    effectively increasing the energy level by one.
    Args:
        dim (int): The dimension of the Hilbert space.
    Returns:
        jnp.ndarray: A 2D array of shape (dim, dim) representing the create operator.
    """
    return jnp.diag(jnp.sqrt(jnp.arange(1, dim)), k=-1)

destroy(dim) cached

Returns the destroy operator for a Hilbert space of dimension dim. The destroy operator is a matrix that annihilates one excitation of a quantum system, effectively reducing the energy level by one. Args: dim (int): The dimension of the Hilbert space. Returns: jnp.ndarray: A 2D array of shape (dim, dim) representing the destroy operator.

Source code in src/squint/interface/base.py

@functools.cache
def destroy(dim):
    """
    Returns the destroy operator for a Hilbert space of dimension `dim`.
    The destroy operator is a matrix that annihilates one excitation of a quantum system,
    effectively reducing the energy level by one.
    Args:
        dim (int): The dimension of the Hilbert space.
    Returns:
        jnp.ndarray: A 2D array of shape (dim, dim) representing the destroy operator.
    """
    return jnp.diag(jnp.sqrt(jnp.arange(1, dim)), k=1)

eye(dim) cached

Returns the identity operator for a Hilbert space of dimension dim.

Parameters:

Name	Type	Description	Default
dim	int	The dimension of the Hilbert space.	required

Returns: jnp.ndarray: A 2D array of shape (dim, dim) representing the identity operator.

Source code in src/squint/interface/base.py

@functools.cache
def eye(dim):
    """
    Returns the identity operator for a Hilbert space of dimension `dim`.

    Args:
        dim (int): The dimension of the Hilbert space.
    Returns:
        jnp.ndarray: A 2D array of shape (dim, dim) representing the identity operator.
    """
    return jnp.eye(dim)

bases(dim) cached

Returns the computational basis indices for a Hilbert space of dimension dim.

Parameters:

Name	Type	Description	Default
dim	int	The dimension of the Hilbert space.	required

Returns:

Type	Description
	jnp.ndarray: A 1D array of shape (dim,) containing the indices of the computational bases.

Source code in src/squint/interface/base.py

@functools.cache
def bases(dim):
    """

    Returns the computational basis indices for a Hilbert space of dimension `dim`.

    Args:
        dim (int): The dimension of the Hilbert space.

    Returns:
        jnp.ndarray: A 1D array of shape (dim,) containing the indices of the computational bases.
    """
    return jnp.arange(dim)

dft(dim) cached

Returns the discrete Fourier transform matrix of dimension dim.

Parameters:

Name	Type	Description	Default
dim	int	The dimension of the DFT matrix.	required

Returns:

Type	Description
	jnp.ndarray: A 2D array of shape (dim, dim) representing the DFT matrix.

Source code in src/squint/interface/base.py

@functools.cache
def dft(dim):
    """
    Returns the discrete Fourier transform matrix of dimension `dim`.

    Args:
        dim (int): The dimension of the DFT matrix.

    Returns:
        jnp.ndarray: A 2D array of shape (dim, dim) representing the DFT matrix.
    """
    return jnp.array(sp.linalg.dft(dim, scale="sqrtn"))

basis_operators(dim) cached

Return a basis of orthogonal Hermitian operators on a Hilbert space of dimension \(d\), with the identity element in the last place. i.e., the Gell-Mann operators (for dim=2, these are the four Pauli operators).

Parameters:

Name	Type	Description	Default
dim	int	The dimension of the Hilbert space.	required

Returns:

Type	Description
	jnp.ndarray: A 3D array of shape (n_operators, dim, dim) containing the basis operators.

Source code in src/squint/interface/base.py

@functools.cache
def basis_operators(dim):
    """
    Return a basis of orthogonal Hermitian operators on a Hilbert space of
    dimension $d$, with the identity element in the last place.
    i.e., the Gell-Mann operators (for dim=2, these are the four Pauli operators).

    Args:
        dim (int): The dimension of the Hilbert space.

    Returns:
        jnp.ndarray: A 3D array of shape (n_operators, dim, dim) containing the basis operators.
    """
    return jnp.array(
        [
            gellmann(j, k, dim)
            for j, k in itertools.product(range(1, dim + 1), repeat=2)
        ],
        jnp.complex128,
    )