azure-quantum 2.1.1__py3-none-any.whl → 2.2.0__py3-none-any.whl

azure/quantum/_client/_version.py

@@ -6,4 +6,4 @@
 # Changes may cause incorrect behavior and will be lost if the code is regenerated.
 # --------------------------------------------------------------------------
 
-VERSION = "2.1.1"
+VERSION = "2.2.0"

azure/quantum/qiskit/backends/backend.py

@@ -21,14 +21,15 @@ from abc import abstractmethod
 from azure.quantum.job.session import SessionHost
 
 try:
-    from qiskit import QuantumCircuit, transpile
+    from qiskit import QuantumCircuit
     from qiskit.providers import BackendV1 as Backend
     from qiskit.providers import Options
     from qiskit.providers import Provider
     from qiskit.providers.models import BackendConfiguration
     from qiskit.qobj import QasmQobj, PulseQobj
-    from pyqir import Module
-    from qiskit_qir import to_qir_module
+    import pyqir as pyqir
+    from qsharp.interop.qiskit import QSharpBackend
+    from qsharp import TargetProfile
 
 except ImportError:
     raise ImportError(
@@ -36,6 +37,39 @@ except ImportError:
 To install run: pip install azure-quantum[qiskit]"
     )
 
+# barrier is handled by an extra flag which will transpile
+# them away if the backend doesn't support them. This has
+# to be done as a special pass as the transpiler will not
+# remove barriers by default.
+QIR_BASIS_GATES = [
+    "measure",
+    "reset",
+    "ccx",
+    "cx",
+    "cy",
+    "cz",
+    "rx",
+    "rxx",
+    "crx",
+    "ry",
+    "ryy",
+    "cry",
+    "rz",
+    "rzz",
+    "crz",
+    "h",
+    "s",
+    "sdg",
+    "swap",
+    "t",
+    "tdg",
+    "x",
+    "y",
+    "z",
+    "id",
+    "ch",
+]
+
 
 class AzureBackendBase(Backend, SessionHost):
 
@@ -280,7 +314,11 @@ class AzureQirBackend(AzureBackendBase):
             "content_type": "qir.v1",
             "input_data_format": "qir.v1",
             "output_data_format": "microsoft.quantum-results.v2",
+            "is_default": True,
         }
+    
+    def _basis_gates(self) -> List[str]:
+        return QIR_BASIS_GATES
 
     def run(
         self,
@@ -368,66 +406,140 @@ class AzureQirBackend(AzureBackendBase):
         return {}
 
     def _generate_qir(
-        self, circuits, targetCapability, **to_qir_kwargs
-    ) -> Tuple[Module, List[str]]:
+        self, circuits: List[QuantumCircuit], target_profile: TargetProfile, **kwargs
+    ) -> pyqir.Module:
+
+        if len(circuits) == 0:
+            raise ValueError("No QuantumCircuits provided")
 
         config = self.configuration()
         # Barriers aren't removed by transpilation and must be explicitly removed in the Qiskit to QIR translation.
