qilisdk 0.1.5__tar.gz → 0.1.7__tar.gz

{qilisdk-0.1.5 → qilisdk-0.1.7}/.gitignore

@@ -22,3 +22,5 @@ wheels/
 # Sphinx documentation
 docs/_build/*
 docs/code/api/*
+sphinx-verbose.log
+sphinx.log

qilisdk-0.1.7/.python-version

@@ -0,0 +1 @@
+3.13

{qilisdk-0.1.5 → qilisdk-0.1.7}/CHANGELOG.md

@@ -1,3 +1,167 @@
+# qilisdk 0.1.7 (2025-12-04)
+
+## Features
+
+- SpeQtrum's synchronous client now runs every request through a shared HTTPX client that refreshes bearer tokens automatically, ensuring submissions, listings, and polling continue seamlessly after 401s while still applying the SDK user agent. API failures now raise a dedicated SpeQtrum error that includes the message returned by the service and is logged in a human-friendly way, and job detail payloads, logs, and results are decoded defensively so malformed base64 no longer crashes the SDK. ([PR #94](https://github.com/qilimanjaro-tech/qilisdk/pulls/94))
+- Added a ``QiliSDK`` to ``OpenFermion`` converter. This allows to translate ``QubitOperator`` from ``OpenFermion`` to ``QiliSDK``'s ``Hamiltonian`` Objects and vice versa.
+
+  This optional 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)
+  ``` 
+  ([PR #96](https://github.com/qilimanjaro-tech/qilisdk/pulls/96))
+- Raised the SDK baseline to Python 3.11 and aligned the local version file, mypy config, CI tests, docs build, and publishing workflow up to Python 3.13. Linux and Windows installs use customized NumPy and SciPy, linked to Intel's high-performance oneAPI Math Kernel Library (Intel MKL). ([PR #99](https://github.com/qilimanjaro-tech/qilisdk/pulls/99))
+- Constraint-aware execution now threads through sampling, time evolution, variational programs, and optimizer loops, rejecting parameter sets that violate declared constraints; tests and serialization use the new APIs.
+
+  ```python
+  from qilisdk.core import GreaterThanOrEqual, Parameter
+  from qilisdk.functionals import Sampling, VariationalProgram
+
+  # Constrain theta >= phi for a variational run; violations short-circuit the optimizer step.
+  theta = Parameter("theta", 0.4, bounds=(0, 1))
+  phi = Parameter("phi", 0.3, bounds=(0, 1))
+  constraints = [GreaterThanOrEqual(theta, phi)]
+
+  vp = VariationalProgram(
+      functional=Sampling(...),
+      optimizer=...,
+      cost_function=...,
+      parameter_constraints=constraints,
+  )
+  ```
+  ([PR #100](https://github.com/qilimanjaro-tech/qilisdk/pulls/100))
+- Rebuilt analog scheduling around a single, flexible `Schedule`/`Interpolator`: `LinearSchedule` is removed, coefficients can be defined as callables or time intervals with step/linear interpolation, max-time rescaling, shared parameter tracking, and updated visualization/backends.
+
+  Centralized parameter management in `Parameterizable` so Hamiltonians, circuits, schedules, and gates all inherit consistent parameter getters/setters, constraint checking, and validation; variables add comparison helpers, caching, and math maps.
+
+  ```python
+  from qilisdk.analog import Schedule, X, Z
+  from qilisdk.analog.schedule import Interpolation
+  from qilisdk.core import Parameter
+
+  T = 10.0
+  schedule = Schedule(
+      hamiltonians={"driver": X(0), "problem": Z(0)},
+      coefficients={
+          # Interval syntax expands to sampled points; callables can reference time directly.
+          "driver": {(0, T): lambda t: 1 - t / T},
+          "problem": {(0, T): lambda t: t / T},
+      },
+      dt=0.5,
+      interpolation=Interpolation.LINEAR,
+  )
+  schedule.scale_max_time(Parameter("T_max", 8.0))
+  schedule.draw()
+  ```
+  ([PR #100](https://github.com/qilimanjaro-tech/qilisdk/pulls/100))
+- Introduced the first version of the `CircuitTranspiler` alongside the `DecomposeMultiControlledGatesPass` that decomposes any multi-controlled single-qubit gate, enabling both CUDA and QuTiP backends to execute circuits containing such constructs. The pass is wired directly into both backends today while the full transpiler pipeline is staged for future expansion. ([PR #101](https://github.com/qilimanjaro-tech/qilisdk/pulls/101))
+
+## Bugfixes
+
+- Fixed `Schedule.add_hamiltonian` so time-dependent coefficient functions populate every discrete time step.
+
+  Added regression tests to cover function-driven schedules and validate that only parameters appear in the generated coefficients. ([PR #95](https://github.com/qilimanjaro-tech/qilisdk/pulls/95))
+
+## Improved Documentation
+
+- Documentation refresh across the project:
+
+  - README now links to the hosted docs and the SpeQtrum snippet walks through building a circuit, logging in, picking a device, and submitting a `Sampling` job.
+  - Digital fundamentals gained a rendered circuit figure, QuTiP execution example for `HardwareEfficientAnsatz`, a clarified measurement note, and a new “build your own ansatz” walkthrough with code.
+  - Analog fundamentals had their operator headings cleaned up, and the shared custom CSS now ships Plus Jakarta Sans, gradient headers, and dark-mode inline-code styling; the circuit diagram image is tracked under `_static/`.
+  - The `time_evolution.ipynb` example notebook was stripped of bulky outputs/metadata to keep the repo lightweight.
+  - Installation docs call out CUDA GPU requirements and defer hands-on content to a brand-new Quickstart guide (added to the index) that hosts the digital and analog walkthroughs plus backend-specific notes.
+  - Backend fundamentals now highlight how to install optional extras and link back to the Installation guide for details.
+
+  ([PR #97](https://github.com/qilimanjaro-tech/qilisdk/pulls/97))
+- Removed `main` branch from documentation. Sorted tags by descending order. (latest is first) ([PR #104](https://github.com/qilimanjaro-tech/qilisdk/pulls/104))
+- Docs publishing now points the root of the site to the latest release docs and keeps "main" as a clearly labeled development build, with the version picker reorganized into separate Releases and Development sections so visitors land on the most current tag while still finding the dev docs easily. ([PR #109](https://github.com/qilimanjaro-tech/qilisdk/pulls/109))
+- Fixed a display bug in which inline code blocks in headers were invisible. This was due to the previous rule only accounting for "a" elements in headers and not ".pre" span elements. The reason there was a ".pre" block in the header is because of a broken class link, which will be fixed along with others in a different PR. ([PR #114](https://github.com/qilimanjaro-tech/qilisdk/pulls/114))
+- Fixed a number of broken/missing API links in the docs and in general made the docs consistent with the API reference.
+
+  Also:
+   - Remove references to optimize() since it has since been moved into execute()
+   - Fixed a broken output box
+   - Fixed several lists that weren't displaying correctly
+   - Removed an unused import from a code block in core.rst
+   - Various other typos, such as missing "a"s before certain terms (keeping consistency with previous uses of said terms)
+   - Wrapped some very long lines (as per the style throughout the rest of the files) ([PR #120](https://github.com/qilimanjaro-tech/qilisdk/pulls/120))
+
+## Misc
+
+- [PR #104](https://github.com/qilimanjaro-tech/qilisdk/pulls/104), [PR #106](https://github.com/qilimanjaro-tech/qilisdk/pulls/106)
+
+
+# qilisdk 0.1.6 (2025-10-31)
+
+## Features
+
+- Added ``job_name`` to speqtrum's ``submit`` method to allow the user to give a custom name to their job. ([PR #86](https://github.com/qilimanjaro-tech/qilisdk/pulls/86))
+- SpeQtrum jobs now retain their concrete result types from submission through retrieval, so every handle produced by `submit` returns the right `FunctionalResult` whether you are sampling, evolving in time, or orchestrating a variational loop. Waiting for a fresh job still takes a single call, but the typed detail that comes back no longer needs manual casting:
+
+  ```python
+  job_handle = speqtrum.submit(Sampling(circuit), device="cuda_state_vector")
+  job = speqtrum.wait_for_job(job_handle)
+  results = job.get_results()  # Your IDE will now know this is a SamplingResult
+  ```
+
+  The same strong typing applies when inspecting historical runs. Recreate a handle with the appropriate class method, pass it to `get_job`, and the returned `TypedJobDetail` exposes the precise payload you expect:
+
+  ```python
+  job_handle = JobHandle.sampling(1200853)
+  job = speqtrum.get_job(job_handle)
+  results = job.get_results()  # Your IDE will now know this is a SamplingResult
+  ```
+
+  Variational programs are the only scenario that needs an extra hint: because they wrap another functional, recreate the handle with the inner functional’s result type so the execution results can be validated against your expectations:
+
+  ```python
+  job_handle = JobHandle.variational_program(1200853, result_type=SamplingResult)
+  job = speqtrum.get_job(job_handle)
+  results = job.get_results()  # Your IDE will now know this is a VariationalProgramResult
+  optimal = results.optimal_execution_results  # Your IDE will now know this is a SamplingResult
+  ```
+
+  Passing a bare integer job identifier to `wait_for_job` or `get_job` remains valid for quick checks and backwards-compatibility, but doing so skips the handle metadata and yields an untyped `JobDetail`, so you will need to inspect or cast the result manually. ([PR #87](https://github.com/qilimanjaro-tech/qilisdk/pulls/87))
+
+## Bugfixes
+
+- Fixed the `HardwareEfficientAnsatz` so the first layer of single-qubit gates is not duplicated, restoring the expected gate and parameter counts. ([PR #90](https://github.com/qilimanjaro-tech/qilisdk/pulls/90))
+- Fixed the scheduler so numpy floats are accepted without errors. Fixed the QuTiP backend by aligning the schedule-to-backend mapping structure. ([PR #91](https://github.com/qilimanjaro-tech/qilisdk/pulls/91))
+
+## Improved Documentation
+
+- Updating the documentation and README to correspond to the latest version of QiliSDK. ([PR #80](https://github.com/qilimanjaro-tech/qilisdk/pulls/80))
+- Added extra doc-strings, and fixed outdated doc-strings. ([PR #84](https://github.com/qilimanjaro-tech/qilisdk/pulls/84))
+
+## Misc
+
+- [PR #88](https://github.com/qilimanjaro-tech/qilisdk/pulls/88), [PR #92](https://github.com/qilimanjaro-tech/qilisdk/pulls/92)
+
+
 # qilisdk 0.1.5 (2025-10-17)
 
 ## Features

{qilisdk-0.1.5 → qilisdk-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qilisdk
-Version: 0.1.5
+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.2
-Requires-Dist: ruamel-yaml>=0.18.15
-Requires-Dist: scipy>=1.15.3
+Requires-Dist: pydantic>=2.12.3
+Requires-Dist: ruamel-yaml>=0.18.16
+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; 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.
 
@@ -58,15 +63,15 @@ Description-Content-Type: text/markdown
   - [Table of Contents](#table-of-contents)
   - [Installation](#installation)
     - [Base Installation](#base-installation)
-    - [Optional Extras](#optional-extras)
+    - [Optional Dependencies: speqtrum, cuda, qutip](#optional-dependencies-speqtrum-cuda-qutip)
   - [Usage](#usage)
     - [Digital Quantum Circuits](#digital-quantum-circuits)
-    - [Hamiltonian and Analog Operations](#hamiltonian-and-analog-operations)
+    - [Hamiltonians](#hamiltonians)
     - [Optimizers](#optimizers)
-    - [Quantum-as-a-Service (QaaS)](#quantum-as-a-service-qaas)
-    - [CUDA-Accelerated Simulation](#cuda-accelerated-simulation)
-    - [Time Evolution](#time-evolution)
-    - [Variational Quantum Eigensolver (VQE)](#variational-quantum-eigensolver-vqe)
+    - [Qilimanjaro SpeQtrum](#qilimanjaro-speqtrum)
+    - [Sample a quantum Circuit Using a CUDA-Accelerated Simulator](#sample-a-quantum-circuit-using-a-cuda-accelerated-simulator)
+    - [Time Evolution using Qutip](#time-evolution-using-qutip)
+    - [Variational Programs](#variational-programs)
     - [Open QASM Serialization](#open-qasm-serialization)
     - [YAML Serialization](#yaml-serialization)
   - [Development](#development)
@@ -94,7 +99,7 @@ Install the core QiliSDK package using pip:
 pip install qilisdk
 ```
 
-### Optional Dependencies
+### Optional Dependencies: speqtrum, cuda, qutip
 
 QiliSDK supports optional modules for additional functionality:
 
@@ -197,26 +202,35 @@ print("Optimal cost:", result.optimal_cost)
 print("Optimal Parameters:", result.optimal_parameters)
 ```
 
-### SpeQtrum
+### Qilimanjaro SpeQtrum
 
 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_details(job_id).status)
-print("job result:", client.get_job_details(job_id).result)
+print("job status:", client.get_job(job_id).status)
+print("job result:", client.get_job(job_id).result)
 ```
 
 ### Sample a quantum Circuit Using a CUDA-Accelerated Simulator
@@ -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.common import ket, tensor_prod
+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()
@@ -299,8 +313,8 @@ Here you find an example of building a Variational Quantum Eigensolver (VQE). To
 ```python
 from qilisdk.digital.gates import U2, CNOT
 from qilisdk.optimizers import SciPyOptimizer
-from qilisdk.common.model import Model
-from qilisdk.common.variables import LEQ, BinaryVariable
+from qilisdk.core.model import Model
+from qilisdk.core.variables import LEQ, BinaryVariable
 from qilisdk.digital.ansatz import HardwareEfficientAnsatz
 from qilisdk.functionals import VariationalProgram, Sampling
 from qilisdk.backends import CudaBackend
@@ -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

{qilisdk-0.1.5 → qilisdk-0.1.7}/README.md

@@ -3,6 +3,7 @@
 [![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.
 
@@ -13,15 +14,15 @@
   - [Table of Contents](#table-of-contents)
   - [Installation](#installation)
     - [Base Installation](#base-installation)
-    - [Optional Extras](#optional-extras)
+    - [Optional Dependencies: speqtrum, cuda, qutip](#optional-dependencies-speqtrum-cuda-qutip)
   - [Usage](#usage)
     - [Digital Quantum Circuits](#digital-quantum-circuits)
-    - [Hamiltonian and Analog Operations](#hamiltonian-and-analog-operations)
+    - [Hamiltonians](#hamiltonians)
     - [Optimizers](#optimizers)
-    - [Quantum-as-a-Service (QaaS)](#quantum-as-a-service-qaas)
-    - [CUDA-Accelerated Simulation](#cuda-accelerated-simulation)
-    - [Time Evolution](#time-evolution)
-    - [Variational Quantum Eigensolver (VQE)](#variational-quantum-eigensolver-vqe)
+    - [Qilimanjaro SpeQtrum](#qilimanjaro-speqtrum)
+    - [Sample a quantum Circuit Using a CUDA-Accelerated Simulator](#sample-a-quantum-circuit-using-a-cuda-accelerated-simulator)
+    - [Time Evolution using Qutip](#time-evolution-using-qutip)
+    - [Variational Programs](#variational-programs)
     - [Open QASM Serialization](#open-qasm-serialization)
     - [YAML Serialization](#yaml-serialization)
   - [Development](#development)
@@ -49,7 +50,7 @@ Install the core QiliSDK package using pip:
 pip install qilisdk
 ```
 
-### Optional Dependencies
+### Optional Dependencies: speqtrum, cuda, qutip
 
 QiliSDK supports optional modules for additional functionality:
 
@@ -152,26 +153,35 @@ print("Optimal cost:", result.optimal_cost)
 print("Optimal Parameters:", result.optimal_parameters)
 ```
 
-### SpeQtrum
+### Qilimanjaro SpeQtrum
 
 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_details(job_id).status)
-print("job result:", client.get_job_details(job_id).result)
+print("job status:", client.get_job(job_id).status)
+print("job result:", client.get_job(job_id).result)
 ```
 
 ### Sample a quantum Circuit Using a CUDA-Accelerated Simulator
@@ -196,18 +206,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.common import ket, tensor_prod
+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
@@ -215,13 +224,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()
@@ -254,8 +264,8 @@ Here you find an example of building a Variational Quantum Eigensolver (VQE). To
 ```python
 from qilisdk.digital.gates import U2, CNOT
 from qilisdk.optimizers import SciPyOptimizer
-from qilisdk.common.model import Model
-from qilisdk.common.variables import LEQ, BinaryVariable
+from qilisdk.core.model import Model
+from qilisdk.core.variables import LEQ, BinaryVariable
 from qilisdk.digital.ansatz import HardwareEfficientAnsatz
 from qilisdk.functionals import VariationalProgram, Sampling
 from qilisdk.backends import CudaBackend
@@ -373,6 +383,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