classiq 0.62.0__py3-none-any.whl → 0.63.0__py3-none-any.whl

classiq/execution/execution_session.py

@@ -2,12 +2,12 @@ import json
 import random
 from functools import cached_property
 from types import TracebackType
-from typing import Any, Callable, Optional, Union, cast
+from typing import Callable, Optional, Union, cast
 
 import numpy as np
 
 from classiq.interface.chemistry.operator import PauliOperator, pauli_integers_to_str
-from classiq.interface.exceptions import ClassiqValueError
+from classiq.interface.exceptions import ClassiqError, ClassiqValueError
 from classiq.interface.execution.primitives import EstimateInput, PrimitivesInput
 from classiq.interface.executor.execution_preferences import ExecutionPreferences
 from classiq.interface.executor.result import (
@@ -15,15 +15,16 @@ from classiq.interface.executor.result import (
     ExecutionDetails,
     ParsedState,
 )
+from classiq.interface.generator.arith import number_utils
 from classiq.interface.generator.functions.qmod_python_interface import QmodPyStruct
 from classiq.interface.generator.quantum_program import QuantumProgram
+from classiq.interface.model.quantum_type import QuantumBit, QuantumNumeric
 
 from classiq._internals import async_utils
 from classiq._internals.api_wrapper import ApiWrapper
 from classiq._internals.client import client
 from classiq.applications.combinatorial_helpers.pauli_helpers.pauli_utils import (
     _pauli_dict_to_pauli_terms,
-    _pauli_terms_to_qmod,
 )
 from classiq.execution.jobs import ExecutionJob
 from classiq.qmod.builtins import PauliTerm
@@ -42,16 +43,6 @@ ParsedExecutionParameters = Optional[
 ]
 
 
-SAVE_RESULT = "\nsave({'result': result})\n"
-
-
-class SupportedPrimitives:
-    SAMPLE = "sample"
-    BATCH_SAMPLE = "batch_sample"
-    ESTIMATE = "estimate"
-    BATCH_ESTIMATE = "batch_estimate"
-
-
 def _deserialize_program(program: Program) -> QuantumProgram:
     return (
         program
@@ -67,10 +58,6 @@ def hamiltonian_to_pauli_terms(hamiltonian: Hamiltonian) -> list[PauliTerm]:
         return _pauli_dict_to_pauli_terms(cast(list[QmodPyStruct], hamiltonian))
 
 
-def to_hamiltonian_str(hamiltonian: Hamiltonian) -> str:
-    return _pauli_terms_to_qmod(hamiltonian_to_pauli_terms(hamiltonian))
-
-
 def _hamiltonian_to_pauli_operator(hamiltonian: Hamiltonian) -> PauliOperator:
     pauli_list = [
         (
@@ -82,14 +69,6 @@ def _hamiltonian_to_pauli_operator(hamiltonian: Hamiltonian) -> PauliOperator:
     return PauliOperator(pauli_list=pauli_list)
 
 
-def serialize(
-    item: Union[float, int, tuple[int, ...], tuple[float, ...]]
-) -> Union[str, list]:
-    if isinstance(item, tuple):
-        return list(item)
-    return str(item)
-
-
 def parse_params(params: ExecutionParams) -> ParsedExecutionParams:
     result = {}
     for key, values in params.items():
@@ -104,48 +83,6 @@ def parse_params(params: ExecutionParams) -> ParsedExecutionParams:
     return result
 
 
-def format_parameters(execution_params: ExecutionParameters) -> str:
-    parsed_parameters: ParsedExecutionParameters = None
-    if execution_params is None:
-        return ""
-    if isinstance(execution_params, dict):
-        parsed_parameters = parse_params(execution_params)
-
-    elif isinstance(execution_params, list):
-        parsed_parameters = [
-            parse_params(ep) if isinstance(ep, dict) else ep for ep in execution_params
-        ]
-
-    execution_params = cast(ExecutionParams, parsed_parameters)
-    return json.dumps(execution_params, default=serialize, indent=2)
-
-
-def create_estimate_execution_code(operation: str, **kwargs: Any) -> str:
-    hamiltonian = kwargs.get("hamiltonian", "")
-    parameters = kwargs.get("parameters", "")
-    return f"\nresult = {operation}([{hamiltonian}], {parameters})" + SAVE_RESULT
-
-
-def create_sample_execution_code(operation: str, **kwargs: Any) -> str:
-    parameters = kwargs.get("parameters", "")
-    return f"\nresult = {operation}({parameters})" + SAVE_RESULT
-
-
-operation_handlers: dict[str, Callable[[str], str]] = {
-    "estimate": create_estimate_execution_code,
-    "batch_estimate": create_estimate_execution_code,
-    "sample": create_sample_execution_code,
-    "batch_sample": create_sample_execution_code,
-}
-
-
-def generate_code_snippet(operation: str, **kwargs: Any) -> str:
-    handler = operation_handlers.get(operation)
-    if handler:
-        return handler(operation, **kwargs)
-    raise ClassiqValueError(f"Unsupported operation type: {operation}")
-
-
 class ExecutionSession:
     """
     A session for executing a quantum program.
@@ -164,9 +101,8 @@ class ExecutionSession:
     ):
         self.program: QuantumProgram = _deserialize_program(quantum_program)
         self.update_execution_preferences(execution_preferences)
-        # When the primitives are called, we always override the
-        # classical_execution_code, and we don't want the conversion route to fail
-        # because cmain is expected in some cases
+        # We never use classical_execution_code in ExecutionSession, and we don't want
+        # the conversion route to fail because cmain is expected in some cases
         self.program.model.classical_execution_code = "dummy"
 
         self._random_seed = self.program.model.execution_preferences.random_seed
@@ -197,13 +133,10 @@ class ExecutionSession:
             ApiWrapper.call_convert_quantum_program(self.program, self._async_client)
         )
 
-    def _execute(
-        self, classical_execution_code: str, primitives_input: PrimitivesInput
-    ) -> ExecutionJob:
-        execution_input = self._execution_input.copy()
-        execution_input["execution_preferences"]["random_seed"] = self._random_seed
+    def _execute(self, primitives_input: PrimitivesInput) -> ExecutionJob:
+        primitives_input.random_seed = self._random_seed
         self._random_seed = self._rng.randint(0, 2**32 - 1)
-        execution_input["classical_execution_code"] = classical_execution_code
+        execution_input = self._execution_input.copy()
         # The use of `model_dump_json` is necessary for complex numbers serialization
         execution_input["primitives_input"] = json.loads(
             primitives_input.model_dump_json()
@@ -256,13 +189,10 @@ class ExecutionSession:
         Returns:
             The execution job.
         """
-        classical_execution_code = generate_code_snippet(
-            SupportedPrimitives.SAMPLE, parameters=format_parameters(parameters)
-        )
         execution_primitives_input = PrimitivesInput(
             sample=[parse_params(parameters)] if parameters is not None else [{}]
         )
-        return self._execute(classical_execution_code, execution_primitives_input)
+        return self._execute(execution_primitives_input)
 
     def batch_sample(self, parameters: list[ExecutionParams]) -> list[ExecutionDetails]:
         """
@@ -290,13 +220,10 @@ class ExecutionSession:
         Returns:
             The execution job.
         """
-        classical_execution_code = generate_code_snippet(
-            SupportedPrimitives.BATCH_SAMPLE, parameters=format_parameters(parameters)
-        )
         execution_primitives_input = PrimitivesInput(
             sample=[parse_params(params) for params in parameters]
         )
-        return self._execute(classical_execution_code, execution_primitives_input)
+        return self._execute(execution_primitives_input)
 
     def estimate(
         self, hamiltonian: Hamiltonian, parameters: Optional[ExecutionParams] = None
@@ -330,11 +257,6 @@ class ExecutionSession:
         Returns:
             The execution job.
         """
-        classical_execution_code = generate_code_snippet(
-            SupportedPrimitives.ESTIMATE,
-            parameters=format_parameters(parameters),
-            hamiltonian=to_hamiltonian_str(hamiltonian),
-        )
         execution_primitives_input = PrimitivesInput(
             estimate=EstimateInput(
                 hamiltonian=_hamiltonian_to_pauli_operator(hamiltonian),
@@ -343,7 +265,7 @@ class ExecutionSession:
                 ),
             )
         )
-        return self._execute(classical_execution_code, execution_primitives_input)
+        return self._execute(execution_primitives_input)
 
     def batch_estimate(
         self, hamiltonian: Hamiltonian, parameters: list[ExecutionParams]
@@ -377,18 +299,13 @@ class ExecutionSession:
         Returns:
             The execution job.
         """
-        classical_execution_code = generate_code_snippet(
-            SupportedPrimitives.BATCH_ESTIMATE,
-            parameters=format_parameters(parameters),
-            hamiltonian=to_hamiltonian_str(hamiltonian),
-        )
         execution_primitives_input = PrimitivesInput(
             estimate=EstimateInput(
                 hamiltonian=_hamiltonian_to_pauli_operator(hamiltonian),
                 parameters=[parse_params(params) for params in parameters],
             )
         )
-        return self._execute(classical_execution_code, execution_primitives_input)
+        return self._execute(execution_primitives_input)
 
     def estimate_cost(
         self,
@@ -427,3 +344,56 @@ class ExecutionSession:
         if costs.size == 0:
             return np.nan
         return float(np.average(costs))
+
+    def set_measured_state_filter(
+        self,
+        output_name: str,
+        condition: Callable,
+    ) -> None:
+        """
+        EXPERIMENTAL
+
+        When simulating on a statevector simulator, emulate the behavior of postprocessing
+        by discarding amplitudes for which their states are "undesirable".
+
+        Args:
+            output_name: The name of the register to filter
+            condition: Filter out values of the statevector for which this callable is False
+        """
+        if "_execution_input" in self.__dict__:
+            raise ClassiqError(
+                "set_measured_state_filter must be called before use of the first primitive (sample, estimate...)"
+            )
+
+        if output_name not in self.program.model.circuit_outputs:
+            raise ClassiqValueError(f"{output_name} is not an output of the model")
+        output_type = self.program.model.circuit_output_types[output_name].quantum_types
+
+        legal_bitstrings = []
+
+        if isinstance(output_type, QuantumBit):
+            if condition(0):
+                legal_bitstrings.append("0")
+            if condition(1):
+                legal_bitstrings.append("1")
+        elif isinstance(output_type, QuantumNumeric):
+            size = output_type.size_in_bits
+            for i in range(2**size):
+                number_string = f"{i:0{size}b}"
+                val = number_utils.binary_to_float_or_int(
+                    number_string,
+                    output_type.fraction_digits_value,
+                    output_type.sign_value,
+                )
+                if condition(val):
+                    legal_bitstrings.append(number_string)
+            if len(legal_bitstrings) > 1:
+                raise NotImplementedError(
+                    "Filtering is only supported on a single value per model output"
+                )
+        else:
+            raise NotImplementedError(
+                "Filtering is only supported on QuantumBit and QuantumNumeric"
+            )
+
+        self.program.model.register_filter_bitstrings[output_name] = legal_bitstrings

classiq/execution/jobs.py

@@ -19,18 +19,15 @@ from classiq.interface.executor.result import (
     MultipleExecutionDetails,
 )
 from classiq.interface.jobs import JobStatus, JSONObject
-from classiq.interface.server.routes import EXECUTION_JOBS_NON_VERSIONED_FULL_PATH
+from classiq.interface.server.routes import EXECUTION_JOBS_FULL_PATH
 
-from classiq._internals.api_wrapper import CLASSIQ_ACCEPT_HEADER, ApiWrapper
+from classiq._internals.api_wrapper import ApiWrapper
 from classiq._internals.async_utils import syncify_function
 from classiq._internals.client import client
 from classiq._internals.jobs import JobID, JobPoller
 
 _JobDetails = Union[ExecutionJobDetails, ExecutionJobDetailsV1]
 
-_JOB_DETAILS_VERSION = "v1"
-_JOB_RESULT_VERSION = "v1"
-
 
 class ClassiqExecutionResultError(ClassiqError):
     def __init__(self, primitive: str) -> None:
@@ -142,7 +139,6 @@ class ExecutionJob:
             self._result = (
                 await ApiWrapper.call_get_execution_job_result(
                     job_id=self._job_id,
-                    version=_JOB_RESULT_VERSION,
                     http_client=_http_client,
                 )
             ).results
@@ -273,9 +269,7 @@ class ExecutionJob:
             return None
 
         poller = JobPoller(
-            base_url=EXECUTION_JOBS_NON_VERSIONED_FULL_PATH,
-            use_versioned_url=False,
-            additional_headers={CLASSIQ_ACCEPT_HEADER: _JOB_DETAILS_VERSION},
+            base_url=EXECUTION_JOBS_FULL_PATH,
         )
         await poller.poll(
             job_id=self._job_id,

classiq/interface/_version.py

@@ -3,5 +3,5 @@ from packaging.version import Version
 # This file was generated automatically
 # Please don't track in version control (DONTTRACK)
 
-SEMVER_VERSION = '0.62.0'
+SEMVER_VERSION = '0.63.0'
 VERSION = str(Version(SEMVER_VERSION))

classiq/interface/backend/backend_preferences.py

@@ -210,12 +210,15 @@ class AwsBackendPreferences(BackendPreferences):
     backend_service_provider: ProviderTypeVendor.AMAZON_BRAKET = pydantic.Field(
         default=ProviderVendor.AMAZON_BRAKET
     )
-    aws_role_arn: Optional[pydantic_backend.PydanticAwsRoleArn] = pydantic.Field(
-        description="ARN of the role to be assumed for execution on your Braket account."
+    aws_role_arn: Optional[str] = pydantic.Field(
+        default=None,
+        description="ARN of the role to be assumed for execution on your Braket account.",
+    )
+    s3_bucket_name: Optional[str] = pydantic.Field(
+        default=None, description="S3 Bucket Name"
     )
-    s3_bucket_name: Optional[str] = pydantic.Field(description="S3 Bucket Name")
-    s3_folder: Optional[pydantic_backend.PydanticS3BucketKey] = pydantic.Field(
-        description="S3 Folder Path Within The S3 Bucket"
+    s3_folder: Optional[str] = pydantic.Field(
+        default=None, description="S3 Folder Path Within The S3 Bucket"
     )
     run_through_classiq: bool = pydantic.Field(
         default=False,

classiq/interface/backend/pydantic_backend.py

@@ -8,7 +8,7 @@ _IONQ_API_KEY_LENGTH: int = 32
 _ALICE_BOB_API_KEY_LENGTH: int = 72
 INVALID_API_KEY: str = _IONQ_API_KEY_LENGTH * "a"
 INVALID_EMAIL_OQC: str = "aa@aa.aa"
-INVALID_PASSWORD_OQC: str = "Aa1!Aa1!"
+INVALID_PASSWORD_OQC: str = "Aa1!Aa1!"  # noqa: S105
 
 EXECUTION_PARAMETER_PATTERN = "[_a-z][_a-z0-9]*"
 

classiq/interface/chemistry/operator.py

@@ -260,210 +260,6 @@ class PauliOperator(HashablePydanticBaseModel, VersionedModel):
     model_config = ConfigDict(frozen=True)
 
 
-class PauliOperatorV1(HashablePydanticBaseModel):
-    """
-    Specification of a Pauli sum operator.
-    """
-
-    pauli_list: PydanticPauliList = pydantic.Field(
-        description="A list of tuples each containing a pauli string comprised of I,X,Y,Z characters and a complex coefficient; for example [('IZ', 0.1), ('XY', 0.2)].",
-    )
-    is_hermitian: bool = pydantic.Field(default=False)
-    has_complex_coefficients: bool = pydantic.Field(default=True)
-
-    def show(self) -> str:
-        if self.is_hermitian:
-            # If the operator is hermitian then the coefficients must be numeric
-            return "\n".join(
-                f"{summand[1].real:+.3f} * {summand[0]}" for summand in self.pauli_list  # type: ignore[union-attr]
-            )
-        return "\n".join(
-            f"+({summand[1]:+.3f}) * {summand[0]}" for summand in self.pauli_list
-        )
-
-    @pydantic.field_validator("pauli_list", mode="before")
-    @classmethod
-    def _validate_pauli_monomials(
-        cls, pauli_list: PydanticPauliList
-    ) -> PydanticPauliList:
-        validated_pauli_list = []
-        for monomial in pauli_list:
-            # Validate the length
-            _PauliMonomialLengthValidator(monomial=monomial)  # type: ignore[call-arg]
-            coeff = cls._validate_monomial_coefficient(monomial[1])
-            parsed_monomial = _PauliMonomialParser(string=monomial[0], coeff=coeff)
-            validated_pauli_list.append((parsed_monomial.string, parsed_monomial.coeff))
-        return validated_pauli_list
-
-    @staticmethod
-    def _validate_monomial_coefficient(
-        coeff: Union[sympy.Expr, ParameterComplexType]
-    ) -> ParameterComplexType:
-        if isinstance(coeff, str):
-            validate_expression_str(coeff)
-        elif isinstance(coeff, sympy.Expr):
-            coeff = str(coeff)
-        return coeff
-
-    @pydantic.field_validator("pauli_list", mode="after")
-    @classmethod
-    def _validate_pauli_list(cls, pauli_list: PydanticPauliList) -> PydanticPauliList:
-        if not all_equal(len(summand[0]) for summand in pauli_list):
-            raise ClassiqValueError("Pauli strings have incompatible lengths.")
-        return pauli_list
-
-    @pydantic.model_validator(mode="before")
-    @classmethod
-    def _validate_hermitianity(cls, v: dict[str, Any]) -> dict[str, Any]:
-        pauli_list = cast(PydanticPauliList, v.get("pauli_list"))
-        if all(isinstance(summand[1], complex) for summand in pauli_list):
-            v["is_hermitian"] = all(
-                np.isclose(complex(summand[1]).real, summand[1])
-                for summand in pauli_list
-            )
-        if v["is_hermitian"]:
-            v["has_complex_coefficients"] = False
-            v["pauli_list"] = [
-                (summand[0], complex(summand[1]).real) for summand in pauli_list
-            ]
-        else:
-            v["has_complex_coefficients"] = not all(
-                np.isclose(complex(summand[1]).real, summand[1])
-                for summand in pauli_list
-                if isinstance(summand[1], complex)
-            )
-        return v
-
-    def __mul__(self, coefficient: complex) -> "PauliOperatorV1":
-        multiplied_ising = [
-            (monomial[0], self._multiply_monomial_coefficient(monomial[1], coefficient))
-            for monomial in self.pauli_list
-        ]
-        return self.__class__(pauli_list=multiplied_ising)
-
-    @staticmethod
-    def _multiply_monomial_coefficient(
-        monomial_coefficient: ParameterComplexType, coefficient: complex
-    ) -> ParameterComplexType:
-        if isinstance(monomial_coefficient, ParameterType):
-            return str(sympy.sympify(monomial_coefficient) * coefficient)
-        return monomial_coefficient * coefficient
-
-    @property
-    def is_commutative(self) -> bool:
-        return all(
-            self._is_sub_pauli_commutative(
-                [summand[0][qubit_num] for summand in self.pauli_list]
-            )
-            for qubit_num in range(self.num_qubits)
-        )
-
-    @staticmethod
-    def _is_sub_pauli_commutative(qubit_pauli_string: Union[list[str], str]) -> bool:
-        unique_paulis = set(qubit_pauli_string) - {"I"}
-        return len(unique_paulis) <= 1
-
-    @property
-    def num_qubits(self) -> int:
-        return len(self.pauli_list[0][0])
-
-    def to_matrix(self) -> np.ndarray:
-        if not all(isinstance(summand[1], complex) for summand in self.pauli_list):
-            raise ClassiqValueError(
-                "Supporting only Hamiltonian with numeric coefficients."
-            )
-        return sum(
-            cast(complex, summand[1]) * to_pauli_matrix(summand[0])
-            for summand in self.pauli_list
-        )  # type: ignore[return-value]
-
-    @staticmethod
-    def _extend_pauli_string(
-        pauli_string: PydanticPauliMonomialStr, num_extra_qubits: int
-    ) -> PydanticPauliMonomialStr:
-        return "I" * num_extra_qubits + pauli_string
-
-    def extend(self, num_extra_qubits: int) -> "PauliOperatorV1":
-        new_pauli_list = [
-            (self._extend_pauli_string(pauli_string, num_extra_qubits), coeff)
-            for (pauli_string, coeff) in self.pauli_list
-        ]
-        return self.model_copy(update={"pauli_list": new_pauli_list}, deep=True)
-
-    @staticmethod
-    def _reorder_pauli_string(
-        pauli_string: PydanticPauliMonomialStr,
-        order: Collection[int],
-        new_num_qubits: int,
-    ) -> PydanticPauliMonomialStr:
-        reversed_pauli_string = pauli_string[::-1]
-        reversed_new_pauli_string = ["I"] * new_num_qubits
-
-        for logical_pos, actual_pos in enumerate(order):
-            reversed_new_pauli_string[actual_pos] = reversed_pauli_string[logical_pos]
-
-        return "".join(reversed(reversed_new_pauli_string))
-
-    @staticmethod
-    def _validate_reorder(
-        order: Collection[int],
-        num_qubits: int,
-        num_extra_qubits: int,
-    ) -> None:
-        if num_extra_qubits < 0:
-            raise ClassiqValueError("Number of extra qubits cannot be negative")
-
-        if len(order) != num_qubits:
-            raise ClassiqValueError("The qubits order doesn't match the Pauli operator")
-
-        if len(order) != len(set(order)):
-            raise ClassiqValueError("The qubits order is not one-to-one")
-
-        if not all(pos < num_qubits + num_extra_qubits for pos in order):
-            raise ClassiqValueError(
-                "The qubits order contains qubits which do no exist"
-            )
-
-    @classmethod
-    def reorder(
-        cls,
-        operator: "PauliOperatorV1",
-        order: Collection[int],
-        num_extra_qubits: int = 0,
-    ) -> "PauliOperatorV1":
-        cls._validate_reorder(order, operator.num_qubits, num_extra_qubits)
-
-        new_num_qubits = operator.num_qubits + num_extra_qubits
-        new_pauli_list = [
-            (cls._reorder_pauli_string(pauli_string, order, new_num_qubits), coeff)
-            for pauli_string, coeff in operator.pauli_list
-        ]
-        return cls(pauli_list=new_pauli_list)
-
-    @classmethod
-    def from_unzipped_lists(
-        cls,
-        operators: list[list["Pauli"]],
-        coefficients: Optional[list[complex]] = None,
-    ) -> "PauliOperatorV1":
-        if coefficients is None:
-            coefficients = [1] * len(operators)
-
-        if len(operators) != len(coefficients):
-            raise ClassiqValueError(
-                f"The number of coefficients ({len(coefficients)}) must be equal to the number of pauli operators ({len(operators)})"
-            )
-
-        return cls(
-            pauli_list=[
-                (pauli_integers_to_str(op), coeff)
-                for op, coeff in zip(operators, coefficients)
-            ]
-        )
-
-    model_config = ConfigDict(frozen=True)
-
-
 # This class validates the length of a monomial.
 @pydantic.dataclasses.dataclass
 class _PauliMonomialLengthValidator:

classiq/interface/execution/primitives.py

@@ -15,3 +15,4 @@ class EstimateInput(BaseModel, json_encoders=CUSTOM_ENCODERS):
 class PrimitivesInput(BaseModel, json_encoders=CUSTOM_ENCODERS):
     sample: Optional[list[Arguments]] = Field(default=None)
     estimate: Optional[EstimateInput] = Field(default=None)
+    random_seed: Optional[int] = Field(default=None)

classiq/interface/generator/compiler_keywords.py

@@ -2,3 +2,7 @@ EXPANDED_KEYWORD = "expanded__"
 CAPTURE_SUFFIX = "_captured__"
 LAMBDA_KEYWORD = "lambda__"
 INPLACE_ARITH_AUX_VAR_PREFIX = "result__temp__"
+
+
+def generate_original_function_name(name: str) -> str:
+    return name.split(f"_{EXPANDED_KEYWORD}")[0]

classiq/interface/generator/functions/type_name.py

@@ -69,6 +69,12 @@ class TypeName(ClassicalType, QuantumType):
     def set_fields(self, fields: Mapping[str, "ConcreteQuantumType"]) -> None:
         self._assigned_fields = fields
 
+    @property
+    def is_instantiated(self) -> bool:
+        return self.has_fields and all(
+            field_type.is_instantiated for field_type in self.fields.values()
+        )
+
 
 class Enum(TypeName):
     pass

classiq/interface/generator/generated_circuit_data.py

@@ -197,14 +197,16 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
 
         updated_children: list[FunctionDebugInfoInterface] = []
         for child in self.children:
-            updated_child = child.model_copy(
-                update=dict(
-                    absolute_qubits=_get_absolute_from_relative(
-                        self.absolute_qubits, child.relative_qubits
-                    )
+            updated_child = child.white_new_absolute_qubits(self.absolute_qubits)
+            if updated_child.override_debug_info is None:
+                updated_child = updated_child.propagate_absolute_qubits()
+            else:
+                updated_child.override_debug_info = (
+                    updated_child.override_debug_info.white_new_absolute_qubits(
+                        absolute_qubits=self.absolute_qubits
+                    ).propagate_absolute_qubits()
                 )
-            )
-            updated_children.append(updated_child.propagate_absolute_qubits())
+            updated_children.append(updated_child)
 
         return self.model_copy(
             update=dict(
@@ -213,6 +215,17 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
             )
         )
 
+    def white_new_absolute_qubits(
+        self, absolute_qubits: tuple[int, ...]
+    ) -> "FunctionDebugInfoInterface":
+        return self.model_copy(
+            update=dict(
+                absolute_qubits=_get_absolute_from_relative(
+                    absolute_qubits, self.relative_qubits
+                )
+            )
+        )
+
     def inverse(self) -> "FunctionDebugInfoInterface":
         inverted_children = [child.inverse() for child in self.children[::-1]]
         return self.model_copy(
@@ -226,6 +239,8 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
 def _get_absolute_from_relative(
     absolute_qubits: tuple[int, ...], relative_qubits: tuple[int, ...]
 ) -> tuple[int, ...]:
+    if len(relative_qubits) == 0:
+        return tuple()
     if max(relative_qubits) >= len(absolute_qubits):
         _logger.warning(
             "Invalid qubit computation (relative qubits: %s, absolute qubits: %s)",

classiq/interface/generator/model/model.py

@@ -68,3 +68,6 @@ class ExecutionModel(ClassiqBaseModel):
         description="Mapping between a measured register name and its qmod type",
         default=dict(),
     )
+    register_filter_bitstrings: dict[str, list[str]] = pydantic.Field(
+        default_factory=dict,
+    )