qhyper 0.3.4__tar.gz → 0.4.0__tar.gz

{qhyper-0.3.4 → qhyper-0.4.0}/LICENSE.txt

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2022-2025 ACC Cyfronet AGH
+Copyright (c) 2022-2026 ACC Cyfronet AGH
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

qhyper-0.4.0/PKG-INFO

@@ -0,0 +1,53 @@
+Metadata-Version: 2.4
+Name: qhyper
+Version: 0.4.0
+Summary: Quantum and classical combinatorial optimization problem solvers
+Author: ACC Cyfronet AGH
+Author-email: jzawalska@agh.edu.pl
+License: MIT
+Keywords: python,qhyper,quantum,solver,experiment
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: Unix
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: numpy~=2.2.6
+Requires-Dist: PennyLane~=0.41.1
+Requires-Dist: pennylane-lightning~=0.41.1
+Requires-Dist: autoray~=0.7.2
+Requires-Dist: tqdm~=4.67.3
+Requires-Dist: sympy~=1.13.0
+Requires-Dist: dwave-system~=1.36.0
+Requires-Dist: dwave-cloud-client~=0.14.8
+Requires-Dist: gurobipy~=12.0.0
+Requires-Dist: pandas~=2.2.3
+Requires-Dist: qiskit~=2.1.2
+Requires-Dist: qiskit-aer~=0.17.2
+Requires-Dist: iqm-client~=34.0.4
+Requires-Dist: wfcommons~=0.8
+Provides-Extra: vlq
+Requires-Dist: py4lexis~=7.1; extra == "vlq"
+Requires-Dist: qaas~=0.5.3; extra == "vlq"
+Provides-Extra: dev
+Requires-Dist: types-tqdm~=4.67.3.20260205; extra == "dev"
+Requires-Dist: ipywidgets~=8.1; extra == "dev"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+A package that allows to build and solve quantum and classical problems using predefined solvers and problems.

{qhyper-0.3.4 → qhyper-0.4.0}/QHyper/constraint.py

@@ -30,12 +30,17 @@ class MethodsForInequalities(Enum):
     """Enum class with different methods for handling inequalities.
 
     There are two available methods for handling inequalities:
+    
     .. list-table::
-
-        * - SLACKS_LOG_2
-          - UNBALANCED_PENALIZATION 
-        * - the method uses slack variables in number of log2(n)
-          - the method uses unbalanced penalization
+        :header-rows: 1
+        :widths: 30 70
+
+        * - Method
+          - Description
+        * - ``SLACKS_LOG_2``
+          - Uses slack variables, log2(n) in number.
+        * - ``UNBALANCED_PENALIZATION``
+          - Uses unbalanced penalization.
     """
     SLACKS_LOG_2 = 0
     UNBALANCED_PENALIZATION = 1

{qhyper-0.3.4 → qhyper-0.4.0}/QHyper/converter.py

@@ -176,7 +176,7 @@ class Converter:
         Attributes
         ----------
         problem : Problem
-            The problem to be solved. Objective funtion variables
+            The problem to be solved. Objective function variables
             should be written in the format <str><int> (e.g. x10, yz1).
         cases: int, default 1
             Number of variable cases (values)
@@ -214,7 +214,7 @@ class Converter:
         for variable in problem.objective_function.get_variables():
             if not pattern.match(variable):
                 raise ValueError(
-                    f"Objective funtion variable '{variable}'"
+                    f"Objective function variable '{variable}'"
                     "should be written in the format <str><int> (e.g. x10, yz1)."
                 )
 

qhyper-0.4.0/QHyper/devices/__init__.py

@@ -0,0 +1,32 @@
+"""
+This module contains device configurations, classes that describe where a
+solver is run and know how to create the backend, sampler or simulator used
+by the given platform.
+Devices are kept separate from solvers, so the same solver can be run on a
+local simulator or on real hardware just by changing the device.
+
+.. code-block:: python
+
+    from QHyper.devices.pennylane import PennyLaneDevice
+
+.. rubric:: Interface
+
+.. autosummary::
+    :toctree: generated
+
+    Device -- Base class for devices.
+
+.. rubric:: Available devices
+
+.. autosummary::
+    :toctree: generated
+
+    pennylane.PennyLaneDevice -- PennyLane device configuration.
+    iqm.ResonanceDevice -- IQM Resonance device configuration.
+    iqm.VLQDevice -- VLQ device configuration.
+    qiskit_aer.AerDevice -- Qiskit Aer simulator device.
+    dwave.DWaveDevice -- D-Wave device configuration.
+
+"""
+
+from QHyper.devices.base import Device

qhyper-0.4.0/QHyper/devices/base.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+
+from abc import ABC
+
+
+class Device(ABC):
+    """Abstract base class for device configurations."""

qhyper-0.4.0/QHyper/devices/dwave/__init__.py

@@ -0,0 +1 @@
+from QHyper.devices.dwave.base import DWaveDevice

qhyper-0.4.0/QHyper/devices/dwave/base.py

@@ -0,0 +1,127 @@
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from typing import Any
+
+from dwave.cloud import Client
+from dwave.cloud.regions import get_regions
+from dwave.system import (
+    DWaveSampler,
+    LeapHybridCQMSampler,
+    LeapHybridDQMSampler,
+)
+
+from QHyper.util import normalize_key, remap_keys
+from QHyper.devices.base import Device
+
+
+DEVICE_NAME = 'DWaveSampler'
+
+SAMPLERS = {
+    'advantage': (DWaveSampler,
+                  lambda s: s.qpu),
+    'cqm': (LeapHybridCQMSampler,
+            lambda s: 'cqm' in s.supported_problem_types),
+    'dqm': (LeapHybridDQMSampler,
+            lambda s: 'dqm' in s.supported_problem_types),
+}
+
+
+@dataclass
+class DWaveDevice(Device):
+    """
+    Device configuration for the D-Wave solvers.
+
+    Attributes
+    ----------
+    type : str, default 'qpu'
+        Type of the device the problem is solved on.
+        Only 'qpu' is accepted, every D-Wave solver (Advantage, CQM, DQM)
+        runs on a remote machine.
+    name : str, default 'DWaveSampler'
+        Name of the device. Only 'DWaveSampler' is accepted.
+    backend : str | None, default None
+        Name of the backend, e.g. 'Advantage_system5.4'. If not provided,
+        the default backend available for the token is used.
+    region : str | None, default None
+        Region the backend is looked up in, e.g. 'eu-central-1'. If not
+        provided, the default region is used.
+    token : str | None, default None
+        D-Wave Leap API token. If not provided, the DWAVE_API_TOKEN
+        environment variable is used.
+    """
+
+    type: str = 'qpu'
+    name: str = DEVICE_NAME
+    backend: str | None = None
+    region: str | None = None
+    token: str | None = None
+
+    def __post_init__(self) -> None:
+        self.type = str(self.type).lower()
+        if self.type != 'qpu':
+            raise ValueError(
+                "'device.type' must be 'qpu', every D-Wave solver "
+                "(advantage, cqm, dqm) runs on a remote machine"
+            )
+
+        if normalize_key(self.name) != normalize_key(DEVICE_NAME):
+            raise ValueError(
+                f"'device.name' must be '{DEVICE_NAME}', got '{self.name}'"
+            )
+        self.name = DEVICE_NAME
+
+        if self.region is not None:
+            regions = [region.code for region in get_regions()]
+            if self.region not in regions:
+                raise ValueError(
+                    f"Unknown D-Wave region '{self.region}'. "
+                    f"Available regions: {sorted(regions)}"
+                )
+
+    @classmethod
+    def from_config(cls, config: Any) -> "DWaveDevice":
+        if isinstance(config, cls):
+            return config
+        if not isinstance(config, dict):
+            raise ValueError("'device' must be a mapping")
+        return cls(**remap_keys(
+            config, ['type', 'name', 'backend', 'region', 'token']))
+
+    def make_sampler(self, solver_name: str) -> Any:
+        if solver_name not in SAMPLERS:
+            raise ValueError(
+                f"Unknown solver '{solver_name}', "
+                f"expected one of {sorted(SAMPLERS)}"
+            )
+        sampler, runs_on = SAMPLERS[solver_name]
+
+        kwargs: dict[str, Any] = {}
+        token = self.token or os.environ.get('DWAVE_API_TOKEN')
+        if token is not None:
+            kwargs['token'] = token
+        if self.region is not None:
+            kwargs['region'] = self.region
+
+        with Client.from_config(**kwargs) as client:
+            machines = sorted(
+                s.name for s in client.get_solvers() if runs_on(s))
+
+        where = (f"region '{self.region}'" if self.region
+                 else 'the default region')
+        if not machines:
+            raise ValueError(
+                f"No machine for the '{solver_name}' solver is available "
+                f"in {where} with this token"
+            )
+        if self.backend is not None and self.backend not in machines:
+            raise ValueError(
+                f"'{self.backend}' is not a valid machine for the "
+                f"'{solver_name}' solver in {where}. "
+                f"Available machines: {machines}"
+            )
+
+        if self.backend is not None:
+            kwargs['solver'] = self.backend
+        return sampler(**kwargs)

qhyper-0.4.0/QHyper/devices/iqm/__init__.py

@@ -0,0 +1,13 @@
+# This project has received funding from the European High Performance Computing Joint Undertaking (EuroHPC JU) 
+# under grant agreement No 101159808 (EuroQHPC-Integration).
+
+from QHyper.devices.iqm.base import IQMDevice
+from QHyper.devices.iqm.resonance import ResonanceDevice, IQM_FAKE_BACKENDS, IQM_BACKEND_URL, IQMBackend
+
+
+def __getattr__(name):
+    # VLQDevice needs the optional 'vlq' extra (py4lexis, qaas)
+    if name == "VLQDevice":
+        from QHyper.devices.iqm.vlq import VLQDevice
+        return VLQDevice
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

qhyper-0.4.0/QHyper/devices/iqm/base.py

@@ -0,0 +1,99 @@
+# This project has received funding from the European High Performance Computing Joint Undertaking (EuroHPC JU) 
+# under grant agreement No 101159808 (EuroQHPC-Integration).
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from dataclasses import fields
+from typing import Any
+
+from qiskit import QuantumCircuit
+
+from QHyper.util import remap_keys
+from QHyper.devices.base import Device
+
+
+class IQMDevice(Device, ABC):
+    """Abstract base class for IQM device configurations."""
+
+    @abstractmethod
+    def make_backend(self) -> Any:
+        """
+        Create the backend the circuits are run on.
+
+        Returns
+        -------
+        Any
+            Qiskit backend instance.
+        """
+
+        ...
+
+    @abstractmethod
+    def transpile(self, qc: QuantumCircuit, backend: Any) -> QuantumCircuit:
+        """
+        Transpile the circuit to the gate set of the given backend.
+
+        Parameters
+        ----------
+        qc : QuantumCircuit
+            Circuit to transpile.
+        backend : Any
+            Backend created by make_backend.
+
+        Returns
+        -------
+        QuantumCircuit
+            Circuit that can be run on the backend.
+        """
+
+        ...
+
+    @classmethod
+    def from_config(cls, config: Any) -> "IQMDevice":
+        from QHyper.devices.iqm.resonance import ResonanceDevice
+
+        if isinstance(config, IQMDevice):
+            return config
+        if not isinstance(config, dict):
+            raise ValueError("'solver.device' must be a mapping")
+
+        cfg = remap_keys(
+            config,
+            ['type', 'name', 'backend', 'project', 'resource_name', 'token'],
+        )
+        device_type = str(cfg.get('type', '')).lower()
+        device_name = str(cfg.get('name', '')).lower()
+
+        if device_type == 'simulator':
+            if device_name in ('it4i', 'lexis', 'vlq'):
+                from QHyper.devices.iqm.vlq import VLQDevice
+                return _build(VLQDevice, cfg)
+            return _build(ResonanceDevice, cfg)
+        if device_type == 'qpu':
+            if device_name in ('iqm.resonance', 'iqm', 'resonance'):
+                return _build(ResonanceDevice, cfg)
+            if device_name in ('it4i', 'lexis', 'vlq'):
+                from QHyper.devices.iqm.vlq import VLQDevice
+                return _build(VLQDevice, cfg)
+            if not device_name:
+                raise ValueError(
+                    "'solver.device.name' must be a non-empty string"
+                )
+            raise ValueError(
+                f"Unsupported IQM qpu device name '{device_name}'. "
+                "Use 'iqm.resonance' for IQM or 'it4i'/'lexis' for LEXIS"
+            )
+        raise ValueError(
+            "'solver.device.type' must be either 'simulator' or 'qpu'"
+        )
+
+
+def _build(target: type, cfg: dict[str, Any]) -> "IQMDevice":
+    names = {f.name for f in fields(target)}
+    unknown = [k for k in cfg if k not in names and k != 'name']
+    if unknown:
+        raise ValueError(
+            f"{target.__name__} does not accept config keys: {sorted(unknown)}"
+        )
+    return target(**{k: v for k, v in cfg.items() if k in names})

qhyper-0.4.0/QHyper/devices/iqm/fake_vlq.py

