classiq 0.66.1__py3-none-any.whl → 0.68.0__py3-none-any.whl

classiq/_internals/api_wrapper.py

@@ -3,6 +3,7 @@ from typing import Any, Optional, Protocol, TypeVar
 
 import httpx
 import pydantic
+from pydantic.main import IncEx
 
 import classiq.interface.executor.execution_result
 import classiq.interface.pyomo_extension
@@ -72,11 +73,12 @@ class ApiWrapper:
         model: pydantic.BaseModel,
         use_versioned_url: bool = True,
         http_client: Optional[httpx.AsyncClient] = None,
+        exclude: Optional[IncEx] = None,
     ) -> dict:
         # TODO: we can't use model.dict() - it doesn't serialize complex class.
         # This was added because JSON serializer doesn't serialize complex type, and pydantic does.
         # We should add support for smarter json serialization.
-        body = json.loads(model.model_dump_json())
+        body = json.loads(model.model_dump_json(exclude=exclude))
         return await cls._call_task(
             http_method,
             url,
@@ -135,6 +137,7 @@ class ApiWrapper:
             url=routes.EXECUTION_SESSIONS_PREFIX,
             model=circuit,
             http_client=http_client,
+            exclude={"debug_info"},
         )
         return raw_result["id"]
 
@@ -164,6 +167,7 @@ class ApiWrapper:
             url=routes.CONVERSION_GENERATED_CIRCUIT_TO_EXECUTION_INPUT_FULL,
             model=circuit,
             http_client=http_client,
+            exclude={"debug_info"},
         )
 
     @classmethod

classiq/_internals/async_utils.py

@@ -58,7 +58,7 @@ def enable_jupyter_notebook() -> None:
 
 
 def _make_iterable_interval(
-    interval_sec: Union[SupportsFloat, Iterable[SupportsFloat]]
+    interval_sec: Union[SupportsFloat, Iterable[SupportsFloat]],
 ) -> Iterable[float]:
     if isinstance(interval_sec, Iterable):
         return map(float, interval_sec)

classiq/_internals/authentication/password_manager.py

@@ -117,7 +117,7 @@ class DummyPasswordManager(PasswordManager):
 
 class FilePasswordManager(PasswordManager):
     _CLASSIQ_CREDENTIALS_FILE_PATH: str = "{}/.classiq-credentials".format(
-        os.getenv("HOME")
+        os.getenv("CLASSIQ_DIR", os.getenv("HOME"))
     )
 
     def __init__(self) -> None:

classiq/_internals/client.py

@@ -89,7 +89,7 @@ P = ParamSpec("P")
 
 
 def try_again_on_failure(
-    func: Callable[P, Awaitable[Ret]]
+    func: Callable[P, Awaitable[Ret]],
 ) -> Callable[P, Awaitable[Ret]]:
     def check_approved_api_error(error_message: str) -> bool:
         for approved_api_error in APPROVED_API_ERROR_MESSAGES_FOR_RESTART:

classiq/applications/finance/finance_model_constructor.py

@@ -1,3 +1,4 @@
+import warnings
 from math import floor, log
 from typing import Union
 
@@ -32,6 +33,14 @@ def construct_finance_model(
     finance_function_input: FinanceFunctionInput,
     phase_port_size: int,
 ) -> SerializedModel:
+    warnings.warn(
+        "Function 'construct_finance_model' has been deprecated and will no longer"
+        "be supported starting on 03/02/2025 the earliest\nHint: It is now possible to "
+        "implement Option Pricing in pure Qmod. For example, see the Option Pricing notebook on the "
+        "Classiq library at https://github.com/Classiq/classiq-library/blob/main/applications/finance/option_pricing/option_pricing.ipynb",
+        category=DeprecationWarning,
+        stacklevel=2,
+    )
     if isinstance(finance_model_input, LogNormalModelInput):
         finance_model = f"struct_literal(LogNormalModel, num_qubits={finance_model_input.num_qubits}, mu={finance_model_input.mu}, sigma={finance_model_input.sigma})"
         finance_function = "log_normal_finance"