-        emit_barrier_calls = "barrier" in config.basis_gates
-        return to_qir_module(
-            circuits,
-            targetCapability,
-            emit_barrier_calls=emit_barrier_calls,
-            **to_qir_kwargs,
+        supports_barrier = "barrier" in config.basis_gates
+        skip_transpilation = kwargs.pop("skip_transpilation", False)
+
+        backend = QSharpBackend(
+            qiskit_pass_options={"supports_barrier": supports_barrier},
+            target_profile=target_profile,
+            skip_transpilation=skip_transpilation,
+            **kwargs,
         )
 
-    def _get_qir_str(self, circuits, targetCapability, **to_qir_kwargs) -> str:
-        module, _ = self._generate_qir(circuits, targetCapability, **to_qir_kwargs)
+        name = "batch"
+        if len(circuits) == 1:
+            name = circuits[0].name
+
+        if isinstance(circuits, list):
+            for value in circuits:
+                if not isinstance(value, QuantumCircuit):
+                    raise ValueError("Input must be List[QuantumCircuit]")
+        else:
+            raise ValueError("Input must be List[QuantumCircuit]")
+
+        context = pyqir.Context()
+        llvm_module = pyqir.qir_module(context, name)
+        for circuit in circuits:
+            qir_str = backend.qir(circuit)
+            module = pyqir.Module.from_ir(context, qir_str)
+            entry_point = next(filter(pyqir.is_entry_point, module.functions))
+            entry_point.name = circuit.name
+            llvm_module.link(module)
+        err = llvm_module.verify()
+        if err is not None:
+            raise Exception(err)
+
+        return llvm_module
+
+    def _get_qir_str(
+        self,
+        circuits: List[QuantumCircuit],
+        target_profile: TargetProfile,
+        **to_qir_kwargs,
+    ) -> str:
+        module = self._generate_qir(circuits, target_profile, **to_qir_kwargs)
         return str(module)
 
     def _translate_input(
-        self, circuits: List[QuantumCircuit], input_params: Dict[str, Any]
+        self, circuits: Union[QuantumCircuit, List[QuantumCircuit]], input_params: Dict[str, Any]
     ) -> bytes:
         """Translates the input values to the QIR expected by the Backend."""
         logger.info(f"Using QIR as the job's payload format.")
-        config = self.configuration()
+        if not (isinstance(circuits, list)):
+            circuits = [circuits]
 
-        # Override QIR translation parameters
-        # We will record the output by default, but allow the backend to override this, and allow the user to override the backend.
-        to_qir_kwargs = input_params.pop(
-            "to_qir_kwargs", config.azure.get("to_qir_kwargs", {"record_output": True})
-        )
-        targetCapability = input_params.pop(
-            "targetCapability",
-            self.options.get("targetCapability", "AdaptiveExecution"),
-        )
+        target_profile = self._get_target_profile(input_params)
 
         if logger.isEnabledFor(logging.DEBUG):
-            qir = self._get_qir_str(circuits, targetCapability, **to_qir_kwargs)
+            qir = self._get_qir_str(circuits, target_profile, skip_transpilation=True)
             logger.debug(f"QIR:\n{qir}")
 
         # We'll transpile automatically to the supported gates in QIR unless explicitly skipped.
-        if not input_params.pop("skipTranspile", False):
-            # Set of gates supported by QIR targets.
-            circuits = transpile(
-                circuits, basis_gates=config.basis_gates, optimization_level=0
-            )
+        skip_transpilation = input_params.pop("skipTranspile", False)
+
+        module = self._generate_qir(
+            circuits, target_profile, skip_transpilation=skip_transpilation
+        )
+
+        def get_func_name(func: pyqir.Function) -> str:
+            return func.name
+
+        entry_points = list(
+            map(get_func_name, filter(pyqir.is_entry_point, module.functions))
+        )
+
+        if not skip_transpilation:
             # We'll only log the QIR again if we performed a transpilation.
             if logger.isEnabledFor(logging.DEBUG):
-                qir = self._get_qir_str(circuits, targetCapability, **to_qir_kwargs)
+                qir = str(module)
                 logger.debug(f"QIR (Post-transpilation):\n{qir}")
 
-        (module, entry_points) = self._generate_qir(
-            circuits, targetCapability, **to_qir_kwargs
-        )
-
-        if not "items" in input_params:
+        if "items" not in input_params:
             arguments = input_params.pop("arguments", [])
             input_params["items"] = [
                 {"entryPoint": name, "arguments": arguments} for name in entry_points
             ]
 
-        return module.bitcode
+        return str(module).encode("utf-8")
+
+    def _estimate_cost_qir(
+        self, circuits: Union[QuantumCircuit, List[QuantumCircuit]], shots, options={}
+    ):
+        """Estimate the cost for the given circuit."""
+        input_params = self._get_input_params(options, shots=shots)
+
+        if not (isinstance(circuits, list)):
+            circuits = [circuits]
+
+        skip_transpilation = input_params.pop("skipTranspile", False)
+        target_profile = self._get_target_profile(input_params)
+        module = self._generate_qir(
+            circuits, target_profile, skip_transpilation=skip_transpilation
+        )
+
+        workspace = self.provider().get_workspace()
+        target = workspace.get_targets(self.name())
+        return target.estimate_cost(module, shots=shots)
+
+    def _get_target_profile(self, input_params) -> TargetProfile:
+        # Default to Adaptive_RI if not specified on the backend
+        # this is really just a safeguard in case the backend doesn't have a default
+        default_profile = self.options.get("target_profile", TargetProfile.Adaptive_RI)
+
+        # If the user is using the old targetCapability parameter, we'll warn them
+        # and use that value for now. This will be removed in the future.
+        if "targetCapability" in input_params:
+            warnings.warn(
+                "The 'targetCapability' parameter is deprecated and will be ignored in the future. "
+                "Please, use 'target_profile' parameter instead.",
+                category=DeprecationWarning,
+            )
+            cap = input_params.pop("targetCapability")
+            if cap == "AdaptiveExecution":
+                default_profile = TargetProfile.Adaptive_RI
+            else:
+                default_profile = TargetProfile.Base
+        # If the user specifies a target profile, use that.
+        # Otherwise, use the profile we got from the backend/targetCapability.
+        return input_params.pop("target_profile", default_profile)
 
 
 class AzureBackend(AzureBackendBase):

azure/quantum/qiskit/backends/ionq.py

@@ -7,7 +7,7 @@ from azure.quantum import __version__
 from azure.quantum.qiskit.job import AzureQuantumJob
 from azure.quantum.target.ionq import IonQ
 from abc import abstractmethod
-
+from qsharp import TargetProfile
 from qiskit import QuantumCircuit
 
 from .backend import (
@@ -20,7 +20,6 @@ from qiskit.providers.models import BackendConfiguration
 from qiskit.providers import Options, Provider
 
 from qiskit_ionq.helpers import (
-    ionq_basis_gates,
     GATESET_MAP,
     qiskit_circ_to_ionq_circ,
 )
@@ -66,7 +65,7 @@ class IonQQirBackendBase(AzureQirBackend):
             **{
                 cls._SHOTS_PARAM_NAME: _DEFAULT_SHOTS_COUNT,
             },
-            targetCapability="BasicExecution",
+            target_profile=TargetProfile.Base,
             )
 
     def _azure_config(self) -> Dict[str, str]:
@@ -77,6 +76,10 @@ class IonQQirBackendBase(AzureQirBackend):
             }
         )
         return config
