qilisdk 0.1.4__py3-none-any.whl → 0.1.5__py3-none-any.whl

{qilisdk-0.1.4.dist-info → qilisdk-0.1.5.dist-info}/METADATA

@@ -1,11 +1,16 @@
 Metadata-Version: 2.4
 Name: qilisdk
-Version: 0.1.4
-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.
+Version: 0.1.5
+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/
+Project-URL: Source, https://github.com/qilimanjaro-tech/qilisdk
+Project-URL: Issues, https://github.com/qilimanjaro-tech/qilisdk/issues
+Project-URL: Changelog, https://github.com/qilimanjaro-tech/qilisdk/blob/main/CHANGELOG.md
 Author-email: Qilimanjaro Quantum Tech <info@qilimanjaro.tech>
 License-File: LICENCE
 Keywords: analog quantum computing,digital quantum computing,qilimanjaro,quantum computing
-Classifier: Development Status :: 1 - Planning
+Classifier: Development Status :: 3 - Alpha
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research
@@ -20,16 +25,22 @@ Classifier: Topic :: Scientific/Engineering :: Physics
 Classifier: Topic :: Scientific/Engineering :: Quantum Computing
 Requires-Python: >=3.10
 Requires-Dist: dill>=0.3.9
-Requires-Dist: numpy>=2.2.4
-Requires-Dist: pydantic-settings>=2.8.0
-Requires-Dist: pydantic>=2.10.6
-Requires-Dist: ruamel-yaml>=0.18.10
-Requires-Dist: scipy>=1.15.1
+Requires-Dist: loguru>=0.7.3
+Requires-Dist: matplotlib>=3.10.7
+Requires-Dist: numpy>=1.26.4
+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
 Provides-Extra: cuda
-Requires-Dist: cuda-quantum-cu12; extra == 'cuda'
-Provides-Extra: qaas
-Requires-Dist: httpx>=0.28.1; extra == 'qaas'
-Requires-Dist: keyring>=25.6.0; extra == 'qaas'
+Requires-Dist: cuda-quantum-cu12==0.12.0; extra == 'cuda'
+Provides-Extra: qutip
+Requires-Dist: qutip-qip>=0.4.1; extra == 'qutip'
+Requires-Dist: qutip>=5.2.1; extra == 'qutip'
+Provides-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
 
 # QiliSDK
@@ -83,39 +94,46 @@ Install the core QiliSDK package using pip:
 pip install qilisdk
 ```
 
-### Optional Extras
+### Optional Dependencies
 
 QiliSDK supports optional modules for additional functionality:
 
-- **QaaS (Quantum-as-a-Service):**
-  To interface with Qilimanjaro’s cloud-based quantum services, install the QaaS extra:
+- **SpeQtrum:**
+  To interface with Qilimanjaro’s cloud-based quantum services, install the Speqtrum optional dependency:
 
   ```bash
-  pip install qilisdk[qaas]
+  pip install qilisdk[speqtrum]
   ```
 
-- **CUDA Acceleration:**
+- **CUDA Accelerated Simulator Backend:**
   For GPU-accelerated quantum simulation using NVIDIA GPUs, install the CUDA extra:
 
   ```bash
   pip install qilisdk[cuda]
   ```
 
-  You can also install both optional dependencies using a single command:
+- **Qutip Simulator Backend:**
+  For GPU-accelerated quantum simulation using NVIDIA GPUs, install the CUDA extra:
+
+  ```bash
+  pip install qilisdk[qutip]
+  ```
+
+   **Note:**  You can also install both optional dependencies using a single command:
 
   ```bash