@@ -0,0 +1,223 @@
+# March 17, 2026 calibration data from VLQ
+#
+# Copyright 2022-2025 Qiskit on IQM developers
+#
+# 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.
+"""Fake backend for IQM's 24-qubit VLQ architecture."""
+
+from iqm.iqm_client import StaticQuantumArchitecture
+from iqm.qiskit_iqm.fake_backends.iqm_fake_backend import IQMErrorProfile, IQMFakeBackend
+
+
+def FakeVLQ() -> IQMFakeBackend:
+    """Return IQMFakeBackend instance representing IQM's VLQ architecture."""
+    architecture = StaticQuantumArchitecture(
+        dut_label="FakeVLQ",
+        qubits=["QB1", "QB2", "QB3", "QB4", "QB5", "QB6", "QB7", "QB8", "QB9", "QB10", "QB11", "QB12", "QB13", "QB14", "QB15", "QB16", "QB17", "QB18", "QB19", "QB20", "QB21", "QB22", "QB23", "QB24"],
+        computational_resonators=["CR1"],
+        connectivity=[
+            ("CR1", "QB1"),
+            ("CR1", "QB2"),
+            ("CR1", "QB3"),
+            ("CR1", "QB4"),
+            ("CR1", "QB5"),
+            ("CR1", "QB6"),
+            ("CR1", "QB7"),
+            ("CR1", "QB8"),
+            ("CR1", "QB9"),
+            ("CR1", "QB10"),
+            ("CR1", "QB11"),
+            ("CR1", "QB12"),
+            ("CR1", "QB13"),
+            ("CR1", "QB14"),
+            ("CR1", "QB15"),
+            ("CR1", "QB16"),
+            ("CR1", "QB17"),
+            ("CR1", "QB18"),
+            ("CR1", "QB19"),
+            ("CR1", "QB20"),
+            ("CR1", "QB21"),
+            ("CR1", "QB22"),
+            ("CR1", "QB23"),
+            ("CR1", "QB24"),
+        ],
+    )
+    error_profile = IQMErrorProfile(
+        t1s={
+            "CR1": 29814.7,
+            "QB1": 56045.2,
+            "QB2": 28729.9,
+            "QB3": 14851.5,
+            "QB4": 46265.7,
+            "QB5": 57696.6,
+            "QB6": 40583.2,
+            "QB7": 29192.0,
+            "QB8": 38211.8,
+            "QB9": 46878.0,
+            "QB10": 13875.1,
+            "QB11": 51104.7,
+            "QB12": 38616.3,
+            "QB13": 26429.5,
+            "QB14": 40202.9,
+            "QB15": 24569.9,
+            "QB16": 33320.0,
+            "QB17": 44884.3,
+            "QB18": 23783.5,
+            "QB19": 37904.1,
+            "QB20": 43738.6,
+            "QB21": 32227.6,
+            "QB22": 41627.0,
+            "QB23": 30612.1,
+            "QB24": 32437.0,            
+        },
+        t2s={
+            "CR1": 29814.7,
+            "QB1": 11239.2,
+            "QB2": 15242.3,
+            "QB3": 6077.3,
+            "QB4": 11035.0,
+            "QB5": 14255.0,
+            "QB6": 12630.0,
+            "QB7": 13889.0,
+            "QB8": 9170.8,
+            "QB9":  9473.1,
+            "QB10": 10501.1,
+            "QB11": 10618.5,
+            "QB12": 13293.6,
+            "QB13": 6709.4,
+            "QB14": 12630.0,
+            "QB15": 12633.8,
+            "QB16": 13851.6,
+            "QB17": 14455.5,
+            "QB18": 9903.4,
+            "QB19": 10948.8,
+            "QB20": 17564.0,
+            "QB21": 13208.1,
+            "QB22": 15476.7,
+            "QB23": 17537.6,
+            "QB24": 12227.4,
+        },
+        single_qubit_gate_depolarizing_error_parameters={
+            "prx": {
+                "QB1": 0.01004,
+                "QB2": 0.01586,
+                "QB3": 0.00121,
+                "QB4": 0.00218,
+                "QB5": 0.00172,
+                "QB6": 0.00232,
+                "QB7": 0.00096,
+                "QB8": 0.00222,
+                "QB9": 0.00098,
+                "QB10": 0.00121,
+                "QB11": 0.00102,
+                "QB12": 0.00157,
+                "QB13": 0.0011,
+                "QB14": 0.03532,
+                "QB15": 0.00085,
+                "QB16": 0.00128,
+                "QB17": 0.00124,
+                "QB18": 0.00058,
+                "QB19": 0.00125,
+                "QB20": 0.00058,
+                "QB21": 0.0013,
+                "QB22": 0.0008,
+                "QB23": 0.00192,
+                "QB24": 0.0027,
+            }
+        },
+        two_qubit_gate_depolarizing_error_parameters={
+            "cz": {
+                ("QB1", "CR1"): 0.005743,
+                ("QB2", "CR1"): 0.060690,
+                ("QB3", "CR1"): 0.012595,
+                ("QB4", "CR1"): 0.007504,
+                ("QB5", "CR1"): 0.005700,
+                ("QB6", "CR1"): 0.044717,
+                ("QB7", "CR1"): 0.005157,
+                ("QB8", "CR1"): 0.007602,
+                ("QB9", "CR1"): 0.007248,
+                ("QB10", "CR1"): 0.011908,
+                ("QB11", "CR1"): 0.007327,
+                ("QB12", "CR1"): 0.005934,
+                ("QB13", "CR1"): 0.005665,
+                ("QB14", "CR1"): 0.111660,
+                ("QB15", "CR1"): 0.004772,
+                ("QB16", "CR1"): 0.021655,
+                ("QB17", "CR1"): 0.006845,
+                ("QB18", "CR1"): 0.026027,
+                ("QB19", "CR1"): 0.005808,
+                ("QB20", "CR1"): 0.358012,
+                ("QB21", "CR1"): 0.015436,
+                ("QB22", "CR1"): 0.006003,
+                ("QB23", "CR1"): 0.004907,
+                ("QB24", "CR1"): 0.006182,
+            },
+            "move": {
+                ("QB1", "CR1"): 0.000659,
+                ("QB2", "CR1"): 0.001453,
+                ("QB3", "CR1"): 0.020023,
+                ("QB4", "CR1"): 0.001523,
+                ("QB5", "CR1"): 0.001287,
+                ("QB6", "CR1"): 0.000998,
+                ("QB7", "CR1"): 0.099595,
+                ("QB8", "CR1"): 0.003081,
+                ("QB9", "CR1"): 0.001481,
+                ("QB10", "CR1"): 0.002812,
+                ("QB11", "CR1"): 0.000970,
+                ("QB12", "CR1"): 0.004332,
+                ("QB13", "CR1"): 0.001165,
+                ("QB14", "CR1"): 0.007962,
+                ("QB15", "CR1"): 0.004231,
+                ("QB16", "CR1"): 0.002013,
+                ("QB17", "CR1"): 0.001451,
+                ("QB18", "CR1"): 0.001123,
+                ("QB19", "CR1"): 0.001912,
+                ("QB20", "CR1"): 0.001385,
+                ("QB21", "CR1"): 0.003157,
+                ("QB22", "CR1"): 0.001503,
+                ("QB23", "CR1"): 0.001453,
+                ("QB24", "CR1"): 0.002493,
+            },
+        },
+        single_qubit_gate_durations={"prx": 32.0},
+        two_qubit_gate_durations={"cz": 88.0, "move": 64.0},
+        readout_errors={
+            "QB1": {"0": 0.016, "1": 0.0665},
+            "QB2": {"0": 0.0305, "1": 0.058},
+            "QB3": {"0": 0.0095, "1": 0.022},
+            "QB4": {"0": 0.0255, "1": 0.0225},
+            "QB5": {"0": 0.0285, "1": 0.037},
+            "QB6": {"0": 0.0195, "1": 0.061},
+            "QB7": {"0": 0.032, "1": 0.0275},
+            "QB8": {"0": 0.041, "1": 0.038},
+            "QB9": {"0": 0.043, "1": 0.0365},
+            "QB10": {"0": 0.019, "1": 0.033},
+            "QB11": {"0": 0.0095, "1": 0.0155},
+            "QB12": {"0": 0.009, "1": 0.0135},
+            "QB13": {"0": 0.0155, "1": 0.011},
+            "QB14": {"0": 0.016, "1": 0.205},
+            "QB15": {"0": 0.004, "1": 0.016},
+            "QB16": {"0": 0.0225, "1": 0.024},
+            "QB17": {"0": 0.0215, "1": 0.026},
+            "QB18": {"0": 0.0165, "1": 0.019},
+            "QB19": {"0": 0.0075, "1": 0.024},
+            "QB20": {"0": 0.014, "1": 0.0205},
+            "QB21": {"0": 0.0075, "1": 0.0195},
+            "QB22": {"0": 0.0225, "1": 0.033},
+            "QB23": {"0": 0.0055, "1": 0.0135},
+            "QB24": {"0": 0.017, "1": 0.0255},
+        },
+        name="VLQ",
+    )
+
+    return IQMFakeBackend(architecture, error_profile, name="FakeVLQBackend")