qilisdk 0.1.6__py3-none-any.whl → 0.1.7__py3-none-any.whl

qilisdk/speqtrum/speqtrum_models.py

@@ -18,6 +18,16 @@ from typing import Any, Callable, Generic, TypeVar, cast, overload
 
 from pydantic import AwareDatetime, BaseModel, ConfigDict, Field, field_serializer, field_validator
 
+from qilisdk.experiments import (
+    RabiExperiment,
+    RabiExperimentResult,
+    T1Experiment,
+    T1ExperimentResult,
+    T2Experiment,
+    T2ExperimentResult,
+    TwoTonesExperiment,
+    TwoTonesExperimentResult,
+)
 from qilisdk.functionals import (
     Sampling,
     SamplingResult,
@@ -27,7 +37,6 @@ from qilisdk.functionals import (
     VariationalProgramResult,
 )
 from qilisdk.functionals.functional_result import FunctionalResult
-from qilisdk.speqtrum.experiments import RabiExperiment, RabiExperimentResult, T1Experiment, T1ExperimentResult
 from qilisdk.utils.serialization import deserialize, serialize
 
 
@@ -52,7 +61,7 @@ class Token(SpeQtrumModel):
 
     access_token: str = Field(alias="accessToken")
     expires_in: int = Field(alias="expiresIn")
-    issued_at: str = Field(alias="issuedAt")
+    issued_at: int = Field(alias="issuedAt")
     refresh_token: str = Field(alias="refreshToken")
     token_type: str = Field(alias="tokenType")
 
@@ -88,6 +97,8 @@ class ExecuteType(str, Enum):
     VARIATIONAL_PROGRAM = "variational_program"
     RABI_EXPERIMENT = "rabi_experiment"
     T1_EXPERIMENT = "t1_experiment"
+    T2_EXPERIMENT = "t2_experiment"
+    TWO_TONES_EXPERIMENT = "two_tones_experiment"
 
 
 class SamplingPayload(SpeQtrumModel):
@@ -160,6 +171,34 @@ class T1ExperimentPayload(SpeQtrumModel):
         return v
 
 
+class T2ExperimentPayload(SpeQtrumModel):
+    t2_experiment: T2Experiment = Field(...)
+
+    @field_serializer("t2_experiment")
+    def _serialize_t2_experiment(self, t2_experiment: T2Experiment, _info):
+        return serialize(t2_experiment)
+
+    @field_validator("t2_experiment", mode="before")
+    def _load_t2_experiment(cls, v):
+        if isinstance(v, str):
+            return deserialize(v, T2Experiment)
+        return v
+
+
+class TwoTonesExperimentPayload(SpeQtrumModel):
+    two_tones_experiment: TwoTonesExperiment = Field(...)
+
+    @field_serializer("two_tones_experiment")
+    def _serialize_two_tones_experiment(self, two_tones_experiment: TwoTonesExperiment, _info):
+        return serialize(two_tones_experiment)
+
+    @field_validator("two_tones_experiment", mode="before")
+    def _load_two_tones_experiment(cls, v):
+        if isinstance(v, str):
+            return deserialize(v, TwoTonesExperiment)
+        return v
+
+
 class ExecutePayload(SpeQtrumModel):
     type: ExecuteType = Field(...)
     sampling_payload: SamplingPayload | None = None
@@ -167,6 +206,8 @@ class ExecutePayload(SpeQtrumModel):
     variational_program_payload: VariationalProgramPayload | None = None
     rabi_experiment_payload: RabiExperimentPayload | None = None
     t1_experiment_payload: T1ExperimentPayload | None = None
+    t2_experiment_payload: T2ExperimentPayload | None = None
+    two_tones_experiment_payload: TwoTonesExperimentPayload | None = None
 
 
 class ExecuteResult(SpeQtrumModel):
@@ -176,6 +217,8 @@ class ExecuteResult(SpeQtrumModel):
     variational_program_result: VariationalProgramResult | None = None
     rabi_experiment_result: RabiExperimentResult | None = None
     t1_experiment_result: T1ExperimentResult | None = None
+    t2_experiment_result: T2ExperimentResult | None = None
+    two_tones_experiment_result: TwoTonesExperimentResult | None = None
 
     @field_serializer("sampling_result")
     def _serialize_sampling_result(self, sampling_result: SamplingResult, _info):
@@ -227,12 +270,32 @@ class ExecuteResult(SpeQtrumModel):
             return deserialize(v, T1ExperimentResult)
         return v
 
+    @field_serializer("t2_experiment_result")
+    def _serialize_t2_experiment_resultt(self, t2_experiment_result: T2ExperimentResult, _info):
+        return serialize(t2_experiment_result) if t2_experiment_result is not None else None
 
-ResultT_co = TypeVar("ResultT_co", bound=FunctionalResult, covariant=True)
-VariationalInnerResultT = TypeVar("VariationalInnerResultT", bound=FunctionalResult)
+    @field_validator("t2_experiment_result", mode="before")
+    def _load_t2_experiment_result(cls, v):
+        if isinstance(v, str) and v.startswith("!"):
+            return deserialize(v, T2ExperimentResult)
+        return v
 
+    @field_serializer("two_tones_experiment_result")
+    def _serialize_two_tones_experiment_result(self, two_tones_experiment_result: TwoTonesExperimentResult, _info):
+        return serialize(two_tones_experiment_result) if two_tones_experiment_result is not None else None
+
+    @field_validator("two_tones_experiment_result", mode="before")
+    def _load_two_tones_experiment_result(cls, v):
+        if isinstance(v, str) and v.startswith("!"):
+            return deserialize(v, TwoTonesExperimentResult)
+        return v
+
+
+TFunctionalResult_co = TypeVar("TFunctionalResult_co", bound=FunctionalResult, covariant=True)
+TVariationalInnerResult = TypeVar("TVariationalInnerResult", bound=FunctionalResult)
 
-ResultExtractor = Callable[[ExecuteResult], ResultT_co]
+
+ResultExtractor = Callable[[ExecuteResult], TFunctionalResult_co]
 
 
 # these helpers live outside the models so they can be referenced by default values
@@ -266,10 +329,24 @@ def _require_t1_experiment_result(result: ExecuteResult) -> T1ExperimentResult:
     return result.t1_experiment_result
 
 
+def _require_t2_experiment_result(result: ExecuteResult) -> T2ExperimentResult:
+    if result.t2_experiment_result is None:
+        raise RuntimeError("SpeQtrum did not return a t2_experiment_result for a T2 experiment execution.")
+    return result.t2_experiment_result
+
+
+def _require_two_tones_experiment_result(result: ExecuteResult) -> TwoTonesExperimentResult:
+    if result.two_tones_experiment_result is None:
+        raise RuntimeError(
+            "SpeQtrum did not return a two_tones_experiment_result for a Two-Tones experiment execution."
+        )
+    return result.two_tones_experiment_result
+
+
 def _require_variational_program_result_typed(
-    inner_result_type: type[VariationalInnerResultT],
-) -> ResultExtractor[VariationalProgramResult[VariationalInnerResultT]]:
-    def _extractor(result: ExecuteResult) -> VariationalProgramResult[VariationalInnerResultT]:
+    inner_result_type: type[TVariationalInnerResult],
+) -> ResultExtractor[VariationalProgramResult[TVariationalInnerResult]]:
+    def _extractor(result: ExecuteResult) -> VariationalProgramResult[TVariationalInnerResult]:
         variational_result = _require_variational_program_result(result)
         optimal_results = variational_result.optimal_execution_results
         if not isinstance(optimal_results, inner_result_type):