classiq/applications/grover/grover_model_constructor.py

@@ -1,3 +1,5 @@
+import warnings
+
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
@@ -90,6 +92,14 @@ def construct_grover_model(
     expression: str,
     num_reps: int = 1,
 ) -> SerializedModel:
+    warnings.warn(
+        "Function 'construct_grover_model' has been deprecated and will no longer"
+        "be supported starting on 03/02/2025 the earliest\nHint: It is now possible to "
+        "implement the Grover algorithm in pure Qmod. For example, see the Grover notebook on the "
+        "Classiq library at https://github.com/Classiq/classiq-library/blob/main/algorithms/grover/3_sat_grover/3_sat_grover.ipynb",
+        category=DeprecationWarning,
+        stacklevel=2,
+    )
     predicate_port_decls = grover_main_port_declarations(
         definitions, PortDeclarationDirection.Inout
     )

classiq/applications/qnn/qlayer.py

@@ -244,9 +244,11 @@ class QLayer(nn.Module):
 
         self.weight = Parameter(value)
 
-    @staticmethod
-    def _make_execute(quantum_program: SerializedQuantumProgram) -> ExecuteFunction:
+    def _make_execute(
+        self, quantum_program: SerializedQuantumProgram
+    ) -> ExecuteFunction:
         session = ExecutionSession(quantum_program)
+        self._session = session
 
         def execute(_ignored: Any, arguments: MultipleArguments) -> ResultsCollection:
             result: ResultsCollection = []
@@ -266,3 +268,7 @@ class QLayer(nn.Module):
             self._post_process,
             self._epsilon,
         )
+
+    def _cleanup(self) -> None:
+        if hasattr(self, "_session"):
+            self._session.close()

classiq/applications/qsvm/qsvm_model_constructor.py

@@ -1,3 +1,4 @@
+import warnings
 from typing import Any
 
 from classiq.interface.applications.qsvm import DataList, LabelsInt
@@ -92,6 +93,14 @@ def construct_qsvm_model(
     feature_map_function_name: str,
     **kwargs: Any,
 ) -> SerializedModel:
+    warnings.warn(
+        "Function 'construct_qsvm_model' has been deprecated and will no longer"
+        "be supported starting on 03/02/2025 the earliest\nHint: It is now possible to "
+        "implement QSVM in pure Qmod. For example, see the QSVM notebook on the "
+        "Classiq library at https://github.com/Classiq/classiq-library/blob/main/algorithms/qml/qsvm/qsvm.ipynb",
+        category=DeprecationWarning,
+        stacklevel=2,
+    )
     qsvm_qmod = Model(
         functions=[
             NativeFunctionDefinition(

classiq/execution/execution_session.py

@@ -1,4 +1,3 @@
-import json
 import random
 from types import TracebackType
 from typing import Callable, Optional, Union, cast
@@ -16,7 +15,10 @@ from classiq.interface.executor.result import (
 )
 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.generator.quantum_program import (
+    OMIT_DEBUG_INFO_FLAG,
+    QuantumProgram,
+)
 from classiq.interface.model.quantum_type import QuantumBit, QuantumNumeric
 
 from classiq._internals import async_utils
@@ -46,7 +48,9 @@ def _deserialize_program(program: Program) -> QuantumProgram:
     return (
         program
         if isinstance(program, QuantumProgram)
-        else QuantumProgram.model_validate(json.loads(program))
+        else QuantumProgram.model_validate_json(
+            program, context={OMIT_DEBUG_INFO_FLAG: True}
+        )
     )
 
 

classiq/executor.py

@@ -10,7 +10,10 @@ from classiq.interface.executor.execution_preferences import ExecutionPreference
 from classiq.interface.executor.quantum_code import QuantumCode
 from classiq.interface.executor.quantum_instruction_set import QuantumInstructionSet
 from classiq.interface.executor.result import ExecutionDetails
-from classiq.interface.generator.quantum_program import QuantumProgram
+from classiq.interface.generator.quantum_program import (
+    OMIT_DEBUG_INFO_FLAG,
+    QuantumProgram,
+)
 
 from classiq._internals import async_utils
 from classiq._internals.api_wrapper import ApiWrapper
@@ -27,7 +30,9 @@ BackendPreferencesAndResult: TypeAlias = tuple[
 def _parse_serialized_qprog(
     quantum_program: SerializedQuantumProgram,
 ) -> QuantumProgram:
-    return QuantumProgram.model_validate_json(quantum_program)
+    return QuantumProgram.model_validate_json(
+        quantum_program, context={OMIT_DEBUG_INFO_FLAG: True}
+    )
 
 
 async def execute_async(quantum_program: SerializedQuantumProgram) -> ExecutionJob:

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.66.1'
+SEMVER_VERSION = '0.68.0'
 VERSION = str(Version(SEMVER_VERSION))

classiq/interface/ast_node.py

@@ -20,7 +20,7 @@ class ASTNode(HashablePydanticBaseModel):
         return self
 
 
-def without_statement_blocks(
+def reset_lists(
     ast_node: ASTNodeType, statement_block_fields: list[str]
 ) -> ASTNodeType:
     return ast_node.model_copy(update={field: [] for field in statement_block_fields})

classiq/interface/chemistry/operator.py

@@ -69,7 +69,7 @@ class PauliOperator(HashablePydanticBaseModel, VersionedModel):
 
     @staticmethod
     def _validate_monomial_coefficient(
-        coeff: Union[sympy.Expr, ParameterComplexType]
+        coeff: Union[sympy.Expr, ParameterComplexType],
     ) -> ParameterComplexType:
         if isinstance(coeff, str):
             validate_expression_str(coeff)

classiq/interface/debug_info/debug_info.py

@@ -32,6 +32,7 @@ class FunctionDebugInfo(BaseModel):
     statement_type: Union[StatementType, None] = None
     is_allocate_or_free: bool = Field(default=False)
     is_inverse: bool = Field(default=False)
+    release_by_inverse: bool = Field(default=False)
     port_to_passed_variable_map: dict[str, str] = Field(default_factory=dict)
     node: Optional[ConcreteQuantumStatement] = None
 
@@ -86,3 +87,29 @@ class DebugInfoCollection(BaseModel):
         if (debug_info := self.get(key)) is None:
             return None
         return self.blackbox_data.get(debug_info.name)
+
+
+def get_back_refs(
+    debug_info: FunctionDebugInfo, collected_debug_info: DebugInfoCollection
+) -> list[ConcreteQuantumStatement]:
+    back_refs: list[ConcreteQuantumStatement] = []
+    while (node := debug_info.node) is not None:
+        back_refs.insert(0, node)
+        if node.back_ref is None:
+            break
+        next_debug_info = collected_debug_info.get(node.back_ref)
+        if next_debug_info is None:
+            break
+        debug_info = next_debug_info
+    return back_refs
+
+
+def new_function_debug_info_by_node(
+    node: ConcreteQuantumStatement,
+) -> FunctionDebugInfo:
+    return FunctionDebugInfo(
+        name="",
+        parameters=dict(),
+        level=OperationLevel.QMOD_STATEMENT,
+        node=node._as_back_ref(),
+    )

classiq/interface/exceptions.py

@@ -6,7 +6,8 @@ _logger = logging.getLogger(__name__)
 
 CLASSIQ_SLACK_COMMUNITY_LINK = (
     "\nIf you need further assistance, please reach out on our Community Slack channel "
-    "at: https://short.classiq.io/join-slack"
+    "at: https://short.classiq.io/join-slack or open a support ticket at: "
+    "https://classiq-community.freshdesk.com/support/tickets/new"
 )
 
 
@@ -177,10 +178,6 @@ class ClassiqExecutorInvalidHamiltonianError(ClassiqCombOptError):
         super().__init__("Invalid hamiltonian")
 
 
-class ClassiqSemanticError(ClassiqError):
-    pass
-
-
 class ClassiqDeprecationWarning(FutureWarning):
     pass
 

classiq/interface/generator/arith/argument_utils.py

@@ -91,7 +91,7 @@ def unsigned_integer_interpretation(
         int_val <<= fraction_digits_diff
 
     # extend sign bit
-    if int(value) < 0:
+    if value < 0:
         bin_val = number_utils.binary_string(int_val)
         bin_val += "1" * (register.size - len(bin_val))
         int_val = number_utils.binary_to_int(bin_val[::-1])

classiq/interface/generator/arith/arithmetic.py

@@ -1,4 +1,5 @@
-from typing import Any, Final, Optional
+import ast
+from typing import Any, Final, Optional, cast
 
 import networkx as nx
 import pydantic
@@ -32,6 +33,8 @@ ARITHMETIC_EXPRESSION_TARGET_NAME: Final[str] = "arithmetic_target"
 ARITHMETIC_EXPRESSION_RESULT_NAME: Final[str] = "expression_result"
 ARITHMETIC_EXPRESSION_GARBAGE_NAME: Final[str] = "expression_garbage"
 
+TARGET_ASSIGNMENT_ERROR = "Expression does not support target assignment"
+
 
 def is_zero(expr: str) -> bool:
     return is_constant(expr) and float(expr) == 0
@@ -60,7 +63,7 @@ class Arithmetic(ArithmeticExpressionABC):
             degree or operation_allows_target(id2op(node))
             for node, degree in graph.out_degree
         ):
-            raise ClassiqValueError("Expression does not support target assignment")
+            raise ClassiqValueError(TARGET_ASSIGNMENT_ERROR)
 
     def _create_ios(self) -> None:
         self._inputs = {
@@ -93,6 +96,9 @@ def get_arithmetic_params(
     machine_precision: int,
     enable_target: bool = False,
 ) -> Arithmetic:
+    expr_str, var_types = _substitute_quantum_subscripts(
+        expr_str, var_types, machine_precision
+    )
     return Arithmetic(
         expression=expr_str,
         definitions={
@@ -119,3 +125,94 @@ def compute_arithmetic_result_type(
     return register_info_to_quantum_type(
         arith_param.outputs[ARITHMETIC_EXPRESSION_RESULT_NAME]
     )
+
+
+def aggregate_numeric_types(
+    numeric_types: list[QuantumNumeric],
+) -> RegisterArithmeticInfo:
+    if all(
+        numeric_type.size_in_bits == 1
+        and numeric_type.sign_value
+        and numeric_type.fraction_digits_value == 1
+        for numeric_type in numeric_types
+    ):
+        return RegisterArithmeticInfo(size=1, is_signed=True, fraction_places=1)
+    int_size = max(
+        numeric_type.size_in_bits
+        - int(numeric_type.sign_value)
+        - numeric_type.fraction_digits_value
+        for numeric_type in numeric_types
+    )
+    is_signed = any(numeric_type.sign_value for numeric_type in numeric_types)
+    frac_size = max(
+        numeric_type.fraction_digits_value for numeric_type in numeric_types
+    )
+    total_size = int_size + int(is_signed) + frac_size
+    return RegisterArithmeticInfo(
+        size=total_size, is_signed=is_signed, fraction_places=frac_size
+    )
+
+
+class _QuantumSubscriptRemover(ast.NodeTransformer):
+    def __init__(self, machine_precision: int) -> None:
+        self._machine_precision = machine_precision
+        self.substitutions_types: dict[str, QuantumNumeric] = {}
+
+    def visit_Call(self, node: ast.Call) -> ast.expr:
+        if not isinstance(node.func, ast.Name) or node.func.id != "Piecewise":
+            return node
+        items = [
+            cast(float, cast(ast.Num, cast(ast.Tuple, arg).elts[0]).value)
+            for arg in node.args
+        ]
+        numeric_types = [
+            compute_arithmetic_result_type(str(num), {}, self._machine_precision)
+            for num in items
+        ]
+        unified_numeric_type = register_info_to_quantum_type(
+            aggregate_numeric_types(numeric_types)
+        )
+        substitution_var_name = f"__lut__{len(self.substitutions_types)}__"
+        self.substitutions_types[substitution_var_name] = unified_numeric_type
+        return ast.Name(id=substitution_var_name)
+
+
+class _NameCollector(ast.NodeVisitor):
+    def __init__(self) -> None:
+        self.names: set[str] = set()
+
+    def visit_Name(self, node: ast.Name) -> None:
+        self.names.add(node.id)
+
+
+def _substitute_quantum_subscripts(
+    expr_str: str, var_types: dict[str, QuantumType], machine_precision: int
+) -> tuple[str, dict[str, QuantumType]]:
+    """
+    Remove quantum lookup expressions ([1, 2, 3, 4][n]) from an arithmetic expression
+    for the purpose of calculating its numeric attributes.
+    Each quantum lookup expression is replaced by a numeric value with equivalent
+    numeric properties.
+
+    Args:
+        expr_str: arithmetic expression
+        var_types: quantum variable type mapping
+        machine_precision: global machine precision
+
+    Returns:
+        1. the reduced expression
+        2. updated type mapping
+    """
+    expr_ast = ast.parse(expr_str)
+    subscript_remover = _QuantumSubscriptRemover(machine_precision)
+    expr_ast = subscript_remover.visit(expr_ast)
+    var_types_substituted = var_types | subscript_remover.substitutions_types
+    expr_str_substituted = ast.unparse(expr_ast)
+    names_collector = _NameCollector()
+    names_collector.visit(ast.parse(expr_str_substituted))
+    var_types_substituted = {
+        var_name: var_type
+        for var_name, var_type in var_types_substituted.items()
+        if var_name in names_collector.names
+    }
+    return expr_str_substituted, var_types_substituted

classiq/interface/generator/arith/arithmetic_expression_parser.py

@@ -91,7 +91,7 @@ class ExpressionVisitor(ExpressionValidator):
 class InDegreeLimiter:
     @staticmethod
     def _sort_in_edges(
-        in_edges: Collection[tuple[Node, str]]
+        in_edges: Collection[tuple[Node, str]],
     ) -> list[tuple[Node, str]]:
         return sorted(
             in_edges,

classiq/interface/generator/arith/binary_ops.py

@@ -398,6 +398,7 @@ class Subtractor(InplacableBinaryOpParams[RegisterOrConst, RegisterOrConst]):
                 right_arg=-self.effective_right_arg,
                 output_size=self.output_size,
                 inplace_arg=self.inplace_arg,
+                machine_precision=self.machine_precision,
             )
             return adder_params.garbage_output_size()
 
@@ -406,6 +407,7 @@ class Subtractor(InplacableBinaryOpParams[RegisterOrConst, RegisterOrConst]):
             output_size=self.negation_output_size,
             inplace=self.should_inplace_negation,
             bypass_bounds_validation=True,
+            machine_precision=self.machine_precision,
         )
         negation_result = negation_params.result_register
         if self.output_size is None and max(self.effective_right_arg.bounds) > 0:
@@ -425,6 +427,7 @@ class Subtractor(InplacableBinaryOpParams[RegisterOrConst, RegisterOrConst]):
             right_arg=negation_result,
             output_size=self.output_size,
             inplace_arg=self.arg_to_inplace_adder,
+            machine_precision=self.machine_precision,
         )
         negation_garbage_size = negation_params.garbage_output_size() * int(
             not self.should_uncompute_negation

classiq/interface/generator/function_param_list_without_self_reference.py

@@ -65,6 +65,7 @@ from classiq.interface.generator.piecewise_linear_amplitude_loading import (
 from classiq.interface.generator.qft import QFT
 from classiq.interface.generator.qsvm import QSVMFeatureMap
 from classiq.interface.generator.randomized_benchmarking import RandomizedBenchmarking
+from classiq.interface.generator.reset import Reset
 from classiq.interface.generator.standard_gates.standard_gates_param_list import (
     standard_gate_function_param_library,
 )
@@ -150,6 +151,7 @@ function_param_library_without_self_reference: FunctionParamLibrary = (
                 PiecewiseLinearRotationAmplitudeLoading,
                 HadamardTransform,
                 Copy,
+                Reset,
             },
             standard_gate_function_param_library.param_list,
             oracle_function_param_library.param_list,

classiq/interface/generator/functions/type_name.py

@@ -3,7 +3,7 @@ from typing import TYPE_CHECKING, Any, Literal, Optional
 
 import pydantic
 
-from classiq.interface.exceptions import ClassiqInternalError
+from classiq.interface.exceptions import ClassiqExpansionError
 from classiq.interface.generator.expressions.qmod_qstruct_proxy import QmodQStructProxy
 from classiq.interface.generator.functions.classical_type import (
     ClassicalType,
@@ -59,7 +59,7 @@ class TypeName(ClassicalType, QuantumType):
     @property
     def fields(self) -> Mapping[str, "ConcreteQuantumType"]:
         if self._assigned_fields is None:
-            raise ClassiqInternalError("Fields not set")
+            raise ClassiqExpansionError(f"Type {self.name!r} is undefined")
         return self._assigned_fields
 
     @property

classiq/interface/generator/generated_circuit_data.py

@@ -11,6 +11,7 @@ from classiq.interface.generator.register_role import RegisterRole
 from classiq.interface.generator.synthesis_metadata.synthesis_execution_data import (
     ExecutionData,
 )
+from classiq.interface.model.statement_block import StatementBlock
 
 from classiq.model_expansions.capturing.mangling_utils import (
     demangle_capture_name,
@@ -22,7 +23,7 @@ _logger = logging.getLogger(__name__)
 ParameterName = str
 IOQubitMapping: TypeAlias = dict[str, tuple[int, ...]]
 
-CLASSIQ_HIERARCHY_SEPARATOR: Literal["."] = "."
+CLASSIQ_HIERARCHY_SEPARATOR: Literal["__"] = "__"
 
 VISUALIZATION_HIDE_LIST = [
     "apply_to_all",
@@ -135,6 +136,8 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
     level: OperationLevel = pydantic.Field(default=OperationLevel.UNKNOWN)
     parameters: list[OperationParameter] = list()
     port_to_passed_variable_map: dict[str, str] = pydantic.Field(default={})
+    release_by_inverse: bool = pydantic.Field(default=False)
+    back_refs: StatementBlock = pydantic.Field(default_factory=list)
 
     model_config = ConfigDict(extra="allow")
     # Temporary field to store the override debug info for parallel old/new visualization
@@ -166,7 +169,7 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
 
     @staticmethod
     def create_parameters_from_dict(
-        parameters: dict[str, str]
+        parameters: dict[str, str],
     ) -> list[OperationParameter]:
         return [
             OperationParameter(label=key, value=value)
@@ -227,14 +230,46 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
         )
 
     def inverse(self) -> "FunctionDebugInfoInterface":
-        inverted_children = [child.inverse() for child in self.children[::-1]]
+        if self.override_debug_info is not None:
+            self.override_debug_info = self.override_debug_info.inverse()
+            return self
+        inverse_generated_function = (
+            self.generated_function.model_copy(
+                update=dict(registers=self._inverse_registers)
+            )
+            if self.generated_function
+            else None
+        )
+        inverted_children = [child.inverse() for child in reversed(self.children)]
         return self.model_copy(
             update=dict(
                 is_inverse=not self.is_inverse,
                 children=inverted_children,
+                generated_function=inverse_generated_function,
             )
         )
 
+    @property
+    def _inverse_registers(self) -> list[GeneratedRegister]:
+        return [
+            reg.model_copy(update=dict(role=self._inverse_register_role(reg.role)))
+            for reg in self.registers
+        ]
+
+    def _inverse_register_role(self, role: RegisterRole) -> RegisterRole:
+        if role is RegisterRole.INPUT:
+            return RegisterRole.OUTPUT
+        if role is RegisterRole.EXPLICIT_ZERO_INPUT or role is RegisterRole.ZERO_INPUT:
+            if self.release_by_inverse:
+                return RegisterRole.ZERO_OUTPUT
+            return RegisterRole.OUTPUT
+        if role is RegisterRole.AUXILIARY:
+            return RegisterRole.AUXILIARY
+        if role is RegisterRole.OUTPUT or role is RegisterRole.GARBAGE_OUTPUT:
+            return RegisterRole.INPUT
+        if role is RegisterRole.ZERO_OUTPUT:
+            return RegisterRole.ZERO_INPUT
+
 
 def _get_absolute_from_relative(
     absolute_qubits: tuple[int, ...], relative_qubits: tuple[int, ...]

classiq/interface/generator/hardware_efficient_ansatz.py

@@ -60,7 +60,7 @@ class HardwareEfficientAnsatz(function_params.FunctionParams):
         description='List of gates for the two qubit gates entangling layer, e.g. ["cx", "cry"]',
     )
     parameter_prefix: str = pydantic.Field(
-        default="param_",
+        default="hea_param_",
         description="Prefix for the generated parameters",
     )
 

classiq/interface/generator/hva.py

@@ -17,6 +17,6 @@ class HVA(ChemistryFunctionParams):
         default=False, description="Whether to evolve the operator naively"
     )
     parameter_prefix: str = pydantic.Field(
-        default="param_",
+        default="hva_param_",
         description="Prefix for the generated parameters",
     )

classiq/interface/generator/model/preferences/preferences.py

@@ -36,7 +36,7 @@ if TYPE_CHECKING:
     PydanticBackendName = str
 else:
     PydanticBackendName = Annotated[
-        str, Field(strict=True, min_length=1, pattern="^([.A-Za-z0-9_-]*)$")
+        str, Field(strict=True, pattern="^([.A-Za-z0-9_-][ .A-Za-z0-9_-]*)$")
     ]
 
 
@@ -262,6 +262,13 @@ class Preferences(pydantic.BaseModel, extra="forbid"):
 
         return output_format
 
+    @pydantic.field_validator("backend_name")
+    @classmethod
+    def validate_backend_name(cls, backend_name: Optional[str]) -> Optional[str]:
+        if backend_name is None:
+            return backend_name
+        return backend_name.rstrip()
+
     @pydantic.model_validator(mode="after")
     def validate_backend(self) -> Self:
         backend_name = self.backend_name

classiq/interface/generator/quantum_program.py

@@ -1,9 +1,11 @@
 import uuid
 from datetime import datetime, timezone
 from pathlib import Path
-from typing import Optional, Union
+from typing import Any, Optional, Union
 
 import pydantic
+from pydantic import model_validator
+from pydantic_core.core_schema import ValidationInfo
 from typing_extensions import TypeAlias
 
 from classiq.interface.exceptions import (
@@ -36,6 +38,8 @@ from classiq.interface.ide.visual_model import CircuitMetrics
 RegisterName: TypeAlias = str
 InitialConditions: TypeAlias = dict[RegisterName, int]
 
+OMIT_DEBUG_INFO_FLAG = "omit_debug_info"
+
 
 class TranspiledCircuitData(CircuitCodeInterface):
     depth: int
@@ -71,6 +75,19 @@ class QuantumProgram(VersionedModel, CircuitCodeInterface):
     program_id: str = pydantic.Field(default_factory=get_uuid_as_str)
     execution_primitives_input: Optional[PrimitivesInput] = pydantic.Field(default=None)
 
+    @model_validator(mode="before")
+    @classmethod
+    def remove_debug_info(
+        cls, data: dict[str, Any], info: ValidationInfo
+    ) -> dict[str, Any]:
+        if (
+            isinstance(data, dict)
+            and info.context is not None
+            and info.context.get(OMIT_DEBUG_INFO_FLAG, False)
+        ):
+            data.pop("debug_info", None)
+        return data
+
     def _hardware_agnostic_program_code(self) -> CodeAndSyntax:
         circuit_code = self.program_circuit.get_code_by_priority()
         if circuit_code is not None: