azure-quantum 2.2.0.dev3__tar.gz → 2.2.0.dev5__tar.gz

{azure-quantum-2.2.0.dev3 → azure-quantum-2.2.0.dev5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: azure-quantum
-Version: 2.2.0.dev3
+Version: 2.2.0.dev5
 Summary: Python client for Azure Quantum
 Home-page: https://github.com/microsoft/azure-quantum-python
 Author: Microsoft

{azure-quantum-2.2.0.dev3 → azure-quantum-2.2.0.dev5}/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.2.0.dev3"
+VERSION = "2.2.0.dev5"

{azure-quantum-2.2.0.dev3 → azure-quantum-2.2.0.dev5}/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,23 +37,37 @@ 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 = [
-    "x",
-    "y",
-    "z",
+    "measure",
+    "reset",
+    "ccx",
+    "cx",
+    "cy",
+    "cz",
     "rx",
+    "rxx",
+    "crx",
     "ry",
+    "ryy",
+    "cry",
     "rz",
+    "rzz",
+    "crz",
     "h",
-    "swap",
-    "cx",
-    "cz",
-    "reset",
     "s",
     "sdg",
+    "swap",
     "t",
     "tdg",
-    "measure",
+    "x",
+    "y",
+    "z",
+    "id",
+    "ch",
 ]
 
 
@@ -391,98 +406,139 @@ 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)
+            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, shots, options={}):
+    def _estimate_cost_qir(
+        self, circuits: Union[QuantumCircuit, List[QuantumCircuit]], shots, options={}
+    ):
         """Estimate the cost for the given circuit."""
-        config = self.configuration()
         input_params = self._get_input_params(options, shots=shots)
 
         if not (isinstance(circuits, list)):
             circuits = [circuits]
-        
-        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"),
-        )
 
-        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
-            )
-        
-
-        (module, _) = self._generate_qir(
-            circuits, targetCapability, **to_qir_kwargs
+        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):
     """Base class for interfacing with a backend in Azure Quantum"""

{azure-quantum-2.2.0.dev3 → azure-quantum-2.2.0.dev5}/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 (
@@ -65,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]:
@@ -147,7 +147,7 @@ class IonQAriaQirBackend(IonQQirBackendBase):
                 "description": "IonQ Aria QPU on Azure Quantum",
                 "basis_gates": self._basis_gates(),
                 "memory": False,
-                "n_qubits": 23,
+                "n_qubits": 25,
                 "conditional": False,
                 "max_shots": 10000,
                 "max_experiments": 1,

azure-quantum-2.2.0.dev5/azure/quantum/qiskit/backends/microsoft.py

