azure-quantum 2.2.0.dev6__py3-none-any.whl → 2.4.0__py3-none-any.whl

azure/quantum/target/microsoft/elements/dft/target.py

@@ -5,8 +5,11 @@ from azure.quantum.job.job import Job
 from azure.quantum.target.target import Target
 from azure.quantum.workspace import Workspace
 from azure.quantum.target.params import InputParams
-from typing import Any, Dict, Type, Union
+from typing import Any, Dict, Type, Union, List
 from .job import MicrosoftElementsDftJob
+from pathlib import Path
+import copy
+import json
 
 
 class MicrosoftElementsDft(Target):
@@ -73,15 +76,162 @@ class MicrosoftElementsDft(Target):
         if shots is not None:
             warnings.warn("The 'shots' parameter is ignored in Microsoft Elements Dft job.")
         
-        return super().submit(
-            input_data=input_data,
-            name=name, 
-            shots=shots, 
-            input_params=input_params,
-            **kwargs
-        )
+        if isinstance(input_data, list):
+
+            qcschema_data = self._assemble_qcshema_from_files(input_data, input_params)
+
+            qcschema_blobs = {}
+            for i in range(len(qcschema_data)):
+                qcschema_blobs[f"inputData_{i}"] = self._encode_input_data(qcschema_data[i])
 
+            toc_str = self._create_table_of_contents(input_data, list(qcschema_blobs.keys()))
+            toc = self._encode_input_data(toc_str)
+
+            return self._get_job_class().from_input_data_container(
+                workspace=self.workspace,
+                name=name,
+                target=self.name,
+                input_data=toc,
+                batch_input_blobs=qcschema_blobs,
+                input_params={ 'numberOfFiles': len(qcschema_data), "inputFiles": list(qcschema_blobs.keys()), **input_params },
+                content_type=kwargs.pop('content_type', self.content_type),
+                encoding=kwargs.pop('encoding', self.encoding),
+                provider_id=self.provider_id,
+                input_data_format=kwargs.pop('input_data_format', 'microsoft.qc-schema.v1'),
+                output_data_format=kwargs.pop('output_data_format', self.output_data_format),
+                session_id=self.get_latest_session_id(),
+                **kwargs
+            )
+        else:
+            return super().submit(
+                input_data=input_data,
+                name=name, 
+                shots=shots, 
+                input_params=input_params,
+                **kwargs
+            )
+
+
+    
+    @classmethod
+    def _assemble_qcshema_from_files(self, input_data: List[str], input_params: Dict) -> str:
+        """
+        Convert a list of files to a list of qcshema objects serialized in json.
+        """
+
+        qcshema_objects = []
+        for file in input_data:
+            file_path = Path(file)
+            if not file_path.exists():
+                raise FileNotFoundError(f"File {file} does not exist.")
+            
+            file_data = file_path.read_text()
+            if file_path.suffix == '.xyz':
+                mol = self._xyz_to_qcschema_mol(file_data)
+                new_qcschema = self._new_qcshema( input_params, mol )
+                qcshema_objects.append(new_qcschema)
+            elif file_path.suffix == '.json':
+                if input_params is not None and len(input_params.keys()) > 0:
+                    warnings.warn('Input parameters were given along with a QcSchema file which contains parameters, using QcSchema parameters as is.')
+                with open(file_path, 'r') as f:
+                    qcshema_objects.append( json.load(f) )
+            else:
+                raise ValueError(f"File type '{file_path.suffix}' for file '{file_path}' is not supported. Please use xyz or QcSchema file formats.")
+
+        return qcshema_objects
+
+    @classmethod
+    def _new_qcshema( self, input_params: Dict[str,Any], mol: Dict[str,Any],  ) -> Dict[str, Any]:
+        """
+        Create a new default qcshema object.
+        """
+
+        if input_params.get("driver") == "go":
+            copy_input_params = copy.deepcopy(input_params)
+            copy_input_params["driver"] = "gradient"
+            new_object = {
+                "schema_name": "qcschema_optimization_input",
+                "schema_version": 1,
+                "initial_molecule": mol,
+            }
+            if copy_input_params.get("keywords") and copy_input_params["keywords"].get("geometryOptimization"):
+                new_object["keywords"] = copy_input_params["keywords"].pop("geometryOptimization")
+            new_object["input_specification"] = copy_input_params
+            return new_object
+        elif input_params.get("driver") == "bomd":
+            copy_input_params = copy.deepcopy(input_params)
+            copy_input_params["driver"] = "gradient"
+            new_object = {
+                "schema_name": "madft_molecular_dynamics_input",
+                "schema_version": 1,
+                "initial_molecule": mol,
+            }
+            if copy_input_params.get("keywords") and copy_input_params["keywords"].get("molecularDynamics"):
+                new_object["keywords"] = copy_input_params["keywords"].pop("molecularDynamics")
+            new_object["input_specification"] = copy_input_params
+            return new_object
+        else:
+            new_object = copy.deepcopy(input_params)
+            new_object.update({
+                "schema_name": "qcschema_input",
+                "schema_version": 1,
+                "molecule": mol,
+            })
+            return new_object
+            
+
+    @classmethod
+    def _xyz_to_qcschema_mol(self, file_data: str ) -> Dict[str, Any]:
+        """
+        Convert xyz format to qcschema molecule.
+        """
+
+        lines = file_data.split("\n")
+        if len(lines) < 3:
+            raise ValueError("Invalid xyz format.")
+        n_atoms = int(lines.pop(0))
+        comment = lines.pop(0)
+        mol = {
+            "geometry": [],
+            "symbols": [],
+        }
+        bohr_to_angstrom = 0.52917721092
+        for line in lines:
+            if line:
+                elements = line.split()
+                if len(elements) < 4:
+                    raise ValueError("Invalid xyz format.")
+                symbol, x, y, z = elements
+                mol["symbols"].append(symbol)
+                mol["geometry"] += [float(x)/bohr_to_angstrom, float(y)/bohr_to_angstrom, float(z)/bohr_to_angstrom]
+            else:
+                break
+        
+        if len(mol["symbols"]) != n_atoms:
+            raise ValueError("Number of inputs does not match the number of atoms in xyz file.")
+
+        return mol
 
     @classmethod
     def _get_job_class(cls) -> Type[Job]:
         return MicrosoftElementsDftJob