@@ -278,17 +355,17 @@ def _require_variational_program_result_typed(
                 f"({type(optimal_results).__qualname__}) does not match the expected "
                 f"{inner_result_type.__qualname__}."
             )
-        return cast("VariationalProgramResult[VariationalInnerResultT]", variational_result)
+        return cast("VariationalProgramResult[TVariationalInnerResult]", variational_result)
 
     return _extractor
 
 
-class JobHandle(SpeQtrumModel, Generic[ResultT_co]):
+class JobHandle(SpeQtrumModel, Generic[TFunctionalResult_co]):
     """Strongly typed reference to a submitted SpeQtrum job."""
 
     id: int
     execute_type: ExecuteType
-    extractor: ResultExtractor[ResultT_co] = Field(repr=False, exclude=True)
+    extractor: ResultExtractor[TFunctionalResult_co] = Field(repr=False, exclude=True)
 
     @classmethod
     def sampling(cls, job_id: int) -> "JobHandle[SamplingResult]":
@@ -305,12 +382,12 @@ class JobHandle(SpeQtrumModel, Generic[ResultT_co]):
     @overload
     @classmethod
     def variational_program(
-        cls, job_id: int, *, result_type: type[VariationalInnerResultT]
-    ) -> "JobHandle[VariationalProgramResult[VariationalInnerResultT]]": ...
+        cls, job_id: int, *, result_type: type[TVariationalInnerResult]
+    ) -> "JobHandle[VariationalProgramResult[TVariationalInnerResult]]": ...
 
     @classmethod
     def variational_program(
-        cls, job_id: int, *, result_type: type[VariationalInnerResultT] | None = None
+        cls, job_id: int, *, result_type: type[TVariationalInnerResult] | None = None
     ) -> "JobHandle[Any]":
         """Create a variational-program handle for an existing job identifier.
 
@@ -335,7 +412,7 @@ class JobHandle(SpeQtrumModel, Generic[ResultT_co]):
 
         extractor = _require_variational_program_result_typed(result_type)
         handle = cls(id=job_id, execute_type=ExecuteType.VARIATIONAL_PROGRAM, extractor=extractor)  # type: ignore[arg-type]
-        return cast("JobHandle[VariationalProgramResult[VariationalInnerResultT]]", handle)
+        return cast("JobHandle[VariationalProgramResult[TVariationalInnerResult]]", handle)
 
     @classmethod
     def rabi_experiment(cls, job_id: int) -> "JobHandle[RabiExperimentResult]":
@@ -345,7 +422,19 @@ class JobHandle(SpeQtrumModel, Generic[ResultT_co]):
     def t1_experiment(cls, job_id: int) -> "JobHandle[T1ExperimentResult]":
         return cls(id=job_id, execute_type=ExecuteType.T1_EXPERIMENT, extractor=_require_t1_experiment_result)  # type: ignore[return-value, arg-type]
 
-    def bind(self, detail: "JobDetail") -> "TypedJobDetail[ResultT_co]":
+    @classmethod
+    def t2_experiment(cls, job_id: int) -> "JobHandle[T2ExperimentResult]":
+        return cls(id=job_id, execute_type=ExecuteType.T2_EXPERIMENT, extractor=_require_t2_experiment_result)  # type: ignore[return-value, arg-type]
+
+    @classmethod
+    def two_tones_experiment(cls, job_id: int) -> "JobHandle[TwoTonesExperimentResult]":
+        return cls(
+            id=job_id,
+            execute_type=ExecuteType.TWO_TONES_EXPERIMENT,
+            extractor=_require_two_tones_experiment_result,  # type: ignore[return-value, arg-type]
+        )
+
+    def bind(self, detail: "JobDetail") -> "TypedJobDetail[TFunctionalResult_co]":
         """Attach this handle's typing information to a concrete job detail.
 
         Args:
@@ -438,13 +527,13 @@ class JobDetail(JobInfo):
     error_logs: str | None = None
 
 
-class TypedJobDetail(JobDetail, Generic[ResultT_co]):
+class TypedJobDetail(JobDetail, Generic[TFunctionalResult_co]):
     """`JobDetail` subclass that exposes a strongly typed `get_results` method."""
 
     expected_type: ExecuteType = Field(repr=False)
-    extractor: ResultExtractor[ResultT_co] = Field(repr=False, exclude=True)
+    extractor: ResultExtractor[TFunctionalResult_co] = Field(repr=False, exclude=True)
 
-    def get_results(self) -> ResultT_co:
+    def get_results(self) -> TFunctionalResult_co:
         """Return the strongly typed execution result.
 
         Returns:

qilisdk/utils/openfermion/__init__.py

@@ -0,0 +1,38 @@
+# Copyright 2025 Qilimanjaro Quantum Tech
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import sys
+
+from qilisdk._optionals import ImportedFeature, OptionalFeature, Symbol, import_optional_dependencies
+
+__all__ = []
+
+OPTIONAL_FEATURES: list[OptionalFeature] = [
+    OptionalFeature(
+        name="openfermion",
+        dependencies=["openfermion"],
+        symbols=[
+            Symbol(path="qilisdk.utils.openfermion.openfermion", name="openfermion_to_qilisdk"),
+            Symbol(path="qilisdk.utils.openfermion.openfermion", name="qilisdk_to_openfermion"),
+        ],
+    ),
+]
+
+current_module = sys.modules[__name__]
+
+# Dynamically import (or stub) each feature's symbols and attach them
+for feature in OPTIONAL_FEATURES:
+    imported_feature: ImportedFeature = import_optional_dependencies(feature)
+    for symbol_name, symbol_obj in imported_feature.symbols.items():
+        setattr(current_module, symbol_name, symbol_obj)
+        __all__ += [symbol_name]  # noqa: PLE0604

qilisdk/{core/algorithm.py → utils/openfermion/__init__.pyi}

@@ -11,8 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-from abc import ABC
 
+from .openfermion import openfermion_to_qilisdk, qilisdk_to_openfermion
 
-class Algorithm(ABC):
-    """Abstract base class for SDK algorithms."""
+__all__ = ["openfermion_to_qilisdk", "qilisdk_to_openfermion"]

qilisdk/utils/openfermion/openfermion.py

@@ -0,0 +1,45 @@
+# Copyright 2025 Qilimanjaro Quantum Tech
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from openfermion import QubitOperator
+
+from qilisdk.analog import Hamiltonian, PauliI, PauliX, PauliY, PauliZ
+
+
+def openfermion_to_qilisdk(qubit_operator: QubitOperator) -> Hamiltonian:
+    pauli_map = {"X": PauliX, "Y": PauliY, "Z": PauliZ}
+
+    return Hamiltonian(
+        {
+            (tuple((pauli_map[op](q)) for q, op in term) if len(term) > 0 else (PauliI(0),)): coeff
+            for term, coeff in qubit_operator.terms.items()
+        }
+    )
+
+
+def qilisdk_to_openfermion(hamiltonian: Hamiltonian) -> QubitOperator:
+    of_ham = QubitOperator()
+
+    for coeff, terms in hamiltonian:
+        of_term = ""
+        for t in terms:
+            if isinstance(t, PauliI):
+                continue
+
+            of_term += str(t).replace("(", "").replace(")", "") + " "
+        of_term = of_term.rstrip()
+
+        of_ham += QubitOperator(of_term, coeff)
+
+    return of_ham

qilisdk/utils/visualization/schedule_renderers.py

@@ -18,6 +18,7 @@ from __future__ import annotations
 from typing import TYPE_CHECKING
 
 import matplotlib.pyplot as plt
+import numpy as np
 
 if TYPE_CHECKING:
     from qilisdk.analog.schedule import Schedule
@@ -29,7 +30,13 @@ from qilisdk.utils.visualization.style import ScheduleStyle
 class MatplotlibScheduleRenderer:
     """Render a Schedule using matplotlib, with theme support."""
 
-    def __init__(self, schedule: Schedule, ax: plt.Axes | None = None, *, style: ScheduleStyle | None = None) -> None:
+    def __init__(
+        self,
+        schedule: Schedule,
+        ax: plt.Axes | None = None,
+        *,
+        style: ScheduleStyle | None = None,
+    ) -> None:
         self.schedule = schedule
         self.style = style or ScheduleStyle()
         self.ax = ax or self._make_axes(self.style.dpi, self.style)
@@ -57,13 +64,14 @@ class MatplotlibScheduleRenderer:
         T = self.schedule.T
         dt = self.schedule.dt
         hamiltonians = self.schedule.hamiltonians
-        times = [i * dt for i in range(int(T / dt))]
+        times = list(np.linspace(0, T, int(1 / dt), dtype=float))  # [i * dt for i in range(int((T + dt) / dt))]
+        for t in self.schedule.tlist:
+            if t not in times:
+                times.append(t)
+        times = sorted(times)
         for h in hamiltonians:
-            plots[h] = []
-        for _t in range(int(T / dt)):
-            t = _t * dt
-            for h in hamiltonians:
-                plots[h].append(self.schedule.get_coefficient(t, h))
+            coef = self.schedule.coefficients[h]
+            plots[h] = [coef[float(t)] for t in times]
 
         # Generate gradient colors between primary and accent
         def hex_to_rgb(hex_color: str) -> tuple[int, ...]:
@@ -162,5 +170,5 @@ class MatplotlibScheduleRenderer:
         Returns:
             A newly created Matplotlib Axes.
         """
-        _, ax = plt.subplots(figsize=style.figsize, dpi=style.dpi, facecolor=style.theme.background)
+        _, ax = plt.subplots(figsize=style.figsize, dpi=dpi or style.dpi, facecolor=style.theme.background)
         return ax

{qilisdk-0.1.6.dist-info → qilisdk-0.1.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qilisdk
-Version: 0.1.6
+Version: 0.1.7
 Summary: QiliSDK is a Python framework for writing digital and analog quantum algorithms and executing them across multiple quantum backends. Its modular design streamlines the development process and enables easy integration with a variety of quantum platforms.
 Project-URL: Homepage, https://github.com/qilimanjaro-tech/qilisdk
 Project-URL: Documentation, https://qilimanjaro-tech.github.io/qilisdk/
@@ -10,35 +10,39 @@ Project-URL: Changelog, https://github.com/qilimanjaro-tech/qilisdk/blob/main/CH
 Author-email: Qilimanjaro Quantum Tech <info@qilimanjaro.tech>
 License-File: LICENCE
 Keywords: analog quantum computing,digital quantum computing,qilimanjaro,quantum computing
-Classifier: Development Status :: 3 - Alpha
+Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: POSIX :: Linux
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering
 Classifier: Topic :: Scientific/Engineering :: Physics
 Classifier: Topic :: Scientific/Engineering :: Quantum Computing
-Requires-Python: >=3.10
+Requires-Python: >=3.11
 Requires-Dist: dill>=0.3.9
 Requires-Dist: loguru>=0.7.3
 Requires-Dist: matplotlib>=3.10.7
-Requires-Dist: numpy>=1.26.4
+Requires-Dist: mkl-service>=2.4.2; sys_platform != 'darwin'
+Requires-Dist: numpy>=2.2.0
 Requires-Dist: pydantic-settings>=2.11.0
 Requires-Dist: pydantic>=2.12.3
 Requires-Dist: ruamel-yaml>=0.18.16
-Requires-Dist: scipy>=1.15.3
+Requires-Dist: scipy<1.16.3,>=1.15; sys_platform != 'darwin'
+Requires-Dist: scipy>=1.16.3; sys_platform == 'darwin'
 Provides-Extra: cuda
-Requires-Dist: cuda-quantum-cu12==0.12.0.post1; extra == 'cuda'
+Requires-Dist: cuda-quantum-cu12==0.13.0; extra == 'cuda'
+Provides-Extra: openfermion
+Requires-Dist: openfermion>=1.7.1; extra == 'openfermion'
 Provides-Extra: qutip
 Requires-Dist: qutip-qip>=0.4.1; extra == 'qutip'
-Requires-Dist: qutip>=5.2.1; extra == 'qutip'
+Requires-Dist: qutip>=5.2.2; extra == 'qutip'
 Provides-Extra: speqtrum
-Requires-Dist: httpx>=0.28.1; extra == 'speqtrum'
+Requires-Dist: httpx==0.28.1; extra == 'speqtrum'
 Requires-Dist: keyring>=25.6.0; extra == 'speqtrum'
 Requires-Dist: keyrings-alt>=5.0.2; extra == 'speqtrum'
 Description-Content-Type: text/markdown
@@ -48,6 +52,7 @@ Description-Content-Type: text/markdown
 [![Python Versions](https://img.shields.io/pypi/pyversions/qilisdk.svg)](https://pypi.org/project/qilisdk/)
 [![PyPI Version](https://img.shields.io/pypi/v/qilisdk.svg)](https://pypi.org/project/qilisdk/)
 [![License](https://img.shields.io/pypi/l/qilisdk.svg)](#license)
+[![Docs](https://img.shields.io/badge/docs-latest-pink.svg)](https://qilimanjaro-tech.github.io/qilisdk/main/index.html)
 
 **QiliSDK** is a Python framework for writing digital and analog quantum algorithms and executing them across multiple quantum backends. Its modular design streamlines the development process and enables easy integration with a variety of quantum platforms.
 
@@ -202,18 +207,27 @@ print("Optimal Parameters:", result.optimal_parameters)
 QiliSDK includes a client for interacting with Qilimanjaro's SpeQtrum platform. This module supports secure login and a unified interface for both digital circuits and analog evolutions:
 
 ```python
-from qilisdk.speqtrum import SpeQtrum
+from qilisdk.backends import CudaBackend, CudaSamplingMethod
+from qilisdk.digital import Circuit, H, M
 from qilisdk.functionals import Sampling
+from qilisdk.speqtrum import SpeQtrum
+
+
+# Build a single-qubit circuit
+circuit = Circuit(nqubits=1)
+circuit.add(H(0))
+circuit.add(M(0))
 
 # Login to QaaSBackend with credentials (or use environment variables)
 # This only needs to be run once.
-SpeQtrum.login(username="your_username", apikey="your_apikey")
+SpeQtrum.login(username="YOUR_USERNAME", apikey="YOUR_APIKEY")
 
 # Instantiate QaaSBackend
 client = SpeQtrum()
 
-# # Execute a pre-built circuit (see Digital Quantum Circuits section)
-job_id = client.submit(Sampling(circuit, 1000), device="cuda_state_vector")
+# Execute a pre-built circuit (see Digital Quantum Circuits section)
+# make sure to select the device (you can list available devices using ``client.list_devices()``)
+job_id = client.submit(Sampling(circuit, 1000), device="SELECTED_DEVICE")
 print("job id:", job_id)
 print("job status:", client.get_job(job_id).status)
 print("job result:", client.get_job(job_id).result)
@@ -241,18 +255,17 @@ print("CUDA Backend Results:", results)
 
 ### Time Evolution using Qutip
 
-For analog simulations, the new `TimeEvolution` and `Schedule` classes allow you to simulate time-dependent quantum dynamics. The following example uses a linear schedule to interpolate between two Hamiltonians on a Qutip backend:
+For analog simulations, the `TimeEvolution` and unified `Schedule` classes allow you to simulate time-dependent quantum dynamics. The following example uses callable coefficients defined over an interval to interpolate between two Hamiltonians on a Qutip backend:
 
 ```python
-import numpy as np
 from qilisdk.analog import Schedule, X, Z, Y
 from qilisdk.core import ket, tensor_prod
 from qilisdk.backends import QutipBackend
 from qilisdk.functionals import TimeEvolution
 
 # Define total time and timestep
-T = 100
-steps = np.linspace(0, T, T)
+T = 100.0
+dt = 0.1
 nqubits = 1
 
 # Define Hamiltonians
@@ -260,13 +273,14 @@ Hx = sum(X(i) for i in range(nqubits))
 Hz = sum(Z(i) for i in range(nqubits))
 
 # Build a time‑dependent schedule
-schedule = Schedule(T)
-
-# Add hx with a time‐dependent coefficient function
-schedule.add_hamiltonian(label="hx", hamiltonian=Hx, schedule=lambda t: 1 - steps[t] / T)
-
-# Add hz similarly
-schedule.add_hamiltonian(label="hz", hamiltonian=Hz, schedule=lambda t: steps[t] / T)
+schedule = Schedule(
+    hamiltonians={"hx": Hx, "hz": Hz},
+    coefficients={
+        "hx": {(0.0, T): lambda t: 1 - t / T},
+        "hz": {(0.0, T): lambda t: t / T},
+    },
+    dt=dt,
+)
 
 # draw the schedule
 schedule.draw()
@@ -418,6 +432,42 @@ print("Reconstructed Circuit:")
 restored_circuit.draw()
 ```
 
+### OpenFermion Integration
+
+`QiliSDK` can translate ``QubitOperator`` objects from ``OpenFermion`` to ``QiliSDK``'s ``Hamiltonian`` Objects and vice versa.
+
+This code is available under an optional dependency that can be installed using ``pip install qilisdk[openfermion]``.
+
+here is an example of the usage: 
+```python
+from openfermion.hamiltonians import jellium_model
+from openfermion.transforms import fourier_transform, jordan_wigner
+from openfermion.utils import Grid
+
+from qilisdk.utils.openfermion import openfermion_to_qilisdk, qilisdk_to_openfermion
+
+# Let's look at a very small model of jellium in 1D.
+grid = Grid(dimensions=1, length=3, scale=1.0)
+spinless = True
+
+# Get the momentum Hamiltonian.
+momentum_hamiltonian = jellium_model(grid, spinless)
+momentum_qubit_operator = jordan_wigner(momentum_hamiltonian)
+momentum_qubit_operator.compress()
+
+# Fourier transform the Hamiltonian to the position basis.
+position_hamiltonian = fourier_transform(momentum_hamiltonian, grid, spinless)
+position_qubit_operator = jordan_wigner(position_hamiltonian)
+position_qubit_operator.compress()
+
+qilisdk_ham = openfermion_to_qilisdk(position_qubit_operator)
+openfermion_ham = qilisdk_to_openfermion(qilisdk_ham)
+
+```
+
+
+
+
 ---
 
 ## Development