@@ -0,0 +1,161 @@
+##
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+##
+
+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, QIR_BASIS_GATES
+
+from qiskit.providers.models import BackendConfiguration
+from qiskit.providers import Options, Provider
+from qsharp import TargetProfile
+from qsharp.interop.qiskit import ResourceEstimatorBackend
+import pyqir as pyqir
+
+if TYPE_CHECKING:
+    from azure.quantum.qiskit import AzureQuantumProvider
+
+import logging
+
+logger = logging.getLogger(__name__)
+
+__all__ = ["MicrosoftBackend", "MicrosoftResourceEstimationBackend"]
+
+
+class MicrosoftBackend(AzureQirBackend):
+    """Base class for interfacing with a Microsoft backend in Azure Quantum"""
+
+    @abstractmethod
+    def __init__(
+        self, configuration: BackendConfiguration, provider: Provider = None, **fields
+    ):
+        super().__init__(configuration, provider, **fields)
+
+    @classmethod
+    def _default_options(cls):
+        return Options(target_profile=TargetProfile.Adaptive_RI)
+
+    def _azure_config(self) -> Dict[str, str]:
+        config = super()._azure_config()
+        config.update(
+            {
+                "provider_id": "microsoft-qc",
+                "output_data_format": "microsoft.resource-estimates.v1",
+            }
+        )
+        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)
+
+        # Add NOOP for recording output tuples
+        # the service isn't set up to handle any output recording calls
+        # and the Q# compiler will always emit them.
+        noop_tuple_record_output = """; NOOP the extern calls to recording output tuples
+define void @__quantum__rt__tuple_record_output(i64, i8*) {
+  ret void
+}"""
+        noop_tuple_record_output_module = pyqir.Module.from_ir(
+            context, noop_tuple_record_output
+        )
+        llvm_module.link(noop_tuple_record_output_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"""
+
+    backend_names = ("microsoft.estimator",)
+
+    @classmethod
+    def _default_options(cls):
+        return Options(
+            target_profile=TargetProfile.Adaptive_RI,
+            errorBudget=1e-3,
+            qubitParams={"name": "qubit_gate_ns_e3"},
+            qecScheme={"name": "surface_code"}
+        )
+
+    def __init__(self, name: str, provider: "AzureQuantumProvider", **kwargs):
+        """Constructor for class to interface with the resource estimator target"""
+        default_config = BackendConfiguration.from_dict(
+            {
+                "backend_name": name,
+                "backend_version": __version__,
+                "simulator": True,
+                "local": False,
+                "coupling_map": None,
+                "description": "Resource estimator on Azure Quantum",
+                "basis_gates": QIR_BASIS_GATES,
+                "memory": False,
+                "n_qubits": 0xFFFFFFFFFFFFFFFF,  # NOTE: maximum 64-bit unsigned value
+                "conditional": True,
+                "max_shots": 1,
+                "max_experiments": 1,
+                "open_pulse": False,
+                "gates": [
+                    {"name": "TODO", "parameters": [], "qasm_def": "TODO"}
+                ],  # NOTE: copied from other backends
+                "azure": self._azure_config(),
+                "is_default": True,
+            }
+        )
+        logger.info("Initializing MicrosoftResourceEstimationBackend")
+        configuration: BackendConfiguration = kwargs.pop(
+            "configuration", default_config
+        )
+        super().__init__(configuration=configuration, provider=provider, **kwargs)

{azure-quantum-2.2.0.dev3 → azure-quantum-2.2.0.dev5}/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,6 +14,8 @@ from .backend import (
 
 from qiskit.providers.models import BackendConfiguration
 from qiskit.providers import Options, Provider
+from qsharp import TargetProfile
+
 
 if TYPE_CHECKING:
     from azure.quantum.qiskit import AzureQuantumProvider
@@ -43,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]:
@@ -54,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,

{azure-quantum-2.2.0.dev3 → azure-quantum-2.2.0.dev5}/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,23 +50,6 @@ QUANTINUUM_BASIS_GATES = [
     "reset",
 ]
 
-QUANTINUUM_QIR_BASIS_GATES = [
-    "x",
-    "y",
-    "z",
-    "rx",
-    "ry",
-    "rz",
-    "h",
-    "cx",
-    "cz",
-    "reset",
-    "s",
-    "sdg",
-    "t",
-    "tdg",
-    "measure",
-]
 
 QUANTINUUM_PROVIDER_ID = "quantinuum"
 QUANTINUUM_PROVIDER_NAME = "Quantinuum"
@@ -101,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]:
@@ -112,9 +95,6 @@ class QuantinuumQirBackendBase(AzureQirBackend):
             }
         )
         return config
-    
-    def _basis_gates(self) -> List[str]:
-        return QUANTINUUM_QIR_BASIS_GATES
 
     def _get_n_qubits(self, name):
         return _get_n_qubits(name)

{azure-quantum-2.2.0.dev3 → azure-quantum-2.2.0.dev5}/azure/quantum/qiskit/backends/rigetti.py

@@ -11,6 +11,7 @@ from .backend import AzureQirBackend
 
 from qiskit.providers.models import BackendConfiguration
 from qiskit.providers import Options, Provider
+from qsharp import TargetProfile
 
 if TYPE_CHECKING:
     from azure.quantum.qiskit import AzureQuantumProvider
@@ -40,7 +41,7 @@ class RigettiBackend(AzureQirBackend):
         other_options = {
             cls._SHOTS_PARAM_NAME: _DEFAULT_SHOTS_COUNT,
         }
-        return Options(targetCapability="BasicExecution", **other_options)
+        return Options(target_profile=TargetProfile.Base, **other_options)
 
     def _azure_config(self) -> Dict[str, str]:
         config = super()._azure_config()

{azure-quantum-2.2.0.dev3 → azure-quantum-2.2.0.dev5}/azure/quantum/qiskit/job.py

@@ -212,7 +212,7 @@ class AzureQuantumJob(JobV1):
 
     @staticmethod
     def _qir_to_qiskit_bitstring(obj):
-        """Convert the data structure from Azure into the "schema" used by Qiskit """
+        """Convert the data structure from Azure into the "schema" used by Qiskit"""
         if isinstance(obj, str) and not re.match(r"[\d\s]+$", obj):
             obj = ast.literal_eval(obj)
 
@@ -220,7 +220,12 @@ class AzureQuantumJob(JobV1):
             # the outermost implied container is a tuple, and each item is
             # associated with a classical register. Azure and Qiskit order the
             # registers in opposite directions, so reverse here to match.
-            return " ".join([AzureQuantumJob._qir_to_qiskit_bitstring(term) for term in reversed(obj)])
+            return " ".join(
+                [
+                    AzureQuantumJob._qir_to_qiskit_bitstring(term)
+                    for term in obj
+                ]
+            )
         elif isinstance(obj, list):
             # a list is for an individual classical register
             return "".join([str(bit) for bit in obj])

{azure-quantum-2.2.0.dev3 → azure-quantum-2.2.0.dev5}/azure/quantum/target/ionq.py

@@ -59,12 +59,16 @@ class IonQ(Target):
         name: str = "ionq.simulator",
         input_data_format: str = "ionq.circuit.v1",
         output_data_format: str = "ionq.quantum-results.v1",
-        capability: str = "BasicExecution",
+        capability: str = "",
         provider_id: str = "IonQ",
         content_type: str = "application/json",
         encoding: str = "",
-        **kwargs
+        target_profile: Union[str, "TargetProfile"] = "Base",
+        **kwargs,
     ):
+        if capability:
+            msg = "The 'capability' parameter is not used for the Quantinuum target."
+            warn(msg, DeprecationWarning)
         super().__init__(
             workspace=workspace,
             name=name,
@@ -74,7 +78,8 @@ class IonQ(Target):
             provider_id=provider_id,
             content_type=content_type,
             encoding=encoding,
-            **kwargs
+            target_profile=target_profile,
+            **kwargs,
         )
 
     def submit(

{azure-quantum-2.2.0.dev3 → azure-quantum-2.2.0.dev5}/azure/quantum/target/microsoft/target.py

@@ -392,6 +392,7 @@ class MicrosoftEstimator(Target):
             output_data_format="microsoft.resource-estimates.v1",
             provider_id="microsoft-qc",
             content_type=ContentType.json,
+            target_profile="Adaptive_RI",
             **kwargs
         )
 
@@ -422,14 +423,32 @@ class MicrosoftEstimator(Target):
             warnings.warn("The 'shots' parameter is ignored in resource estimation job.")
 
         try:
-            from qiskit import QuantumCircuit, transpile
-            from qiskit_qir import to_qir_module
-            from qiskit_qir.visitor import SUPPORTED_INSTRUCTIONS
+            from qiskit import QuantumCircuit
+            from qsharp import TargetProfile
+            from qsharp.interop.qiskit import ResourceEstimatorBackend
+            from pyqir import Context, Module
+
             if isinstance(input_data, QuantumCircuit):
-                input_data = transpile(input_data,
-                                       basis_gates=SUPPORTED_INSTRUCTIONS,
-                                       optimization_level=0)
-                (module, _) = to_qir_module(input_data, record_output=False)
+                backend = ResourceEstimatorBackend()
+                target_profile = TargetProfile.from_str(self.target_profile)
+                qir_str = backend.qir(input_data, target_profile=target_profile)
+                context = Context()
+                module = Module.from_ir(context, qir_str)
+                # Add NOOP for recording output tuples
+                # the service isn't set up to handle any output recording calls
+                # and the Q# compiler will always emit them.
+                noop_tuple_record_output = """; NOOP the extern calls to recording output tuples
+define void @__quantum__rt__tuple_record_output(i64, i8*) {
+ret void
+}"""
+                noop_tuple_record_output_module = Module.from_ir(
+                    context, noop_tuple_record_output
+                )
+                module.link(noop_tuple_record_output_module)
+
+                err = module.verify()
+                if err is not None:
+                    raise Exception(err)
                 input_data = module.bitcode
         finally:
             return super().submit(