+
+    @classmethod
+    def _create_table_of_contents(cls, input_files: List[str], input_blobs: List[str]) -> Dict[str,Any]:
+        """Create the table of contents for a batched job that contains a description of file and the mapping between the file names and the blob names"""
+
+        assert len(input_files) == len(input_blobs), "Internal error: number of blobs is not that same as the number of files."
+
+        toc = []
+        for i in range(len(input_files)):
+            toc.append( 
+                {
+                    "inputFileName": input_files[i],
+                    "qcschemaBlobName": input_blobs[i],
+                }
+            )
+
+        return {
+            "description": "This files contains the mapping between the xyz file name that were submitted and the qcschema blobs that are used for the calculation.",
+            "tableOfContents": toc,
+        }

azure/quantum/target/microsoft/target.py

@@ -13,29 +13,6 @@ from ...workspace import Workspace
 from ..params import InputParams, InputParamsItem, AutoValidatingParams, \
     validating_field
 from ..target import Target
-from . import MicrosoftEstimatorJob
-
-class QubitParams:
-    """
-    Resource estimator Qubit parameters.
-    """
-
-    GATE_US_E3 = "qubit_gate_us_e3"
-    GATE_US_E4 = "qubit_gate_us_e4"
-    GATE_NS_E3 = "qubit_gate_ns_e3"
-    GATE_NS_E4 = "qubit_gate_ns_e4"
-    MAJ_NS_E4 = "qubit_maj_ns_e4"
-    MAJ_NS_E6 = "qubit_maj_ns_e6"
-
-
-class QECScheme:
-    """
-    Resource estimator QEC Scheme.
-    """
-
-    SURFACE_CODE = "surface_code"
-    FLOQUET_CODE = "floquet_code"
-
 
 def _check_error_rate(name, value):
     if value <= 0.0 or value >= 1.0:
@@ -64,90 +41,6 @@ class MeasurementErrorRate(AutoValidatingParams):
     process: float = field(metadata={"validate": _check_error_rate})
     readout: float = field(metadata={"validate": _check_error_rate})
 
-@dataclass
-class MicrosoftEstimatorQubitParams(AutoValidatingParams):
-    @staticmethod
-    def check_instruction_set(name, value):
-        if value not in ["gate-based", "gate_based", "GateBased", "gateBased",
-                         "Majorana", "majorana"]:
-            raise ValueError(f"{name} must be GateBased or Majorana")
-
-    name: Optional[str] = None
-    instruction_set: Optional[str] = validating_field(check_instruction_set)
-    one_qubit_measurement_time: Optional[str] = validating_field(check_time)
-    two_qubit_joint_measurement_time: Optional[str] = \
-        validating_field(check_time)
-    one_qubit_gate_time: Optional[str] = validating_field(check_time)
-    two_qubit_gate_time: Optional[str] = validating_field(check_time)
-    t_gate_time: Optional[str] = validating_field(check_time)
-    one_qubit_measurement_error_rate: Union[None, float, MeasurementErrorRate] = \
-        validating_field(_check_error_rate_or_process_and_readout)
-    two_qubit_joint_measurement_error_rate: Union[None, float, MeasurementErrorRate] = \
-        validating_field(_check_error_rate_or_process_and_readout)
-    one_qubit_gate_error_rate: Optional[float] = \
-        validating_field(_check_error_rate)
-    two_qubit_gate_error_rate: Optional[float] = \
-        validating_field(_check_error_rate)
-    t_gate_error_rate: Optional[float] = validating_field(_check_error_rate)
-    idle_error_rate: Optional[float] = validating_field(_check_error_rate)
-
-    _default_models = [QubitParams.GATE_US_E3, QubitParams.GATE_US_E4,
-                       QubitParams.GATE_NS_E3, QubitParams.GATE_NS_E4,
-                       QubitParams.MAJ_NS_E4, QubitParams.MAJ_NS_E6]
-    _gate_based = ["gate-based", "gate_based", "GateBased", "gateBased"]
-    _maj_based = ["Majorana", "majorana"]
-
-    def post_validation(self, result):
-        # check whether all fields have been specified in case a custom qubit
-        # model is specified
-        custom = result != {} and \
-            (self.name is None or self.name not in self._default_models)
-
-        # no further validation needed for non-custom models
-        if not custom:
-            return
-
-        # instruction set must be set
-        if self.instruction_set is None:
-            raise LookupError("instruction_set must be set for custom qubit "
-                              "parameters")
-
-        # NOTE at this point, we know that instruction set must have valid
-        # value
-        if self.one_qubit_measurement_time is None:
-            raise LookupError("one_qubit_measurement_time must be set")
-        if self.one_qubit_measurement_error_rate is None:
-            raise LookupError("one_qubit_measurement_error_rate must be set")
-
-        # this only needs to be checked for gate based qubits
-        if self.instruction_set in self._gate_based:
-            if self.one_qubit_gate_time is None:
-                raise LookupError("one_qubit_gate_time must be set")
-
-    def as_dict(self, validate=True) -> Dict[str, Any]:
-        qubit_params = super().as_dict(validate)
-        if len(qubit_params) != 0:
-            if isinstance(self.one_qubit_measurement_error_rate, MeasurementErrorRate):
-                qubit_params["oneQubitMeasurementErrorRate"] = \
-                self.one_qubit_measurement_error_rate.as_dict(validate)
-
-            if isinstance(self.two_qubit_joint_measurement_error_rate, MeasurementErrorRate):
-                qubit_params["twoQubitJointMeasurementErrorRate"] = \
-                self.two_qubit_joint_measurement_error_rate.as_dict(validate)
-
-        return qubit_params
-
-
-@dataclass
-class MicrosoftEstimatorQecScheme(AutoValidatingParams):
-    name: Optional[str] = None
-    error_correction_threshold: Optional[float] = \
-        validating_field(_check_error_rate)
-    crossing_prefactor: Optional[float] = None
-    logical_cycle_time: Optional[str] = None
-    physical_qubits_per_logical_qubit: Optional[str] = None
-
-
 @dataclass
 class ProtocolSpecificDistillationUnitSpecification(AutoValidatingParams):
     num_unit_qubits: Optional[int] = None