-  pip install qilisdk[cuda,qaas]
+  pip install qilisdk[cuda,qutip,speqtrum]
   ```
 
 ---
 
 ## Usage
 
-QiliSDK is designed to simplify both digital and analog quantum computing workflows. This guide provides example code snippets for creating quantum circuits, performing Hamiltonian arithmetic, optimization, simulation on various backends (including CUDA and cloud-based QaaS), and using additional utility functions.
+QiliSDK is designed to simplify both digital and analog quantum computing workflows. This guide provides example code snippets for creating quantum circuits, performing Hamiltonian arithmetic, optimization, simulation on various backends (including CUDA and cloud-based using Speqtrum), and using additional utility functions.
 
 ### Digital Quantum Circuits
 
-Create and simulate quantum circuits with a flexible gate framework. The following example demonstrates how to assemble a circuit, adjust gate parameters, and execute it with the Qibo backend:
+Create and simulate quantum circuits with a flexible gate framework. The following example demonstrates how to assemble a circuit, adjust gate parameters:
 
 ```python
 import numpy as np
@@ -123,29 +141,20 @@ from qilisdk.digital import Circuit, H, RX, CNOT, M
 
 # Create a circuit with 2 qubits
 circuit = Circuit(2)
-circuit.add(H(0))              # Apply Hadamard on qubit 0
+circuit.add(H(0))  # Apply Hadamard on qubit 0
 circuit.add(RX(0, theta=np.pi))  # Apply RX rotation on qubit 0
-circuit.add(CNOT(0, 1))          # Add a CNOT gate between qubit 0 and 1
+circuit.add(CNOT(0, 1))  # Add a CNOT gate between qubit 0 and 1
 
 # Retrieve the current gate parameters
 print("Initial parameters:", circuit.get_parameter_values())
 
 # Update circuit parameters (e.g., update RX rotation angle)
 circuit.set_parameter_values([2 * np.pi])
-
-# Execute the circuit simulation using CudaBackend
-backend = CudaBackend()
-results = backend.execute(circuit)
-
-# Display the simulation output and measurement probabilities
-print("Simulation Results:")
-print(results)
-print("Probabilities:", results.probabilities)
 ```
 
-### Hamiltonian and Analog Operations
+### Hamiltonians
 
-Utilize the `Hamiltonian` class for Pauli operator arithmetic. Build expressions, iterate through terms, and even round-trip using the parse feature:
+Utilize the `Hamiltonian` class for Pauli operator arithmetic. Build expressions, iterate through terms:
 
 ```python
 from qilisdk.analog import Hamiltonian, X, Y, Z, I
@@ -158,57 +167,66 @@ print("Hamiltonian Expression:", H_expr)
 for coeff, ops in H_expr:
     print("Coefficient:", coeff, "Operators:", ops)
 
-# Parse a Hamiltonian from its string representation
-parsed_H = Hamiltonian.parse("-2j Y(0)")
-assert H_expr == parsed_H, "The Hamiltonian does not match after parsing."
+print("-"*10)
+# export hamiltonians to matrices
+print("Sparse Matrix from Hamiltonian: \n", H_expr.to_matrix()) # sparse matrix  
+# the returned matrix is sparse by default to get the dense representation call .toarray()
 ```
 
+
 ### Optimizers
 
 Run optimization routines using the `SciPyOptimizer` and integrate them with a variational algorithm (VQE). In the example below, a simple quadratic cost function is minimized:
 
 ```python
-from qilisdk.common import SciPyOptimizer
+from qilisdk.optimizers import SciPyOptimizer
+
 
 def cost_function(params):
     # A simple quadratic cost: minimum at [1, 1, 1]
     return sum((p - 1) ** 2 for p in params)
 
+
 # Initialize the optimizer with the BFGS method
 optimizer = SciPyOptimizer(method="BFGS")
 initial_parameters = [0, 0, 0]
-result = optimizer.optimize(cost_function, initial_parameters)
+parameter_bounds = [(0, 1), (0, 1), (0, 1)]
+result = optimizer.optimize(cost_function, initial_parameters, parameter_bounds)
 
 print("Optimal cost:", result.optimal_cost)
 print("Optimal Parameters:", result.optimal_parameters)
 ```
 
-### Quantum-as-a-Service (QaaS)
+### SpeQtrum
 
-QiliSDK now includes a draft backend for interfacing with Qilimanjaro's QaaS platform. This module supports secure login and a unified interface for both digital circuits and analog evolutions:
+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.extras import QaaSBackend
+from qilisdk.speqtrum import SpeQtrum
+from qilisdk.functionals import Sampling
 
 # Login to QaaSBackend with credentials (or use environment variables)
 # This only needs to be run once.
-QaaSBackend.login(username="your_username", apikey="your_apikey")
+SpeQtrum.login(username="your_username", apikey="your_apikey")
 
 # Instantiate QaaSBackend
-qaas_backend = QaaSBackend()
+client = SpeQtrum()
 
-# Execute a pre-built circuit (see Digital Quantum Circuits section)
-results = qaas_backend.execute(circuit)
-print("QaaS Simulation Results:", results)
+# # Execute a pre-built circuit (see Digital Quantum Circuits section)
+job_id = client.submit(Sampling(circuit, 1000), device="cuda_state_vector")
+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)
 ```
 
-### CUDA-Accelerated Simulation
+### Sample a quantum Circuit Using a CUDA-Accelerated Simulator
 
 For users with NVIDIA GPUs, the `CudaBackend` provides GPU-accelerated simulation using several simulation methods. For example, using the TENSOR_NETWORK method:
 
 ```python
-from qilisdk.extras import CudaBackend
-from qilisdk.digital import Circuit, H, M, DigitalSimulationMethod
+from qilisdk.backends import CudaBackend, CudaSamplingMethod
+from qilisdk.digital import Circuit, H, M
+from qilisdk.functionals import Sampling
 
 # Build a single-qubit circuit
 circuit = Circuit(nqubits=1)
@@ -216,112 +234,123 @@ circuit.add(H(0))
 circuit.add(M(0))
 
 # Initialize CudaBackend with the TENSOR_NETWORK simulation method
-cuda_backend = CudaBackend(digital_simulation_method=DigitalSimulationMethod.TENSOR_NETWORK)
-results = cuda_backend.execute(circuit, nshots=1000)
+backend = CudaBackend(sampling_method=CudaSamplingMethod.TENSOR_NETWORK)
+results = backend.execute(Sampling(circuit))
 print("CUDA Backend Results:", results)
 ```
 
-### Time Evolution
+### 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 CUDA backend:
+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:
 
 ```python
 import numpy as np
-from qilisdk.analog import Schedule, TimeEvolution, ket, X, Z, Y, tensor_prod
-from qilisdk.extras import CudaBackend
-
-T = 10       # Total evolution time
-dt = 0.1     # Time-step
-steps = np.linspace(0, T, int(T / dt))
+from qilisdk.analog import Schedule, X, Z, Y
+from qilisdk.common 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)
 nqubits = 1
 
-# Define two Hamiltonians for the simulation
-H1 = sum(X(i) for i in range(nqubits))
-H2 = sum(Z(i) for i in range(nqubits))
-
-# Create a schedule for the time evolution
-schedule = Schedule(
-    T,
-    dt,
-    hamiltonians={"h1": H1, "h2": H2},
-    schedule={
-        t: {"h1": 1 - steps[t] / T, "h2": steps[t] / T}
-        for t in range(len(steps))
-    },
-)
+# Define Hamiltonians
+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)
 
-# Prepare an initial state (equal superposition)
-state = tensor_prod([(ket(0) + ket(1)).unit() for _ in range(nqubits)]).unit()
+# Add hx with a time‐dependent coefficient function
+schedule.add_hamiltonian(label="hx", hamiltonian=Hx, schedule=lambda t: 1 - steps[t] / T)
 
-# Perform time evolution on the CUDA backend with observables to monitor
+# Add hz similarly
+schedule.add_hamiltonian(label="hz", hamiltonian=Hz, schedule=lambda t: steps[t] / T)
+
+# draw the schedule
+schedule.draw()
+
+# Prepare an equal superposition initial state
+initial_state = tensor_prod([(ket(0) - ket(1)).unit() for _ in range(nqubits)]).unit()
+
+# Create the TimeEvolution functional
 time_evolution = TimeEvolution(
     schedule=schedule,
-    initial_state=state,
+    initial_state=initial_state,
     observables=[Z(0), X(0), Y(0)],
+    nshots=100,
+    store_intermediate_results=False,
 )
-results = time_evolution.evolve(backend=CudaBackend(), store_intermediate_results=True)
-print("Time Evolution Results:", results)
+
+# Execute on Qutip backend and inspect results
+backend = QutipBackend()
+results = backend.execute(time_evolution)
+print(results)
 ```
 
-### Variational Quantum Eigensolver (VQE)
+### Variational Programs
+
+The `VariationalProgram` allows the user to optimized parameterized functionals, including `Sampling` and `TimeEvolution`.
+
 
-The VQE algorithm integrates ansatz design, cost function evaluation, and classical optimization. Below is an illustrative example that sets up a VQE instance using a hardware-efficient ansatz and the SciPy optimizer:
+Here you find an example of building a Variational Quantum Eigensolver (VQE). To do this we need a circuit ansatz, cost function to optimize, and classical optimizer. Below is an illustrative example that sets up a VQE instance using a hardware-efficient ansatz and the SciPy optimizer:
 
 ```python
-import numpy as np
-from qilisdk.common import SciPyOptimizer
-from qilisdk.digital import HardwareEfficientAnsatz, VQE
-from qilisdk.extras import CudaBackend
+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.digital.ansatz import HardwareEfficientAnsatz
+from qilisdk.functionals import VariationalProgram, Sampling
+from qilisdk.backends import CudaBackend
+from qilisdk.cost_functions import ModelCostFunction
+
+
+## Define the model
+
+model = Model("Knapsack")
+
+values = [2, 3, 7]
+weights = [1, 3, 3]
+max_weight = 4
+b = [BinaryVariable(f"b{i}") for i in range(len(values))]
+
+obj = sum(b[i] * values[i] for i in range(len(values)))
+model.set_objective(obj, "obj")
 
+con = LEQ(sum(b[i] * weights[i] for i in range(len(weights))), max_weight)
 
-# Define problem parameters
-n_items = 4
-weights = [np.random.randint(1, 5) for _ in range(n_items)]
-values  = [np.random.randint(1, 10) for _ in range(n_items)]
-max_weight_perc = 0.6
-max_w = int(max_weight_perc * sum(weights))
-nqubits = n_items
+model.add_constraint("max_weight", con)
 
-# Initialize a hardware-efficient ansatz
+## Define the Ansatz:
+nqubits = 3
 ansatz = HardwareEfficientAnsatz(
-    n_qubits=nqubits,
-    connectivity="Full",
-    layers=1,
-    one_qubit_gate="U3",
-    two_qubit_gate="CNOT"
+    nqubits=nqubits, layers=2, connectivity="Linear", structure="grouped", one_qubit_gate=U2, two_qubit_gate=CNOT
 )
 
-# Use a CUDA backend for simulation
-backend = CudaBackend()
+## Define the Optimizer
+optimizer = SciPyOptimizer(method="Powell")
 
-LM = sum(values)
-
-def cost_function(result):
-    # Get the most probable outcomes from the digital result
-    most_probable = result.get_probabilities()
-    final_cost = 0
-    for bitstring, prob in most_probable:
-        x_n = [int(bit) for bit in bitstring]
-        total_weight = sum(weights[i] * x_n[i] for i in range(n_items))
-        penalty = (total_weight - max_w) if total_weight > max_w else 0
-        reward = -sum(values[i] * x_n[i] for i in range(n_items))
-        final_cost += prob * (LM * penalty + reward)
-    return final_cost
-
-optimizer = SciPyOptimizer(
-    method="Powell",
-    bounds=[(0, np.pi)] * ansatz.nparameters
+## Build the VQE object
+vqe = VariationalProgram(
+    functional=Sampling(ansatz),
+    optimizer=optimizer,
+    cost_function=ModelCostFunction(model),
 )
 
-# Initialize and execute the VQE algorithm
-vqe = VQE(ansatz, [0.5] * ansatz.nparameters, cost_function)
-results = vqe.execute(backend, optimizer, store_intermediate_results=True)
+## Define the Backend 
+backend = CudaBackend()
+
+## Execute the VQE to find the optimal parameters
+result = backend.execute(vqe)
 
-print("Optimal Cost:", results.optimal_cost)
-print("Optimal Parameters:", results.optimal_parameters)
-print("Intermediate Optimization Steps:")
-for intermediate in results.intermediate_results:
-    print("Cost:", intermediate.cost)
+## Sample the circuit using the optimal parameters
+ansatz.set_parameter_values(result.optimal_parameters)
+results = backend.execute(Sampling(ansatz))
+
+## Print the probabilities
+print(results.get_probabilities())
 ```
 
 ### Open QASM Serialization
@@ -330,7 +359,7 @@ Serialize and deserialize quantum circuits using Open QASM 2.0 grammar. The util
 
 ```python
 from qilisdk.digital import Circuit, CNOT, RX, H, M
-from qilisdk.utils import to_qasm2, from_qasm2, to_qasm2_file, from_qasm2_file
+from qilisdk.utils.openqasm2 import to_qasm2, from_qasm2, to_qasm2_file, from_qasm2_file
 
 # Create a sample circuit
 circuit = Circuit(3)
@@ -339,6 +368,8 @@ circuit.add(CNOT(0, 1))
 circuit.add(RX(2, theta=3.1415))
 circuit.add(M(0, 1, 2))
 
+print("Initial Circuit:")
+circuit.draw()
 # Serialize to QASM string
 qasm_code = to_qasm2(circuit)
 print("Generated QASM:")
@@ -350,21 +381,29 @@ reconstructed_circuit = from_qasm2(qasm_code)
 # Save to and load from a file
 to_qasm2_file(circuit, "circuit.qasm")
 reconstructed_circuit = from_qasm2_file("circuit.qasm")
+print()
+print("Reconstructed Circuit:")
+reconstructed_circuit.draw()
+
+
 ```
 
 ### YAML Serialization
 
-Easily save and restore circuits, hamiltonians, simulation and execution results, and virtually any other class in YAML format using the provided serialization functions:
+Easily save and restore circuits, Hamiltonians, simulation and execution results, and virtually any other class in YAML format using the provided serialization functions:
 
 ```python
 from qilisdk.digital import Circuit, H, CNOT, M
-from qilisdk.utils import serialize, deserialize, serialize_to, deserialize_from
+from qilisdk.utils.serialization import serialize, deserialize, serialize_to, deserialize_from
 
 circuit = Circuit(2)
 circuit.add(H(0))
 circuit.add(CNOT(0, 1))
 circuit.add(M(0, 1))
 
+print("Initial Circuit:")
+circuit.draw()
+
 # Serialize a circuit to a YAML string
 yaml_string = serialize(circuit)
 
@@ -372,8 +411,11 @@ yaml_string = serialize(circuit)
 restored_circuit = deserialize(yaml_string, cls=Circuit)
 
 # Alternatively, work with files:
-serialize_to(circuit, 'circuit.yml')
-restored_circuit = deserialize_from('circuit.yml', cls=Circuit)
+serialize_to(circuit, "circuit.yml")
+restored_circuit = deserialize_from("circuit.yml", cls=Circuit)
+print()
+print("Reconstructed Circuit:")
+restored_circuit.draw()
 ```
 
 ---
@@ -413,11 +455,15 @@ This section covers how to set up a local development environment for qilisdk, r
      uv sync
      ```
      This sets up a virtual environment and installs all pinned dependencies (including `ruff`, `mypy`, `towncrier`, etc.).
-   - To install extra dependencies such as `qibo-backend`, run:
+   - To install extra dependencies such as `CudaBackend`, run:
      ```bash
-     uv sync --extra qibo-backend -extra ...
+     uv sync --extra cuda -extra ...
      ```
      This sets up a virtual environment and installs all pinned dependencies (previous), plus the specified extras.
+     you can also install all the optional dependencies and groups by running;
+     ```bash
+     uv sync --all-extras --all-groups
+     ```
 
 4. **Activate the virtual environment**:
    - uv typically creates and manages its own environment, e.g., `.venv/`.
@@ -487,7 +533,7 @@ changes/123.feature.rst
 ```
 Inside this file, you briefly describe the new feature:
 ```rst
-Added a new `cool_feature` in the `qilisdk.extras` module.
+Added a new `cool_feature` in the `qilisdk.backend` module.
 ```
 Instead of manually creating the file, you can run:
 ```bash

qilisdk-0.1.5.dist-info/RECORD

@@ -0,0 +1,69 @@
+qilisdk/__init__.py,sha256=ewlADDRquvUClgPp1fDx5gfsPsmUHl3LF42ROLqeI5g,824
+qilisdk/__init__.pyi,sha256=7O8kvYmk9hl0OKHgXJkemmYp-x_zppNRuN_WAZeHjbo,630
+qilisdk/_logging.py,sha256=vCKCClIwAY9KptzieYbldU6MVs-HYZ4P1imG2oXkumM,4063
+qilisdk/_optionals.py,sha256=WkYAtoE4RcPtgl7l4OJNGeXwJc0xc8M_UQCpVHS1lmo,3459
+qilisdk/logging_config.yaml,sha256=DxsAJBPr1o54pjtYRnzMHuDbrr8hv4ruym8rLRmUKEk,381
+qilisdk/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+qilisdk/settings.py,sha256=PtiO3iInoBIBLTO_t6D5iWN5a3FuqO4DXyPKmpnph-A,2827
+qilisdk/yaml.py,sha256=UcildGIQq1vMmjKLgFAbd-tN5nwYHlAUi6cs_8r8_As,8050
+qilisdk/analog/__init__.py,sha256=HZecq1CdbZ9ilgxeXcuNQDYv0qYUqi-Mvta-WZPoGT4,862
+qilisdk/analog/exceptions.py,sha256=oYRJD00ICs9M6hezXPv7C7Ug6amcbbGDeP-1o1GkECc,717
+qilisdk/analog/hamiltonian.py,sha256=UbjPmgGZtAO0O99RTJWuCS4M19XFSr2VsL2utszI9eo,39994
+qilisdk/analog/linear_schedule.py,sha256=lVjSvvOxRHBqfCezWEqa4ndQTj4ffSN0FeFLHKAS2Zw,4775
+qilisdk/analog/schedule.py,sha256=gzyAjjTbiCtlPvQxV8wRfLFXetiyp4_fVhW01rE_nsc,22760
+qilisdk/backends/__init__.py,sha256=QHJ99ub4WPMmSMEs_Zdx3yF6d7K9uBapKp0FgvZ12L8,1666
+qilisdk/backends/__init__.pyi,sha256=JP6QY7BqO0LuN7NPAWU0ebBwfcKEJ5w5p4xHa5GNKhA,752
+qilisdk/backends/backend.py,sha256=G0duQuO6Cf9en36eiFunLpmWNKmtQJzN4RuMxV8sp6w,5241
+qilisdk/backends/cuda_backend.py,sha256=1OnkodWH7u2cDlJ9SuIxBtBjCx-bsTkJYEnyqz4KiqQ,17084
+qilisdk/backends/qutip_backend.py,sha256=LgOMNFGzYHtxeOk9PnBDWRUacT1z_LuqTpae0l-aALU,19585
+qilisdk/common/__init__.py,sha256=etcRx1P5YrIAEqkfRuZ8RuF0AFxLFgwM6VTUcBiev9o,1405
+qilisdk/common/algorithm.py,sha256=RgXo5rhl0yON6M77hRI82fmtflwkwUS7ADZPUZw_pQE,682
+qilisdk/common/exceptions.py,sha256=f72N4SRj-oUkHVKVV_Drj6oinTJODNM0LxdFn6AHuBE,1034
+qilisdk/common/model.py,sha256=FAw_YksZnqrfPUKO7mkOrKYthWYKgOgiz-CVZaym2JY,41583
+qilisdk/common/parameterizable.py,sha256=hdibs--MFKn7Sy3CuFbn7Bk2ozPe0206jAuXfyMQdNY,2575
+qilisdk/common/qtensor.py,sha256=gyPcYpi5fumyFctlniZfjGhDvQZ8LjSFodKxXQSK43w,26016
+qilisdk/common/result.py,sha256=EUCWebtdeBwGjhVCBgStuEVmx-U1WR0ZOX7ALAnLrmI,700
+qilisdk/common/variables.py,sha256=f98valt1445iysG7CXEpPaiqTeLuYwcoPYBAL952_GA,71826
+qilisdk/cost_functions/__init__.py,sha256=tKoEm4eVb8oTGGhj25nM2YQE73CRXaLgLyfipa2I70s,760
+qilisdk/cost_functions/cost_function.py,sha256=NyUy-2pp5A_KMjFZ5vIvl0pw5aGD024i-2X2AUKasDo,2852
+qilisdk/cost_functions/model_cost_function.py,sha256=gU2-nRlPCv_Dwkt2GSWRtAtjkMOyTppMX4uD_cp9Uno,5715
+qilisdk/cost_functions/observable_cost_function.py,sha256=lPYrnQr9Tf6VD7YbDY4l8q9VY-xF_o0rLtbefku3C0M,4188
+qilisdk/digital/__init__.py,sha256=qmE0VTKdD9ILlx6ClhBjvOXbpD0nr3uavG-l3VSh69c,989
+qilisdk/digital/ansatz.py,sha256=HJLhC5o5sh8aw4itLnYoZ6cUZMunFIC0FFFBjYT0OJQ,8074
+qilisdk/digital/circuit.py,sha256=3oSkStK91wPG_ozjEGDoDder6PFs5yV5xp6InonoPPo,6911
+qilisdk/digital/exceptions.py,sha256=dtMN9yjX_qRWJ5iFfNTHWVwKB7BrrSecvjB4D0KeoEA,1292
+qilisdk/digital/gates.py,sha256=3on8XI0zZd7WFF15Rr7KNV-se7AOZSf5FBKgX60w1Tk,33651
+qilisdk/functionals/__init__.py,sha256=1Yrk8SyJ98yNYm658HeyaPFaNdMBH96PPlv6oEGGwpM,1037
+qilisdk/functionals/functional.py,sha256=z0KrJ6CPD_FawpYYereXnaiFnX1TyfEmK5pf9HzY_ew,1449
+qilisdk/functionals/functional_result.py,sha256=jEtMEoJcezFgIa1AsJDNg0nm5HSJJOEXkr5eVo2u4bI,743
+qilisdk/functionals/sampling.py,sha256=LkZJW2oHqDcGiARmKJPp3qwNmUEd0ygJfIUAjigKlnY,3266
+qilisdk/functionals/sampling_result.py,sha256=tUXOHJOtznGyWsHK4MLtP1bTSdD6zppbT2K2lcQFkyo,3411
+qilisdk/functionals/time_evolution.py,sha256=ixSTvtd5zckhTmyZsylpEUxTdPYx9siag_l5NfIy6CU,4155
+qilisdk/functionals/time_evolution_result.py,sha256=kwagAEZdumaWcJzRL0t25wXYIqH9hIax7jL4i0KEDV8,3495
+qilisdk/functionals/variational_program.py,sha256=wD5oHYBMUGRNCn-SFjTHE6r0oqd5y3KxQ8dkgbANS94,3029
+qilisdk/functionals/variational_program_result.py,sha256=Dii9D1BnUpfsBfgN60eFVp7Qhsr2mIFSbUtM5Q4KZeI,2657
+qilisdk/optimizers/__init__.py,sha256=v3pLS__wnVRCiz83y8-gUjRuW-BoAGXFpd6HUmLodgY,663
+qilisdk/optimizers/optimizer.py,sha256=GT9ziwPJ2ZjckOeeoyc07O3XyaVsRmUnVxN0UXNaO7Y,1570
+qilisdk/optimizers/optimizer_result.py,sha256=OjwgED_tAKkp4rqqnq0ordaLp09B2lbN5Yfjed9qUak,3477
+qilisdk/optimizers/scipy_optimizer.py,sha256=JquRPvpWJ6ccpzxlo9HKV66cz4kYwEXEPe3jNeT8_sE,5020
+qilisdk/speqtrum/__init__.py,sha256=7fvKWdhNrfhRFNJuCNg-VKZ-mr0VlPlfbbLWYUBdqqM,1537
+qilisdk/speqtrum/__init__.pyi,sha256=2_3FiMTnJe0rUuK-arKd4JuIt3tJ9ci-a8ipgMdOSSo,728
+qilisdk/speqtrum/keyring.py,sha256=zPYSAqq9A0hfjWdchTCy9oZi72HPFvtxDoblHDvpjhA,1898
+qilisdk/speqtrum/speqtrum.py,sha256=Je-Euanqa2yANhLaeRZ59OMpsCQatPq6MRBjJANS9E4,17387
+qilisdk/speqtrum/speqtrum_models.py,sha256=eI5xg3flP6N-UObffI75BhNcSmNp511N3WoGSw-yCHU,9952
+qilisdk/speqtrum/experiments/__init__.py,sha256=FlXV-8SR8VMRKMxbgj3sa8kHcueTsw6NT9j0zm6Tk_U,955
+qilisdk/speqtrum/experiments/experiment_functional.py,sha256=0yuuDZJzI2OaHsKmbQrkXeK4Ih2PQilKLuwqdXZxdC4,4363
+qilisdk/speqtrum/experiments/experiment_result.py,sha256=O398vInFShp4n8YvUSfit1kgNCnlSZ9F07xHipxRHkc,8201
+qilisdk/utils/__init__.py,sha256=LDSTo7NstSbHMvvqvx7ZLxh0HFTEXg1O_B76SyEEHk8,588
+qilisdk/utils/openqasm2.py,sha256=IMHT3BRbpS4giKg5JCZ4tt6BpD7eDEJMALrW7w1RvPw,8322
+qilisdk/utils/serialization.py,sha256=_SmxxbshMtSozCHdzi_Y_3YZ7-KNjsrlfgkBtJ3mAjw,3870
+qilisdk/utils/visualization/PlusJakartaSans-SemiBold.ttf,sha256=kcACUvAhK3AgdI7-50kwPyG0xdtAodY9-UhPbw2NtTk,94844
+qilisdk/utils/visualization/__init__.py,sha256=p3OTMwM2eF5_LZW0-kYU8IqcEyQySxjDKnqDfCw3dpg,769
+qilisdk/utils/visualization/circuit_renderers.py,sha256=20X--lgQdwmu08pvuekdebOI01hRHknl0Z8ct4OVWOU,29908
+qilisdk/utils/visualization/schedule_renderers.py,sha256=RhigVpXgZF_iHg2W8EOdvwL_g2j_mCw-gIgFvgJcjLM,6005
+qilisdk/utils/visualization/style.py,sha256=l50u4UGCbU0r_BBuij35M4sTrmYh_e0m1IgRY-DjfH8,7288
+qilisdk/utils/visualization/themes.py,sha256=uganZjDx742bmGVG73UU6Lde5XXjlDNfVNEa9y_icBw,2346
+qilisdk-0.1.5.dist-info/METADATA,sha256=Yclcu1KkOs4WMosRTkCT_lT6mLNsvMQqeOoP4UIhQuw,19301
+qilisdk-0.1.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+qilisdk-0.1.5.dist-info/licenses/LICENCE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+qilisdk-0.1.5.dist-info/RECORD,,