qadence 1.1.1__tar.gz → 1.2.1__tar.gz

{qadence-1.1.1 → qadence-1.2.1}/.github/workflows/build_docs.yml

@@ -35,7 +35,7 @@ jobs:
       run: sudo apt-get install -y graphviz
 
     - name: Set up Python 3.10
-      uses: actions/setup-python@v4
+      uses: actions/setup-python@v5
       with:
         python-version: '3.10'
 

{qadence-1.1.1 → qadence-1.2.1}/.github/workflows/lint.yml

@@ -17,7 +17,7 @@ jobs:
       uses: actions/checkout@v4
 
     - name: Set up Python 3.x
-      uses: actions/setup-python@v4
+      uses: actions/setup-python@v5
       with:
         python-version: '3.x'
 

{qadence-1.1.1 → qadence-1.2.1}/.github/workflows/test_all.yml

@@ -10,6 +10,7 @@ concurrency:
   group: all-${{ github.head_ref || github.run_id }}
   cancel-in-progress: true
 
+
 jobs:
   test_qadence_ubuntu:
     name: Test Qadence (ubuntu)
@@ -22,7 +23,7 @@ jobs:
       uses: actions/checkout@v4
 
     - name: Set up Python ${{ matrix.python-version }}
-      uses: actions/setup-python@v4
+      uses: actions/setup-python@v5
       with:
         python-version: ${{ matrix.python-version }}
 
@@ -33,3 +34,27 @@ jobs:
     - name: Run tests
       run: |
         hatch -v run test
+
+  test_fast_qadence_windows_mac:
+    name: Test Qadence (Windows, MacOS)
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [macos-latest, windows-latest]
+        python-version: ["3.10"]
+    steps:
+    - name: Checkout Qadence
+      uses: actions/checkout@v4
+
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v5
+      with:
+        python-version: ${{ matrix.python-version }}
+
+    - name: Install Hatch
+      run: |
+        pip install hatch
+
+    - name: Run tests
+      run: |
+        hatch -v run test -m "not slow"

{qadence-1.1.1 → qadence-1.2.1}/.github/workflows/test_examples.yml

@@ -24,7 +24,7 @@ jobs:
       run: sudo apt-get install -y graphviz
 
     - name: Select Python 3.10
-      uses: actions/setup-python@v4
+      uses: actions/setup-python@v5
       with:
         python-version: '3.10'
 

{qadence-1.1.1 → qadence-1.2.1}/.github/workflows/test_fast.yml

@@ -27,7 +27,7 @@ jobs:
     - name: Checkout Qadence
       uses: actions/checkout@v4
     - name: Set up Python ${{ matrix.python-version }}
-      uses: actions/setup-python@v4
+      uses: actions/setup-python@v5
       with:
         python-version: ${{ matrix.python-version }}
     - name: Install Hatch
@@ -54,7 +54,7 @@ jobs:
         with:
           ref: ${{ github.ref }}
       - name: Set up Python
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v5
         with:
           python-version: "3.10"
       - name: Install Python dependencies
@@ -94,7 +94,7 @@ jobs:
     - name: Install graphviz
       run: sudo apt-get install -y graphviz
     - name: Set up Python 3.10
-      uses: actions/setup-python@v4
+      uses: actions/setup-python@v5
       with:
         python-version: '3.10'
     - name: Install Hatch

{qadence-1.1.1 → qadence-1.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: qadence
-Version: 1.1.1
+Version: 1.2.1
 Summary: Pasqal interface for circuit-based quantum computing SDKs
 Author-email: Aleksander Wennersteen <aleksander.wennersteen@pasqal.com>, Gert-Jan Both <gert-jan.both@pasqal.com>, Niklas Heim <niklas.heim@pasqal.com>, Mario Dagrada <mario.dagrada@pasqal.com>, Vincent Elfving <vincent.elfving@pasqal.com>, Dominik Seitz <dominik.seitz@pasqal.com>, Roland Guichard <roland.guichard@pasqal.com>, "Joao P. Moutinho" <joao.moutinho@pasqal.com>, Vytautas Abramavicius <vytautas.abramavicius@pasqal.com>
 License: Apache 2.0
@@ -18,8 +18,9 @@ Requires-Dist: deepdiff
 Requires-Dist: jsonschema
 Requires-Dist: matplotlib
 Requires-Dist: nevergrad
+Requires-Dist: numpy
 Requires-Dist: openfermion
-Requires-Dist: pyqtorch==1.0.1
+Requires-Dist: pyqtorch==1.0.3
 Requires-Dist: rich
 Requires-Dist: scipy
 Requires-Dist: sympytorch>=0.1.2
@@ -27,10 +28,25 @@ Requires-Dist: tensorboard>=2.12.0
 Requires-Dist: torch
 Provides-Extra: all
 Requires-Dist: amazon-braket-sdk; extra == 'all'
+Requires-Dist: einops; extra == 'all'
+Requires-Dist: flax; extra == 'all'
 Requires-Dist: graphviz; extra == 'all'
+Requires-Dist: horqrux==0.3.0; extra == 'all'
+Requires-Dist: jax; extra == 'all'
+Requires-Dist: jaxopt; extra == 'all'
+Requires-Dist: optax; extra == 'all'
 Requires-Dist: pulser>=0.15.2; extra == 'all'
+Requires-Dist: sympy2jax; extra == 'all'
 Provides-Extra: braket
 Requires-Dist: amazon-braket-sdk; extra == 'braket'
+Provides-Extra: horqrux
+Requires-Dist: einops; extra == 'horqrux'
+Requires-Dist: flax; extra == 'horqrux'
+Requires-Dist: horqrux==0.3.0; extra == 'horqrux'
+Requires-Dist: jax; extra == 'horqrux'
+Requires-Dist: jaxopt; extra == 'horqrux'
+Requires-Dist: optax; extra == 'horqrux'
+Requires-Dist: sympy2jax; extra == 'horqrux'
 Provides-Extra: pulser
 Requires-Dist: pasqal-cloud>=0.3.5; extra == 'pulser'
 Requires-Dist: pulser>=v0.15.2; extra == 'pulser'
@@ -74,12 +90,15 @@ Qadence is available on [PyPI](https://pypi.org/project/qadence/) and can be ins
 pip install qadence
 ```
 
-The default, pre-installed backend for Qadence is [PyQTorch](https://github.com/pasqal-io/pyqtorch), a differentiable state vector simulator for digital-analog simulation. It is possible to install additional backends and the circuit visualization library using the following extras:
+The default, pre-installed backend for Qadence is [PyQTorch](https://github.com/pasqal-io/pyqtorch), a differentiable state vector simulator for digital-analog simulation based on `PyTorch`. It is possible to install additional, `PyTorch` -based backends and the circuit visualization library using the following extras:
 
 * `pulser`: The [Pulser](https://github.com/pasqal-io/Pulser) backend for composing, simulating and executing pulse sequences for neutral-atom quantum devices.
 * `braket`: The [Braket](https://github.com/amazon-braket/amazon-braket-sdk-python) backend, an open source library that provides a framework for interacting with quantum computing hardware devices through Amazon Braket.
 * `visualization`: A visualization library to display quantum circuit diagrams.
 
+Qadence also supports a `JAX` engine which is currently supporting the [Horqrux](https://github.com/pasqal-io/horqrux) backend. `horqrux` is currently only available via the [low-level API](examples/backends/low_level/horqrux_backend.py).
+
+
 To install individual extras, use the following syntax (**IMPORTANT** Make sure to use quotes):
 
 ```bash

{qadence-1.1.1 → qadence-1.2.1}/README.md

@@ -34,12 +34,15 @@ Qadence is available on [PyPI](https://pypi.org/project/qadence/) and can be ins
 pip install qadence
 ```
 
-The default, pre-installed backend for Qadence is [PyQTorch](https://github.com/pasqal-io/pyqtorch), a differentiable state vector simulator for digital-analog simulation. It is possible to install additional backends and the circuit visualization library using the following extras:
+The default, pre-installed backend for Qadence is [PyQTorch](https://github.com/pasqal-io/pyqtorch), a differentiable state vector simulator for digital-analog simulation based on `PyTorch`. It is possible to install additional, `PyTorch` -based backends and the circuit visualization library using the following extras:
 
 * `pulser`: The [Pulser](https://github.com/pasqal-io/Pulser) backend for composing, simulating and executing pulse sequences for neutral-atom quantum devices.
 * `braket`: The [Braket](https://github.com/amazon-braket/amazon-braket-sdk-python) backend, an open source library that provides a framework for interacting with quantum computing hardware devices through Amazon Braket.
 * `visualization`: A visualization library to display quantum circuit diagrams.
 
+Qadence also supports a `JAX` engine which is currently supporting the [Horqrux](https://github.com/pasqal-io/horqrux) backend. `horqrux` is currently only available via the [low-level API](examples/backends/low_level/horqrux_backend.py).
+
+
 To install individual extras, use the following syntax (**IMPORTANT** Make sure to use quotes):
 
 ```bash

{qadence-1.1.1 → qadence-1.2.1}/mkdocs.yml

@@ -23,10 +23,9 @@ nav:
     - digital_analog_qc/index.md
     - Basic operations on neutral-atoms: digital_analog_qc/analog-basics.md
     - Fitting a simple function: digital_analog_qc/analog-qcl.md
-    - Hardware efficient ansatz with restricted addressability: digital_analog_qc/rydberg-hea.md
+    - Restricted local addressability: digital_analog_qc/semi-local-addressing.md
     - Pulse-level programming with Pulser: digital_analog_qc/pulser-basic.md
     - Solve a QUBO problem: digital_analog_qc/analog-qubo.md
-    - Pulse-level programming with Pulser: digital_analog_qc/pulser-basic.md
     - CNOT with interacting qubits: digital_analog_qc/daqc-cnot.md
 
   - Variational quantum algorithms:

{qadence-1.1.1 → qadence-1.2.1}/pyproject.toml

@@ -19,7 +19,7 @@ authors = [
 ]
 requires-python = ">=3.9,<3.12"
 license = {text = "Apache 2.0"}
-version = "1.1.1"
+version = "1.2.1"
 classifiers=[
     "License :: OSI Approved :: Apache Software License",
     "Programming Language :: Python",
@@ -31,8 +31,9 @@ classifiers=[
     "Programming Language :: Python :: Implementation :: PyPy",
 ]
 dependencies = [
-    "openfermion",
+    "numpy",
     "torch",
+    "openfermion",
     "sympytorch>=0.1.2",
     "rich",
     "tensorboard>=2.12.0",
@@ -40,8 +41,8 @@ dependencies = [
     "jsonschema",
     "nevergrad",
     "scipy",
-    "pyqtorch==1.0.1",
-    "matplotlib"
+    "pyqtorch==1.0.3",
+    "matplotlib",
 ]
 
 [tool.hatch.metadata]
@@ -57,6 +58,15 @@ visualization = [
   # "latex2svg @ git+https://github.com/Moonbase59/latex2svg.git#egg=latex2svg",
   # "scour",
 ]
+horqrux = [
+    "horqrux==0.3.0",
+    "jax",
+    "flax",
+    "optax",
+    "jaxopt",
+    "einops",
+    "sympy2jax"]
+
 all = [
   "pulser>=0.15.2",
   "amazon-braket-sdk",
@@ -64,6 +74,13 @@ all = [
   # FIXME: will be needed once we support latex labels
   # "latex2svg @ git+https://github.com/Moonbase59/latex2svg.git#egg=latex2svg",
   # "scour",
+    "horqrux==0.3.0",
+    "jax",
+    "flax",
+    "optax",
+    "jaxopt",
+    "einops",
+    "sympy2jax"
 ]
 
 [tool.hatch.envs.default]
@@ -111,16 +128,16 @@ filterwarnings = [
 
 [tool.hatch.envs.docs]
 dependencies = [
-  "mkdocs==1.5.2",
+  "mkdocs",
   "mkdocs-material",
   "mkdocstrings",
   "mkdocstrings-python",
-  "mkdocs-section-index==0.3.6",
+  "mkdocs-section-index",
   "mkdocs-exclude",
   "markdown-exec",
   "mike",
 ]
-features = ["pulser", "braket", "visualization"]
+features = ["pulser", "braket", "horqrux", "visualization"]
 
 [tool.hatch.envs.docs.scripts]
 build = "mkdocs build --clean --strict"
@@ -167,6 +184,7 @@ required-imports = ["from __future__ import annotations"]
 [tool.ruff.per-file-ignores]
 "__init__.py" = ["F401"]
 "operations.py" = ["E742"]  # Avoid ambiguous class name warning for identity.
+"qadence/backends/horqrux/convert_ops.py" = ["E741"]  # Avoid ambiguous class name warning for 0.
 
 [tool.ruff.mccabe]
 max-complexity = 15

{qadence-1.1.1 → qadence-1.2.1}/qadence/__init__.py

@@ -11,6 +11,7 @@ from .backends import *
 from .blocks import *
 from .circuit import *
 from .constructors import *
+from .engines import *
 from .exceptions import *
 from .execution import *
 from .measurements import *

qadence-1.2.1/qadence/analog/__init__.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+
+from .addressing import AddressingPattern
+from .device import IdealDevice, RealisticDevice, RydbergDevice
+from .parse_analog import add_background_hamiltonian
+
+__all__ = ["RydbergDevice", "IdealDevice", "RealisticDevice", "AddressingPattern"]

qadence-1.2.1/qadence/analog/addressing.py

@@ -0,0 +1,167 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, fields
+from typing import Union
+from warnings import warn
+
+from sympy import Expr, Heaviside, exp
+from torch import Tensor, pi
+
+from qadence.parameters import Parameter, evaluate
+
+# FIXME: Clarify the roles of these values in the context
+# device specification and how they relate with the
+# maximum values for delta and omega.
+GLOBAL_MAX_AMPLITUDE = 300
+GLOBAL_MAX_DETUNING = 2 * pi * 2000
+LOCAL_MAX_AMPLITUDE = 3
+LOCAL_MAX_DETUNING = 2 * pi * 20
+
+TWeight = Union[str, float, Tensor, Parameter]
+
+
+def sigmoid(x: Tensor, a: float, b: float) -> Expr:
+    return 1.0 / (1.0 + exp(-a * (x + b)))
+
+
+@dataclass
+class AddressingPattern:
+    """Semi-local addressing pattern."""
+
+    n_qubits: int
+    """Number of qubits in register."""
+
+    weights_amp: dict[int, TWeight]
+    """List of weights for fixed amplitude pattern that cannot be changed during the execution."""
+
+    weights_det: dict[int, TWeight]
+    """List of weights for fixed detuning pattern that cannot be changed during the execution."""
+
+    amp: TWeight = LOCAL_MAX_AMPLITUDE
+    """Maximum amplitude of the amplitude pattern felt by a single qubit."""
+
+    det: TWeight = LOCAL_MAX_DETUNING
+    """Maximum detuning of the detuning pattern felt by a single qubit."""
+
+    def _validate_weights(
+        self,
+        weights: dict[int, TWeight],
+    ) -> None:
+        for v in weights.values():
+            if not isinstance(v, (str, Parameter)):
+                if not (v >= 0.0 and v <= 1.0):
+                    raise ValueError("Addressing pattern weights must sum fall in range [0.0, 1.0]")
+
+    def _constrain_weights(
+        self,
+        weights: dict[int, TWeight],
+    ) -> dict:
+        # augment weight dict if needed
+        weights = {
+            i: Parameter(0.0)
+            if i not in weights
+            else (Parameter(weights[i]) if not isinstance(weights[i], Parameter) else weights[i])
+            for i in range(self.n_qubits)
+        }
+
+        # restrict weights to [0, 1] range - equal to 0 everywhere else
+        weights = {
+            k: v if v.is_number else abs(v * (sigmoid(v, 20, 1) - sigmoid(v, 20.0, -1)))  # type: ignore [union-attr]
+            for k, v in weights.items()
+        }
+
+        return weights
+
+    def _constrain_max_vals(self) -> None:
+        # enforce constraints:
+        # 0 <= amp <= GLOBAL_MAX_AMPLITUDE
+        # 0 <= abs(det) <= GLOBAL_MAX_DETUNING
+        self.amp = abs(
+            self.amp
+            * (
+                Heaviside(self.amp + GLOBAL_MAX_AMPLITUDE)  # type: ignore [operator]
+                - Heaviside(self.amp - GLOBAL_MAX_AMPLITUDE)  # type: ignore [operator]
+            )
+        )
+        self.det = -abs(
+            self.det
+            * (
+                Heaviside(self.det + GLOBAL_MAX_DETUNING)
+                - Heaviside(self.det - GLOBAL_MAX_DETUNING)
+            )
+        )
+
+    def _create_local_constraint(self, val: Expr, weights: dict, max_val: float) -> dict:
+        # enforce local constraints:
+        # amp * w_amp_i < LOCAL_MAX_AMPLITUDE or
+        # abs(det) * w_det_i < LOCAL_MAX_DETUNING
+        local_constr = {k: val * v for k, v in weights.items()}
+        local_constr = {k: Heaviside(v) - Heaviside(v - max_val) for k, v in local_constr.items()}
+
+        return local_constr
+
+    def _create_global_constraint(self, val: Expr, weights: dict, max_val: float) -> Expr:
+        # enforce global constraints:
+        # amp * sum(w_amp_0, w_amp_1, ...) < GLOBAL_MAX_AMPLITUDE or
+        # abs(det) * sum(w_det_0, w_det_1, ...) < GLOBAL_MAX_DETUNING
+        weighted_vals_global = val * sum([v for v in weights.values()])
+        weighted_vals_global = Heaviside(weighted_vals_global) - Heaviside(
+            weighted_vals_global - max_val
+        )
+
+        return weighted_vals_global
+
+    def __post_init__(self) -> None:
+        # validate amplitude/detuning weights
+        self._validate_weights(self.weights_amp)
+        self._validate_weights(self.weights_det)
+
+        # validate maximum global amplitude/detuning values
+        if not isinstance(self.amp, (str, Parameter)):
+            if self.amp > GLOBAL_MAX_AMPLITUDE:
+                warn("Maximum absolute value of amplitude is exceeded")
+        elif isinstance(self.amp, str):
+            self.amp = Parameter(self.amp, trainable=True)
+        if not isinstance(self.det, (str, Parameter)):
+            if abs(self.det) > GLOBAL_MAX_DETUNING:
+                warn("Maximum absolute value of detuning is exceeded")
+        elif isinstance(self.det, str):
+            self.det = Parameter(self.det, trainable=True)
+
+        # constrain amplitude/detuning parameterized weights to [0.0, 1.0] interval
+        self.weights_amp = self._constrain_weights(self.weights_amp)
+        self.weights_det = self._constrain_weights(self.weights_det)
+
+        # constrain max global amplitude and detuning to strict interval
+        self._constrain_max_vals()
+
+        # create additional local and global constraints for amplitude/detuning masks
+        self.local_constr_amp = self._create_local_constraint(
+            self.amp, self.weights_amp, LOCAL_MAX_AMPLITUDE
+        )
+        self.local_constr_det = self._create_local_constraint(
+            -self.det, self.weights_det, LOCAL_MAX_DETUNING
+        )
+        self.global_constr_amp = self._create_global_constraint(
+            self.amp, self.weights_amp, GLOBAL_MAX_AMPLITUDE
+        )
+        self.global_constr_det = self._create_global_constraint(
+            -self.det, self.weights_det, GLOBAL_MAX_DETUNING
+        )
+
+        # validate number of qubits in mask
+        if max(list(self.weights_amp.keys())) >= self.n_qubits:
+            raise ValueError("Amplitude weight specified for non-existing qubit")
+        if max(list(self.weights_det.keys())) >= self.n_qubits:
+            raise ValueError("Detuning weight specified for non-existing qubit")
+
+    def evaluate(self, weights: dict, values: dict) -> dict:
+        # evaluate weight expressions with actual values
+        return {k: evaluate(v, values, as_torch=True).flatten() for k, v in weights.items()}  # type: ignore [union-attr]
+
+    def _to_dict(self) -> dict:
+        return {field.name: getattr(self, field.name) for field in fields(self)}
+
+    @classmethod
+    def _from_dict(cls, d: dict) -> AddressingPattern | None:
+        return cls(**d) if len(d) > 0 else None

qadence-1.2.1/qadence/analog/constants.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+# Ising coupling coefficient depending on the Rydberg level
+# Include a normalization to the Planck constant hbar
+# In units of [rad . µm^6 / µs]
+
+C6_DICT = {
+    50: 96120.72,
+    51: 122241.6,
+    52: 154693.02,
+    53: 194740.36,
+    54: 243973.91,
+    55: 304495.01,
+    56: 378305.98,
+    57: 468027.05,
+    58: 576714.85,
+    59: 707911.38,
+    60: 865723.02,
+    61: 1054903.11,
+    62: 1281042.11,
+    63: 1550531.15,
+    64: 1870621.31,
+    65: 2249728.57,
+    66: 2697498.69,
+    67: 3224987.51,
+    68: 3844734.37,
+    69: 4571053.32,
+    70: 5420158.53,
+    71: 6410399.4,
+    72: 7562637.31,
+    73: 8900342.14,
+    74: 10449989.62,
+    75: 12241414.53,
+    76: 14308028.03,
+    77: 16687329.94,
+    78: 19421333.62,
+    79: 22557029.94,
+    80: 26146720.74,
+    81: 30248886.65,
+    82: 34928448.69,
+    83: 40257623.67,
+    84: 46316557.88,
+    85: 53194043.52,
+    86: 60988354.64,
+    87: 69808179.15,
+    88: 79773468.88,
+    89: 91016513.07,
+    90: 103677784.57,
+    91: 117933293.96,
+    92: 133943541.9,
+    93: 151907135.94,
+    94: 172036137.34,
+    95: 194562889.89,
+    96: 219741590.56,
+    97: 247850178.91,
+    98: 279192193.77,
+    99: 314098829.39,
+    100: 352931119.11,
+}

qadence-1.2.1/qadence/analog/device.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, fields
+
+from torch import pi
+
+from qadence.analog import AddressingPattern
+from qadence.types import DeviceType, Interaction
+
+
+@dataclass(frozen=True, eq=True)
+class RydbergDevice:
+    """
+    Dataclass for interacting Rydberg atoms under an Hamiltonian:
+
+    H = ∑_i [Ω/2 * (cos(φ) * Xᵢ - sin(φ) * Yᵢ) - δ * N_i] + H_int,
+
+    where:
+
+    H_int = ∑_(j<i) (C_6 / R**6) * (N_i @ N_j) for the NN interaction;
+
+    H_int = ∑_(j<i) (C_3 / R**3) * ((X_i @ X_j) + (Y_i @ Y_j)) for the XY interaction;
+    """
+
+    interaction: Interaction = Interaction.NN
+    """Defines the interaction Hamiltonian."""
+
+    rydberg_level: int = 60
+    """Rydberg level affecting the value of C_6."""
+
+    coeff_xy: float = 3700.00
+    """Value of C_3."""
+
+    max_detuning: float = 2 * pi * 4
+    """Maximum value of the detuning δ."""
+
+    max_amp: float = 2 * pi * 3
+    """Maximum value of the amplitude Ω."""
+
+    pattern: AddressingPattern | None = None
+    """Semi-local addressing pattern configuration."""
+
+    type: DeviceType = DeviceType.IDEALIZED
+    """DeviceType.IDEALIZED or REALISTIC to convert to the Pulser backend."""
+
+    def __post_init__(self) -> None:
+        # FIXME: Currently not supporting custom interaction functions.
+        if self.interaction not in [Interaction.NN, Interaction.XY]:
+            raise KeyError(
+                "RydbergDevice currently only supports Interaction.NN or Interaction.XY."
+            )
+
+    def _to_dict(self) -> dict:
+        device_dict = {}
+        for field in fields(self):
+            if field.name != "pattern":
+                device_dict[field.name] = getattr(self, field.name)
+            else:
+                device_dict[field.name] = (
+                    self.pattern._to_dict() if self.pattern is not None else {}
+                )
+        return device_dict
+
+    @classmethod
+    def _from_dict(cls, d: dict) -> RydbergDevice:
+        pattern = AddressingPattern._from_dict(d["pattern"])
+        d["pattern"] = pattern
+        return cls(**d)
+
+
+def IdealDevice(pattern: AddressingPattern | None = None) -> RydbergDevice:
+    return RydbergDevice(
+        pattern=pattern,
+        type=DeviceType.IDEALIZED,
+    )
+
+
+def RealisticDevice(pattern: AddressingPattern | None = None) -> RydbergDevice:
+    return RydbergDevice(
+        pattern=pattern,
+        type=DeviceType.REALISTIC,
+    )