@@ -247,225 +140,3 @@ class DistillationUnitSpecification(AutoValidatingParams):
                         logical_qubit_specification_first_round_override_dict
 
         return specification_dict
-
-
-@dataclass
-class ErrorBudgetPartition(AutoValidatingParams):
-    """
-    Resource estimator error budget partition parameters.
-    """
-    logical: float = 0.001 / 3
-    t_states: float = 0.001 / 3
-    rotations: float = 0.001 / 3
-
-
-@dataclass
-class MicrosoftEstimatorConstraints(AutoValidatingParams):
-    """
-    Resource estimator constraints.
-    """
-
-    @staticmethod
-    def at_least_one(name, value):
-        if value < 1:
-            raise ValueError(f"{name} must be at least 1")
-
-    logical_depth_factor: Optional[float] = validating_field(at_least_one)
-    max_t_factories: Optional[int] = validating_field(at_least_one)
-    max_duration: Optional[int] = validating_field(check_time)
-    max_physical_qubits: Optional[int] = validating_field(at_least_one)
-
-    def post_validation(self, result):
-        if self.max_duration is not None and self.max_physical_qubits is not None:
-            raise LookupError("Both duration and number of physical qubits constraints are provided, but only one is allowe at a time.")
-
-
-@dataclass
-class MicrosoftEstimatorProfiling(AutoValidatingParams):
-    @staticmethod
-    def at_most_30(name, value):
-        if value < 0 or value > 30:
-            raise ValueError(f"{name} must be nonnegative and at most 30")
-
-    call_stack_depth: Optional[int] = validating_field(at_most_30)
-    inline_functions: Optional[bool] = None
-
-
-class MicrosoftEstimatorInputParamsItem(InputParamsItem):
-    """
-    Input params for microsoft.estimator target
-
-    :ivar error_budget Total error budget for execution of the algorithm
-    """
-
-    def __init__(self):
-        super().__init__()
-
-        self.qubit_params: MicrosoftEstimatorQubitParams = \
-            MicrosoftEstimatorQubitParams()
-        self.qec_scheme: MicrosoftEstimatorQecScheme = \
-            MicrosoftEstimatorQecScheme()
-        self.distillation_unit_specifications = []  # type: List[DistillationUnitSpecification]
-        self.constraints: MicrosoftEstimatorConstraints = \
-            MicrosoftEstimatorConstraints()
-        self.profiling: MicrosoftEstimatorProfiling = \
-            MicrosoftEstimatorProfiling()
-        self.error_budget: Optional[Union[float, ErrorBudgetPartition]] = None
-
-    def as_dict(self, validate=True) -> Dict[str, Any]:
-        result = super().as_dict(validate)
-
-        qubit_params = self.qubit_params.as_dict(validate)
-        if len(qubit_params) != 0:
-            result["qubitParams"] = qubit_params
-
-        qec_scheme = self.qec_scheme.as_dict(validate)
-        if len(qec_scheme) != 0:
-            result["qecScheme"] = qec_scheme
-
-        for specification in self.distillation_unit_specifications:
-            specification_dict = specification.as_dict(validate)
-            if len(specification_dict) != 0:
-                if result.get("distillationUnitSpecifications") is None:
-                    result["distillationUnitSpecifications"] = []
-
-                result["distillationUnitSpecifications"].append(specification_dict)
-
-        constraints = self.constraints.as_dict(validate)
-        if len(constraints) != 0:
-            result["constraints"] = constraints
-
-        profiling = self.profiling.as_dict(validate)
-        if len(profiling) != 0:
-            result["profiling"] = profiling
-
-        if self.error_budget is not None:
-            if isinstance(self.error_budget, float) or \
-                    isinstance(self.error_budget, int):
-                if validate and \
-                        (self.error_budget <= 0 or self.error_budget >= 1):
-                    message = "error_budget must be value between 0 and 1"
-                    raise ValueError(message)
-                result["errorBudget"] = self.error_budget
-            elif isinstance(self.error_budget, ErrorBudgetPartition):
-                result["errorBudget"] = self.error_budget.as_dict(validate)
-
-        return result
-
-
-class MicrosoftEstimatorParams(InputParams, MicrosoftEstimatorInputParamsItem):
-    """
-    Resource estimator input parameters.
-    """
-    def __init__(self, num_items: Optional[int] = None):
-        InputParams.__init__(
-            self,
-            num_items=num_items,
-            item_type=MicrosoftEstimatorInputParamsItem)
-
-
-class MicrosoftEstimator(Target):
-    """
-    Resource estimator target from the microsoft-qc provider.
-    """
-
-    target_names = [
-        "microsoft.estimator"
-    ]
-
-    def __init__(
-        self,
-        workspace: "Workspace",
-        name: str = "microsoft.estimator",
-        **kwargs
-    ):
-        # There is only a single target name for this target
-        assert name == self.target_names[0]
-
-        # make sure to not pass argument twice
-        kwargs.pop("provider_id", None)
-
-        super().__init__(
-            workspace=workspace,
-            name=name,
-            input_data_format="qir.v1",
-            output_data_format="microsoft.resource-estimates.v1",
-            provider_id="microsoft-qc",
-            content_type=ContentType.json,
-            target_profile="Adaptive_RI",
-            **kwargs
-        )
-
-    def submit(
-        self,
-        input_data: Any,
-        name: str = "azure-quantum-job",
-        shots: int = None,
-        input_params: Union[Dict[str, Any], InputParams, None] = None,
-        **kwargs,
-    ) -> Job:
-        """
-        Submit an estimation job.
-
-        :param input_data: Input data
-        :type input_data: Any
-        :param name: Job name
-        :type name: str
-        :param shots: Number of shots. Ignored in estimation. Defaults to None
-        :type shots: int
-        :param input_params: Input parameters
-        :type input_params: Dict[str, Any]
-        :return: Azure Quantum job
-        :rtype: Job
-        """
-
-        if shots is not None:
-            warnings.warn("The 'shots' parameter is ignored in resource estimation job.")
-
-        try:
-            from qiskit import QuantumCircuit
-            from qsharp import TargetProfile
-            from qsharp.interop.qiskit import ResourceEstimatorBackend
-            from pyqir import Context, Module
-
-            if isinstance(input_data, QuantumCircuit):
-                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(
-                input_data=input_data, 
-                name=name, 
-                shots=shots,
-                input_params=input_params, 
-                **kwargs
-            )
-
-    @classmethod
-    def _get_job_class(cls) -> Type[Job]:
-        return MicrosoftEstimatorJob
-
-    def _qir_output_data_format(self) -> str:
-        """"Fallback output data format in case of QIR job submission."""
-        return "microsoft.resource-estimates.v1"
-
-    def make_params(self, num_items: Optional[int] = None):
-        return MicrosoftEstimatorParams(num_items=num_items)