+
+    def estimate_cost(self, circuits, shots, options={}):
+        """Estimate the cost for the given circuit."""
+        return self._estimate_cost_qir(circuits, shots, options)
     
     def run(
         self, 
@@ -103,7 +106,6 @@ class IonQSimulatorQirBackend(IonQQirBackendBase):
 
     def __init__(self, name: str, provider: "AzureQuantumProvider", **kwargs):
         """Base class for interfacing with an IonQ QIR Simulator backend"""
-
         default_config = BackendConfiguration.from_dict(
             {
                 "backend_name": name,
@@ -112,7 +114,7 @@ class IonQSimulatorQirBackend(IonQQirBackendBase):
                 "local": False,
                 "coupling_map": None,
                 "description": "IonQ simulator on Azure Quantum",
-                "basis_gates": ionq_basis_gates,
+                "basis_gates": self._basis_gates(),
                 "memory": False,
                 "n_qubits": 29,
                 "conditional": False,
@@ -135,7 +137,6 @@ class IonQAriaQirBackend(IonQQirBackendBase):
 
     def __init__(self, name: str, provider: "AzureQuantumProvider", **kwargs):
         """Base class for interfacing with an IonQ Aria QPU backend"""
-
         default_config = BackendConfiguration.from_dict(
             {
                 "backend_name": name,
@@ -144,9 +145,9 @@ class IonQAriaQirBackend(IonQQirBackendBase):
                 "local": False,
                 "coupling_map": None,
                 "description": "IonQ Aria QPU on Azure Quantum",
-                "basis_gates": ionq_basis_gates,
+                "basis_gates": self._basis_gates(),
                 "memory": False,
-                "n_qubits": 23,
+                "n_qubits": 25,
                 "conditional": False,
                 "max_shots": 10000,
                 "max_experiments": 1,
@@ -167,7 +168,6 @@ class IonQForteQirBackend(IonQQirBackendBase):
 
     def __init__(self, name: str, provider: "AzureQuantumProvider", **kwargs):
         """Base class for interfacing with an IonQ Forte QPU backend"""
-
         default_config = BackendConfiguration.from_dict(
             {
                 "backend_name": name,
@@ -176,7 +176,7 @@ class IonQForteQirBackend(IonQQirBackendBase):
                 "local": False,
                 "coupling_map": None,
                 "description": "IonQ Forte QPU on Azure Quantum",
-                "basis_gates": ionq_basis_gates,
+                "basis_gates": self._basis_gates(),
                 "memory": False,
                 "n_qubits": 35,
                 "conditional": False,
@@ -241,7 +241,7 @@ class IonQBackend(AzureBackend):
             "provider_id": "ionq",
             "input_data_format": "ionq.circuit.v1",
             "output_data_format": "ionq.quantum-results.v1",
-            "is_default": True,
+            "is_default": False,
         }
 
     def _prepare_job_metadata(self, circuit, **kwargs):
@@ -316,15 +316,6 @@ class IonQSimulatorNativeBackend(IonQSimulatorBackend):
             kwargs["gateset"] = "native"
         super().__init__(name, provider, **kwargs)
 
-    def _azure_config(self) -> Dict[str, str]:
-        config = super()._azure_config()
-        config.update(
-            {
-                "is_default": False,
-            }
-        )
-        return config
-
 
 class IonQAriaBackend(IonQBackend):
     backend_names = ("ionq.qpu.aria-1", "ionq.qpu.aria-2")
@@ -398,27 +389,9 @@ class IonQAriaNativeBackend(IonQAriaBackend):
             kwargs["gateset"] = "native"
         super().__init__(name, provider, **kwargs)
 
-    def _azure_config(self) -> Dict[str, str]:
-        config = super()._azure_config()
-        config.update(
-            {
-                "is_default": False,
-            }
-        )
-        return config
-
 
 class IonQForteNativeBackend(IonQForteBackend):
     def __init__(self, name: str, provider: "AzureQuantumProvider", **kwargs):
         if "gateset" not in kwargs:
             kwargs["gateset"] = "native"
         super().__init__(name, provider, **kwargs)
-
-    def _azure_config(self) -> Dict[str, str]:
-        config = super()._azure_config()
-        config.update(
-            {
-                "is_default": False,
-            }
-        )
-        return config

azure/quantum/qiskit/backends/microsoft.py

@@ -3,36 +3,17 @@
 # Licensed under the MIT License.
 ##
 
-from typing import TYPE_CHECKING, Any, Dict, List
+from typing import TYPE_CHECKING, Any, Dict, List, Union
 from azure.quantum.version import __version__
 from qiskit import QuantumCircuit
 from abc import abstractmethod
-from .backend import AzureQirBackend
+from .backend import AzureQirBackend, QIR_BASIS_GATES
 
 from qiskit.providers.models import BackendConfiguration
 from qiskit.providers import Options, Provider
-
-QIR_BASIS_GATES = [
-    "measure",
-    "m",
-    "ccx",
-    "cx",
-    "cz",
-    "h",
-    "reset",
-    "rx",
-    "ry",
-    "rz",
-    "s",
-    "sdg",
-    "swap",
-    "t",
-    "tdg",
-    "x",
-    "y",
-    "z",
-    "id",
-]
+from qsharp import TargetProfile
+from qsharp.interop.qiskit import ResourceEstimatorBackend
+import pyqir as pyqir
 
 if TYPE_CHECKING:
     from azure.quantum.qiskit import AzureQuantumProvider
@@ -55,7 +36,7 @@ class MicrosoftBackend(AzureQirBackend):
 
     @classmethod
     def _default_options(cls):
-        return Options(targetCapability="AdaptiveExecution")
+        return Options(target_profile=TargetProfile.Adaptive_RI)
 
     def _azure_config(self) -> Dict[str, str]:
         config = super()._azure_config()
@@ -63,11 +44,65 @@ class MicrosoftBackend(AzureQirBackend):
             {
                 "provider_id": "microsoft-qc",
                 "output_data_format": "microsoft.resource-estimates.v1",
-                "to_qir_kwargs": {"record_output": False},
             }
         )
         return config
 
+    def _translate_input(
+        self,
+        circuits: Union[QuantumCircuit, List[QuantumCircuit]],
+        input_params: Dict[str, Any],
+    ) -> bytes:
+        """Translates the input values to the QIR expected by the Backend."""
+        # All the logic is in the base class, but we need to override
+        # this method to ensure that the bitcode QIR format is used for RE.
+
+        # normal translation is to QIR text format in utf-8 encoded bytes
+        ir_byte_str = super()._translate_input(circuits, input_params)
+        # decode the utf-8 encoded bytes to a string
+        ir_str = ir_byte_str.decode('utf-8')
+        # convert the QIR text format to QIR bitcode format
+        module = pyqir.Module.from_ir(pyqir.Context(), ir_str)
+        return module.bitcode
+
+    def _generate_qir(
+        self, circuits: List[QuantumCircuit], target_profile: TargetProfile, **kwargs
+    ) -> pyqir.Module:
+        if len(circuits) == 0:
+            raise ValueError("No QuantumCircuits provided")
+
+        name = "circuits"
+        if isinstance(circuits, QuantumCircuit):
+            name = circuits.name
+            circuits = [circuits]
+        elif isinstance(circuits, list):
+            for value in circuits:
+                if not isinstance(value, QuantumCircuit):
+                    raise ValueError(
+                        "Input must be Union[QuantumCircuit, List[QuantumCircuit]]"
+                    )
+        else:
+            raise ValueError(
+                "Input must be Union[QuantumCircuit, List[QuantumCircuit]]"
+            )
+
+        skip_transpilation = kwargs.pop("skip_transpilation", False)
+        backend = ResourceEstimatorBackend(
+            skip_transpilation=skip_transpilation, **kwargs
+        )
+        context = pyqir.Context()
+        llvm_module = pyqir.qir_module(context, name)
+        for circuit in circuits:
+            qir_str = backend.qir(circuit, target_profile=target_profile)
+            module = pyqir.Module.from_ir(context, qir_str)
+            llvm_module.link(module)
+
+        err = llvm_module.verify()
+        if err is not None:
+            raise Exception(err)
+
+        return llvm_module
+
 
 class MicrosoftResourceEstimationBackend(MicrosoftBackend):
     """Backend class for interfacing with the resource estimator target"""
@@ -77,7 +112,7 @@ class MicrosoftResourceEstimationBackend(MicrosoftBackend):
     @classmethod
     def _default_options(cls):
         return Options(
-            targetCapability="AdaptiveExecution",
+            target_profile=TargetProfile.Adaptive_RI,
             errorBudget=1e-3,
             qubitParams={"name": "qubit_gate_ns_e3"},
             qecScheme={"name": "surface_code"}

azure/quantum/qiskit/backends/qci.py

@@ -3,7 +3,7 @@
 # Licensed under the MIT License.
 ##
 
-from typing import TYPE_CHECKING, Dict
+from typing import TYPE_CHECKING, Dict, List
 from azure.quantum.version import __version__
 from azure.quantum.qiskit.job import AzureQuantumJob
 from abc import abstractmethod
@@ -14,28 +14,8 @@ from .backend import (
 
 from qiskit.providers.models import BackendConfiguration
 from qiskit.providers import Options, Provider
+from qsharp import TargetProfile
 
-QIR_BASIS_GATES  = [
-    "measure",
-    "m",
-    "barrier",
-    "cx",
-    "cz",
-    "h",
-    "reset",
-    "rx",
-    "ry",
-    "rz",
-    "s",
-    "sdg",
-    "swap",
-    "t",
-    "tdg",
-    "x",
-    "y",
-    "z",
-    "id",
-]
 
 if TYPE_CHECKING:
     from azure.quantum.qiskit import AzureQuantumProvider
@@ -65,7 +45,7 @@ class QCIBackend(AzureQirBackend):
             **{
                 cls._SHOTS_PARAM_NAME: _DEFAULT_SHOTS_COUNT, 
             },
-            targetCapability="AdaptiveExecution",
+            target_profile=TargetProfile.Adaptive_RI,
         )
 
     def _azure_config(self) -> Dict[str, str]:
@@ -76,9 +56,12 @@ class QCIBackend(AzureQirBackend):
             }
         )
         return config
-    
+
+    def _basis_gates(self) -> List[str]:
+        return super()._basis_gates() + ["barrier"]
+
     def run(
-        self, 
+        self,
         run_input=None,
         shots: int = None,
         **options,
@@ -110,7 +93,7 @@ class QCISimulatorBackend(QCIBackend):
                 "local": False,
                 "coupling_map": None,
                 "description": "QCI simulator on Azure Quantum",
-                "basis_gates": QIR_BASIS_GATES,
+                "basis_gates": self._basis_gates(),
                 "memory": False,
                 "n_qubits": 29,
                 "conditional": True,
@@ -142,7 +125,7 @@ class QCIQPUBackend(QCIBackend):
                 "local": False,
                 "coupling_map": None,
                 "description": "QCI QPU on Azure Quantum",
-                "basis_gates": QIR_BASIS_GATES,
+                "basis_gates": self._basis_gates(),
                 "memory": False,
                 "n_qubits": 11,
                 "conditional": True,

azure/quantum/qiskit/backends/quantinuum.py

@@ -15,7 +15,7 @@ from qiskit.providers.models import BackendConfiguration
 from qiskit.providers import Options
 from qiskit.providers import Provider
 from qiskit.qasm2 import dumps
-
+from qsharp import TargetProfile
 import logging
 
 logger = logging.getLogger(__name__)
@@ -50,6 +50,7 @@ QUANTINUUM_BASIS_GATES = [
     "reset",
 ]
 
+
 QUANTINUUM_PROVIDER_ID = "quantinuum"
 QUANTINUUM_PROVIDER_NAME = "Quantinuum"
 
@@ -59,7 +60,7 @@ def _get_n_qubits(name):
     if ".h1-" in name or "hqs-lt" in name:
         return 20
     if ".h2-" in name:
-        return 32
+        return 56
     warnings.warn(
         UserWarning(f"Number of qubits not known for target {name}. Defaulting to 20."))
     return 20
@@ -83,7 +84,7 @@ class QuantinuumQirBackendBase(AzureQirBackend):
             **{
                 cls._SHOTS_PARAM_NAME: _DEFAULT_SHOTS_COUNT
             },
-            targetCapability="BasicExecution",
+            target_profile=TargetProfile.Adaptive_RI,
         )
 
     def _azure_config(self) -> Dict[str, str]:
@@ -97,6 +98,10 @@ class QuantinuumQirBackendBase(AzureQirBackend):
 
     def _get_n_qubits(self, name):
         return _get_n_qubits(name)
+    
+    def estimate_cost(self, circuits, shots, options={}):
+        """Estimate the cost for the given circuit."""
+        return self._estimate_cost_qir(circuits, shots, options)
 
 
 class QuantinuumSyntaxCheckerQirBackend(QuantinuumQirBackendBase):
@@ -118,7 +123,7 @@ class QuantinuumSyntaxCheckerQirBackend(QuantinuumQirBackendBase):
                 "local": False,
                 "coupling_map": None,
                 "description": f"Quantinuum Syntax Checker on Azure Quantum",
-                "basis_gates": QUANTINUUM_BASIS_GATES,
+                "basis_gates": self._basis_gates(),
                 "memory": True,
                 "n_qubits": self._get_n_qubits(name),
                 "conditional": False,
@@ -155,7 +160,7 @@ class QuantinuumEmulatorQirBackend(QuantinuumQirBackendBase):
                 "local": False,
                 "coupling_map": None,
                 "description": f"Quantinuum emulator on Azure Quantum",
-                "basis_gates": QUANTINUUM_BASIS_GATES,
+                "basis_gates": self._basis_gates(),
                 "memory": True,
                 "n_qubits": self._get_n_qubits(name),
                 "conditional": False,
@@ -192,7 +197,7 @@ class QuantinuumQPUQirBackend(QuantinuumQirBackendBase):
                 "local": False,
                 "coupling_map": None,
                 "description": f"Quantinuum QPU on Azure Quantum",
-                "basis_gates": QUANTINUUM_BASIS_GATES,
+                "basis_gates": self._basis_gates(),
                 "memory": True,
                 "n_qubits": self._get_n_qubits(name),
                 "conditional": False,
@@ -236,7 +241,7 @@ class QuantinuumBackend(AzureBackend):
             "provider_id": self._provider_id,
             "input_data_format": "honeywell.openqasm.v1",
             "output_data_format": "honeywell.quantum-results.v1",
-            "is_default": True,
+            "is_default": False,
         }
 
     def _translate_input(self, circuit):