azure/quantum/target/quantinuum.py

@@ -100,126 +100,3 @@ class Quantinuum(Target):
             input_params=input_params,
             **kwargs
         )
-
-    def estimate_cost(
-        self,
-        circuit: Union[str, Any] = None,
-        num_shots: int = None,
-        N_1q: int = None,
-        N_2q: int = None,
-        N_m: int = None,
-        shots: int = None,
-    ) -> CostEstimate:
-        """Estimate the cost in HQC for a given circuit.
-        Optionally, you can provide the number of gate and measurement operations
-        manually.
-        The actual price charged by the provider may differ from this estimation.
-
-        For the most current pricing details, see
-        https://aka.ms/AQ/Quantinuum/Documentation
-        Or find your workspace and view pricing options in the "Provider" tab
-        of your workspace: https://aka.ms/aq/myworkspaces
-
-        :param circuit: Quantum circuit in OpenQASM 2.0 format
-        :type circuit: str
-        :param num_shots: Number of shots for which to estimate costs
-        :type num_shots: int
-        :param N_1q: Number of one-qubit gates, if not specified,
-            this is estimated from the circuit
-        :type N_1q: int
-        :param N_2q: Number of two-qubit gates, if not specified,
-            this is estimated from the circuit
-        :type N_2q: int
-        :param N_m: Number of measurement operations, if not specified,
-            this is estimated from the circuit
-        :type N_m: int
-        :param shots: Number of shots for which to estimate costs
-        :type shots: int
-        :raises ImportError: If N_1q, N_2q and N_m are not specified,
-            this will require a qiskit installation.
-        """
-
-        if num_shots is None and shots is None:
-             raise ValueError("The 'shots' parameter has to be specified")
-
-        if num_shots is not None:
-            warn(
-                "The 'num_shots' parameter will be deprecated. Please, use 'shots' parameter instead.",
-                category=DeprecationWarning,
-            )
-            shots = num_shots
-
-        # If we use passthrough, else assume QIR
-        if (isinstance(circuit, str)):
-            if circuit is not None and (N_1q is None or N_2q is None or N_m is None):
-                try:
-                    from qiskit.qasm2 import loads
-                    from qiskit.converters.circuit_to_dag import circuit_to_dag
-
-                except ImportError:
-                    raise ImportError(
-                        "Missing dependency qiskit. Please run `pip install azure-quantum[qiskit]` " \
-    "to estimate the circuit cost. Alternatively, specify the number of one-qubit and two-qubit " \
-    "gates in the method input arguments.")
-
-                else:
-                    from qiskit.dagcircuit.dagnode import DAGOpNode
-                    circuit_obj = loads(string=circuit)
-                    dag = circuit_to_dag(circuit=circuit_obj)
-                    N_1q, N_2q, N_m = 0, 0, 0
-                    for node in dag._multi_graph.nodes():
-                        if isinstance(node, DAGOpNode):
-                            if node.op.name in ["measure", "reset"]:
-                                N_m += 1
-                            elif node.op.num_qubits == 1:
-                                N_1q += 1
-                            else:
-                                N_2q += 1
-        else:
-            N_1q, N_2q, N_m = Target._calculate_qir_module_gate_stats(circuit)
-            
-
-        import re
-        is_emulator_regex = re.compile("^.*(-sim|-[0-9]*e)$")
-        is_syntax_checker_regex = re.compile("^.*(-apival|-[0-9]*sc)$")
-
-        if is_emulator_regex.match(self.name):
-            currency_code = "EHQC"
-        else:
-            currency_code = "HQC"
-
-        if is_syntax_checker_regex.match(self.name):
-            HQC = 0.0
-        else:
-            HQC = 5 + shots * (N_1q + 10 * N_2q + 5 * N_m) / 5000
-
-        return CostEstimate(
-            events=[
-                UsageEvent(
-                    dimension_id="gates1q",
-                    dimension_name="1Q Gates",
-                    measure_unit="1q gates",
-                    amount_billed=0.0,
-                    amount_consumed=N_1q,
-                    unit_price=0.0
-                ),
-                UsageEvent(
-                    dimension_id="gates2q",
-                    dimension_name="2Q Gates",
-                    measure_unit="2q gates",
-                    amount_billed=0.0,
-                    amount_consumed=N_2q,
-                    unit_price=0.0
-                ),
-                UsageEvent(
-                    dimension_id="measops",
-                    dimension_name="Measurement operations",
-                    measure_unit="measurement operations",
-                    amount_billed=0.0,
-                    amount_consumed=N_m,
-                    unit_price=0.0
-                )
-            ],
-            currency_code=currency_code,
-            estimated_total=HQC
-        )

azure/quantum/target/rigetti/target.py

@@ -30,6 +30,8 @@ class RigettiTarget(str, Enum):
     QVM = "rigetti.sim.qvm"
     """A simulator target for Quil. See https://github.com/quil-lang/qvm for more info."""
 
+    ANKAA_3 = "rigetti.qpu.ankaa-3"
+
     ANKAA_9Q_3 = "rigetti.qpu.ankaa-9q-3"
 
     def simulators() -> List[str]:
@@ -41,6 +43,7 @@ class RigettiTarget(str, Enum):
     def qpus() -> List[str]:
         """Returns a list of QPU targets"""
         return [
+            RigettiTarget.ANKAA_3.value,
             RigettiTarget.ANKAA_9Q_3.value,
         ]
 
@@ -49,6 +52,8 @@ class RigettiTarget(str, Enum):
 
         if target_name == RigettiTarget.QVM.value:
             return 20
+        elif target_name == RigettiTarget.ANKAA_3.value:
+            return 84
         elif target_name == RigettiTarget.ANKAA_9Q_3.value:
             return 9
         else: