classiq 0.43.2__py3-none-any.whl → 0.44.0__py3-none-any.whl

classiq/interface/executor/execution_preferences.py

@@ -1,15 +1,11 @@
-from datetime import timedelta
-from typing import Any, Dict, Optional
+from typing import Optional
 
 import pydantic
 
 from classiq.interface.backend.backend_preferences import (
-    AWS_DEFAULT_JOB_TIMEOUT_SECONDS,
-    AwsBackendPreferences,
     BackendPreferencesTypes,
     backend_preferences_field,
 )
-from classiq.interface.backend.pydantic_backend import MAX_EXECUTION_TIMEOUT_SECONDS
 from classiq.interface.backend.quantum_backend_providers import (
     ClassiqSimulatorBackendNames,
 )
@@ -21,17 +17,6 @@ from classiq.interface.generator.model.preferences.randomness import create_rand
 from classiq.interface.generator.noise_properties import NoiseProperties
 
 from classiq._internals.enum_utils import ReprEnum
-from classiq.exceptions import ClassiqValueError
-
-DIFFERENT_TIMEOUT_MSG = (
-    "Timeout is defined differently in the execution preferences and the "
-    "AWS Backend Preferences."
-)
-
-TIMEOUT_LARGE_FOR_AWS_MSG = (
-    "Timeout is larger than the current allowed limit of "
-    f"{timedelta(MAX_EXECUTION_TIMEOUT_SECONDS)}"
-)
 
 
 class QaeWithQpeEstimationMethod(int, ReprEnum):
@@ -40,11 +25,6 @@ class QaeWithQpeEstimationMethod(int, ReprEnum):
 
 
 class ExecutionPreferences(pydantic.BaseModel):
-    timeout_sec: Optional[pydantic.PositiveInt] = pydantic.Field(
-        default=None,
-        description="If set, limits the execution runtime. Value is in seconds. "
-        "Not supported on all platforms.",
-    )
     noise_properties: Optional[NoiseProperties] = pydantic.Field(
         default=None, description="Properties of the noise in the circuit"
     )
@@ -66,30 +46,6 @@ class ExecutionPreferences(pydantic.BaseModel):
         description="The job name",
     )
 
-    def __init__(self, **kwargs: Any) -> None:
-        super().__init__(**kwargs)
-
-    @pydantic.validator("backend_preferences", always=True)
-    def validate_timeout_for_aws(
-        cls, backend_preferences: BackendPreferencesTypes, values: Dict[str, Any]
-    ) -> BackendPreferencesTypes:
-        timeout = values.get("timeout_sec", None)
-        if (
-            not isinstance(backend_preferences, AwsBackendPreferences)
-            or timeout is None
-        ):
-            return backend_preferences
-        if (
-            timeout != backend_preferences.job_timeout
-            and backend_preferences.job_timeout != AWS_DEFAULT_JOB_TIMEOUT_SECONDS
-        ):
-            raise ClassiqValueError(DIFFERENT_TIMEOUT_MSG)
-        if timeout > MAX_EXECUTION_TIMEOUT_SECONDS:
-            raise ClassiqValueError(TIMEOUT_LARGE_FOR_AWS_MSG)
-
-        backend_preferences.job_timeout = timeout
-        return backend_preferences
-
 
 __all__ = [
     "ExecutionPreferences",

classiq/interface/executor/result.py

@@ -2,6 +2,7 @@ import functools
 import operator
 from collections import defaultdict
 from typing import (
+    TYPE_CHECKING,
     Any,
     DefaultDict,
     Dict,
@@ -32,7 +33,7 @@ _UNAVAILABLE_OUTPUT_ERROR_MSG: str = "Requested output doesn't exist in the circ
 
 State: TypeAlias = str
 Name: TypeAlias = str
-RegisterValue: TypeAlias = Union[float, int]
+RegisterValue: TypeAlias = Union[float, int, list, dict]
 MeasuredShots: TypeAlias = pydantic.NonNegativeInt
 ParsedState: TypeAlias = Mapping[Name, RegisterValue]
 ParsedStates: TypeAlias = Mapping[State, ParsedState]
@@ -60,6 +61,7 @@ class SimulatedState(BaseModel):
         return self.state[item]
 
 
+SimulatedState.update_forward_refs(RegisterValue=RegisterValue)
 ParsedStateVector: TypeAlias = List[SimulatedState]
 
 
@@ -122,6 +124,23 @@ def get_parsed_counts(counts: Counts, parsed_states: ParsedStates) -> ParsedCoun
     return sorted(parsed_counts, key=lambda k: k.shots, reverse=True)
 
 
+def prepare_parsed_state_vector(
+    state_vector: StateVector, parsed_state_vector_states: ParsedStates
+) -> Optional[ParsedStateVector]:
+    if not state_vector:
+        return None
+
+    parsed_state_vector = [
+        SimulatedState(
+            state=parsed_state_vector_states[bitstring],
+            bitstring=bitstring,
+            amplitude=complex(amplitude_str),
+        )
+        for bitstring, amplitude_str in state_vector.items()
+    ]
+    return sorted(parsed_state_vector, key=lambda k: abs(k.amplitude), reverse=True)
+
+
 class ExecutionDetails(BaseModel, QmodPyObject):
     vendor_format_result: Dict[str, Any] = pydantic.Field(
         ..., description="Result in proprietary vendor format"
@@ -184,17 +203,9 @@ class ExecutionDetails(BaseModel, QmodPyObject):
 
     @property
     def parsed_state_vector(self) -> Optional[ParsedStateVector]:
-        if not self.state_vector:
-            return None
-        parsed_state_vector = [
-            SimulatedState(
-                state=self.parsed_state_vector_states[bitstring],
-                bitstring=bitstring,
-                amplitude=complex(amplitude_str),
-            )
-            for bitstring, amplitude_str in self.state_vector.items()
-        ]
-        return sorted(parsed_state_vector, key=lambda k: abs(k.amplitude), reverse=True)
+        return prepare_parsed_state_vector(
+            self.state_vector, self.parsed_state_vector_states
+        )
 
     def flip_execution_counts_bitstring(self) -> None:
         """Backends should return result count bitstring in right to left form"""
@@ -261,6 +272,8 @@ class ExecutionDetails(BaseModel, QmodPyObject):
             lsb_right=False
         ).items():
             value = value_from_str_bin(binary_string=results_binary_key)
+            if TYPE_CHECKING:
+                assert isinstance(value, float)
             register_output[value] = register_output.get(value, 0) + counts
 
         return register_output

classiq/interface/generator/application_apis/arithmetic_declarations.py

@@ -2,13 +2,16 @@ from classiq.interface.generator.functions.classical_function_declaration import
     ClassicalFunctionDeclaration,
 )
 from classiq.interface.generator.functions.classical_type import Integer, Real
+from classiq.interface.model.classical_parameter_declaration import (
+    ClassicalParameterDeclaration,
+)
 
 qft_const_adder_phase = ClassicalFunctionDeclaration(
     name="qft_const_adder_phase",
-    param_decls={
-        "bit_index": Integer(),
-        "value": Integer(),
-        "reg_len": Integer(),
-    },
+    positional_parameters=[
+        ClassicalParameterDeclaration(name="bit_index", classical_type=Integer()),
+        ClassicalParameterDeclaration(name="value", classical_type=Integer()),
+        ClassicalParameterDeclaration(name="reg_len", classical_type=Integer()),
+    ],
     return_type=Real(),
 )

classiq/interface/generator/application_apis/chemistry_declarations.py

@@ -10,43 +10,44 @@ from classiq.interface.generator.functions.classical_type import (
     ClassicalList,
     Integer,
     Real,
-    Struct,
-    TypeName,
     VQEResult,
 )
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
+from classiq.interface.generator.functions.type_name import Struct, TypeName
 from classiq.interface.generator.types.struct_declaration import StructDeclaration
+from classiq.interface.model.classical_parameter_declaration import (
+    ClassicalParameterDeclaration,
+)
 from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_function_declaration import (
-    QuantumFunctionDeclaration,
+    NamedParamsQuantumFunctionDeclaration,
 )
 
-MOLECULE_PROBLEM_PARAM = {"molecule_problem": Struct(name="MoleculeProblem")}
+MOLECULE_PROBLEM_PARAM = ClassicalParameterDeclaration(
+    name="molecule_problem", classical_type=Struct(name="MoleculeProblem")
+)
 MOLECULE_PROBLEM_SIZE = "get_field(get_field(molecule_problem_to_hamiltonian(molecule_problem)[0], 'pauli'), 'len')"
-MOLECULE_PROBLEM_PORT = {
-    "qbv": PortDeclaration(
-        name="qbv",
-        direction=PortDeclarationDirection.Inout,
-        size=Expression(
-            expr=MOLECULE_PROBLEM_SIZE,
-        ),
-    )
-}
+MOLECULE_PROBLEM_PORT = PortDeclaration(
+    name="qbv",
+    direction=PortDeclarationDirection.Inout,
+    size=Expression(
+        expr=MOLECULE_PROBLEM_SIZE,
+    ),
+)
 
-FOCK_HAMILTONIAN_PROBLEM_PARAM = {
-    "fock_hamiltonian_problem": Struct(name="FockHamiltonianProblem")
-}
+FOCK_HAMILTONIAN_PROBLEM_PARAM = ClassicalParameterDeclaration(
+    name="fock_hamiltonian_problem",
+    classical_type=Struct(name="FockHamiltonianProblem"),
+)
 FOCK_HAMILTONIAN_SIZE = "get_field(get_field(fock_hamiltonian_problem_to_hamiltonian(fock_hamiltonian_problem)[0], 'pauli'), 'len')"
 
-FOCK_HAMILTONIAN_PROBLEM_PORT = {
-    "qbv": PortDeclaration(
-        name="qbv",
-        direction=PortDeclarationDirection.Inout,
-        size=Expression(expr=FOCK_HAMILTONIAN_SIZE),
-    )
-}
+FOCK_HAMILTONIAN_PROBLEM_PORT = PortDeclaration(
+    name="qbv",
+    direction=PortDeclarationDirection.Inout,
+    size=Expression(expr=FOCK_HAMILTONIAN_SIZE),
+)
 
 
 class ChemistryProblemType(Enum):
@@ -54,59 +55,63 @@ class ChemistryProblemType(Enum):
     FockHamiltonianProblem = "fock_hamiltonian_problem"
 
 
-MOLECULE_UCC_ANSATZ = QuantumFunctionDeclaration(
+MOLECULE_UCC_ANSATZ = NamedParamsQuantumFunctionDeclaration(
     name="molecule_ucc",
-    param_decls={
-        **MOLECULE_PROBLEM_PARAM,
-        "excitations": ClassicalList(element_type=Integer()),
-    },
-    port_declarations=MOLECULE_PROBLEM_PORT,
+    positional_arg_declarations=[
+        MOLECULE_PROBLEM_PARAM,
+        ClassicalParameterDeclaration(
+            name="excitations", classical_type=ClassicalList(element_type=Integer())
+        ),
+        MOLECULE_PROBLEM_PORT,
+    ],
 )
 
 
-MOLECULE_HVA_ANSATZ = QuantumFunctionDeclaration(
+MOLECULE_HVA_ANSATZ = NamedParamsQuantumFunctionDeclaration(
     name="molecule_hva",
-    param_decls={
-        **MOLECULE_PROBLEM_PARAM,
-        "reps": Integer(),
-    },
-    port_declarations=MOLECULE_PROBLEM_PORT,
+    positional_arg_declarations=[
+        MOLECULE_PROBLEM_PARAM,
+        ClassicalParameterDeclaration(name="reps", classical_type=Integer()),
+        MOLECULE_PROBLEM_PORT,
+    ],
 )
 
 
-MOLECULE_HARTREE_FOCK = QuantumFunctionDeclaration(
+MOLECULE_HARTREE_FOCK = NamedParamsQuantumFunctionDeclaration(
     name="molecule_hartree_fock",
-    param_decls={
-        **MOLECULE_PROBLEM_PARAM,
-    },
-    port_declarations=MOLECULE_PROBLEM_PORT,
+    positional_arg_declarations=[
+        MOLECULE_PROBLEM_PARAM,
+        MOLECULE_PROBLEM_PORT,
+    ],
 )
 
 
-FOCK_HAMILTONIAN_UCC_ANSATZ = QuantumFunctionDeclaration(
+FOCK_HAMILTONIAN_UCC_ANSATZ = NamedParamsQuantumFunctionDeclaration(
     name="fock_hamiltonian_ucc",
-    param_decls={
-        **FOCK_HAMILTONIAN_PROBLEM_PARAM,
-        "excitations": ClassicalList(element_type=Integer()),
-    },
-    port_declarations=FOCK_HAMILTONIAN_PROBLEM_PORT,
+    positional_arg_declarations=[
+        FOCK_HAMILTONIAN_PROBLEM_PARAM,
+        ClassicalParameterDeclaration(
+            name="excitations", classical_type=ClassicalList(element_type=Integer())
+        ),
+        FOCK_HAMILTONIAN_PROBLEM_PORT,
+    ],
 )
 
-FOCK_HAMILTONIAN_HVA_ANSATZ = QuantumFunctionDeclaration(
+FOCK_HAMILTONIAN_HVA_ANSATZ = NamedParamsQuantumFunctionDeclaration(
     name="fock_hamiltonian_hva",
-    param_decls={
-        **FOCK_HAMILTONIAN_PROBLEM_PARAM,
-        "reps": Integer(),
-    },
-    port_declarations=FOCK_HAMILTONIAN_PROBLEM_PORT,
+    positional_arg_declarations=[
+        FOCK_HAMILTONIAN_PROBLEM_PARAM,
+        ClassicalParameterDeclaration(name="reps", classical_type=Integer()),
+        FOCK_HAMILTONIAN_PROBLEM_PORT,
+    ],
 )
 
-FOCK_HAMILTONIAN_HARTREE_FOCK = QuantumFunctionDeclaration(
+FOCK_HAMILTONIAN_HARTREE_FOCK = NamedParamsQuantumFunctionDeclaration(
     name="fock_hamiltonian_hartree_fock",
-    param_decls={
-        **FOCK_HAMILTONIAN_PROBLEM_PARAM,
-    },
-    port_declarations=FOCK_HAMILTONIAN_PROBLEM_PORT,
+    positional_arg_declarations=[
+        FOCK_HAMILTONIAN_PROBLEM_PARAM,
+        FOCK_HAMILTONIAN_PROBLEM_PORT,
+    ],
 )
 
 
@@ -187,20 +192,33 @@ MOLECULE_RESULT = StructDeclaration(
 
 MOLECULE_PROBLEM_TO_HAMILTONIAN = ClassicalFunctionDeclaration(
     name="molecule_problem_to_hamiltonian",
-    param_decls={"problem": Struct(name="MoleculeProblem")},
+    positional_parameters=[
+        ClassicalParameterDeclaration(
+            name="problem", classical_type=Struct(name="MoleculeProblem")
+        ),
+    ],
     return_type=ClassicalList(element_type=Struct(name="PauliTerm")),
 )
 
 FOCK_HAMILTONIAN_PROBLEM_TO_HAMILTONIAN = ClassicalFunctionDeclaration(
     name="fock_hamiltonian_problem_to_hamiltonian",
-    param_decls={"problem": Struct(name="FockHamiltonianProblem")},
+    positional_parameters=[
+        ClassicalParameterDeclaration(
+            name="problem", classical_type=Struct(name="FockHamiltonianProblem")
+        ),
+    ],
     return_type=ClassicalList(element_type=Struct(name="PauliTerm")),
 )
 
 
 MOLECULE_GROUND_STATE_SOLUTION_POST_PROCESS = ClassicalFunctionDeclaration(
     name="molecule_ground_state_solution_post_process",
-    param_decls={"problem": Struct(name="MoleculeProblem"), "vqe_result": VQEResult()},
+    positional_parameters=[
+        ClassicalParameterDeclaration(
+            name="problem", classical_type=Struct(name="MoleculeProblem")
+        ),
+        ClassicalParameterDeclaration(name="vqe_result", classical_type=VQEResult()),
+    ],
     return_type=Struct(name="MoleculeResult"),
 )
 

classiq/interface/generator/application_apis/combinatorial_optimization_declarations.py

@@ -5,11 +5,14 @@ from classiq.interface.generator.functions.classical_type import (
     ClassicalList,
     Integer,
     Real,
-    Struct,
     StructMetaType,
     VQEResult,
 )
+from classiq.interface.generator.functions.type_name import Struct
 from classiq.interface.generator.types.struct_declaration import StructDeclaration
+from classiq.interface.model.classical_parameter_declaration import (
+    ClassicalParameterDeclaration,
+)
 
 COMBINATORIAL_OPTIMIZATION_SOLUTION = StructDeclaration(
     name="CombinatorialOptimizationSolution",
@@ -23,20 +26,26 @@ COMBINATORIAL_OPTIMIZATION_SOLUTION = StructDeclaration(
 
 OPTIMIZATION_PROBLEM_TO_HAMILTONIAN = ClassicalFunctionDeclaration(
     name="optimization_problem_to_hamiltonian",
-    param_decls={
-        "problem_type": StructMetaType(),
-        "penalty_energy": Real(),
-    },
+    positional_parameters=[
+        ClassicalParameterDeclaration(
+            name="problem_type", classical_type=StructMetaType()
+        ),
+        ClassicalParameterDeclaration(name="penalty_energy", classical_type=Real()),
+    ],
     return_type=ClassicalList(element_type=Struct(name="PauliTerm")),
 )
 
 GET_OPTIMIZATION_SOLUTION = ClassicalFunctionDeclaration(
     name="get_optimization_solution",
-    param_decls={
-        "problem_type": StructMetaType(),
-        "vqe_result_handle": VQEResult(),
-        "penalty_energy": Real(),
-    },
+    positional_parameters=[
+        ClassicalParameterDeclaration(
+            name="problem_type", classical_type=StructMetaType()
+        ),
+        ClassicalParameterDeclaration(
+            name="vqe_result_handle", classical_type=VQEResult()
+        ),
+        ClassicalParameterDeclaration(name="penalty_energy", classical_type=Real()),
+    ],
     return_type=ClassicalList(
         element_type=Struct(name="CombinatorialOptimizationSolution")
     ),

classiq/interface/generator/application_apis/entangler_declarations.py

@@ -6,19 +6,24 @@ from classiq.interface.generator.functions.classical_type import (
     ClassicalList,
     Integer,
 )
+from classiq.interface.model.classical_parameter_declaration import (
+    ClassicalParameterDeclaration,
+)
 
 GRID_ENTANGLER_GRAPH = ClassicalFunctionDeclaration(
     name="grid_entangler_graph",
-    param_decls={
-        "num_qubits": Integer(),
-        "schmidt_rank": Integer(),
-        "grid_randomization": Bool(),
-    },
+    positional_parameters=[
+        ClassicalParameterDeclaration(name="num_qubits", classical_type=Integer()),
+        ClassicalParameterDeclaration(name="schmidt_rank", classical_type=Integer()),
+        ClassicalParameterDeclaration(name="grid_randomization", classical_type=Bool()),
+    ],
     return_type=ClassicalList(element_type=ClassicalList(element_type=Integer())),
 )
 
 HYPERCUBE_ENTANGLER_GRAPH = ClassicalFunctionDeclaration(
     name="hypercube_entangler_graph",
-    param_decls={"num_qubits": Integer()},
+    positional_parameters=[
+        ClassicalParameterDeclaration(name="num_qubits", classical_type=Integer()),
+    ],
     return_type=ClassicalList(element_type=ClassicalList(element_type=Integer())),
 )

classiq/interface/generator/application_apis/finance_declarations.py

@@ -10,15 +10,18 @@ from classiq.interface.generator.functions.classical_type import (
     ClassicalList,
     Integer,
     Real,
-    Struct,
 )
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
+from classiq.interface.generator.functions.type_name import Struct
 from classiq.interface.generator.types.struct_declaration import StructDeclaration
+from classiq.interface.model.classical_parameter_declaration import (
+    ClassicalParameterDeclaration,
+)
 from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_function_declaration import (
-    QuantumFunctionDeclaration,
+    NamedParamsQuantumFunctionDeclaration,
 )
 
 if TYPE_CHECKING:
@@ -59,25 +62,28 @@ FINANCE_FUNCTION_PORT_SIZE_FUNCTION_MAPPING: Mapping[FinanceModelType, Callable]
 
 def _generate_finance_function(
     finance_model: FinanceModelType,
-) -> QuantumFunctionDeclaration:
-    return QuantumFunctionDeclaration(
+) -> NamedParamsQuantumFunctionDeclaration:
+    return NamedParamsQuantumFunctionDeclaration(
         name=f"{finance_model.value}_finance",
-        param_decls={
-            "finance_model": Struct(name=f"{finance_model.name}Model"),
-            "finance_function": Struct(name="FinanceFunction"),
-        },
-        port_declarations={
-            FUNCTION_PORT_NAME: PortDeclaration(
+        positional_arg_declarations=[
+            ClassicalParameterDeclaration(
+                name="finance_model",
+                classical_type=Struct(name=f"{finance_model.name}Model"),
+            ),
+            ClassicalParameterDeclaration(
+                name="finance_function", classical_type=Struct(name="FinanceFunction")
+            ),
+            PortDeclaration(
                 name=FUNCTION_PORT_NAME,
                 direction=PortDeclarationDirection.Inout,
                 size=Expression(expr=FINANCE_FUNCTION_PORT_SIZE_MAPPING[finance_model]),
             ),
-            OBJECTIVE_PORT_NAME: PortDeclaration(
+            PortDeclaration(
                 name=OBJECTIVE_PORT_NAME,
                 direction=PortDeclarationDirection.Inout,
                 size=Expression(expr="1"),
             ),
-        },
+        ],
     )
 
 
@@ -118,21 +124,29 @@ FINANCE_FUNCTION = StructDeclaration(
 
 LOG_NORMAL_FINANCE_POST_PROCESS = ClassicalFunctionDeclaration(
     name="log_normal_finance_post_process",
-    param_decls={
-        "finance_model": Struct(name="LogNormalModel"),
-        "estimation_method": Struct(name="FinanceFunction"),
-        "probability": Real(),
-    },
+    positional_parameters=[
+        ClassicalParameterDeclaration(
+            name="finance_model", classical_type=Struct(name="LogNormalModel")
+        ),
+        ClassicalParameterDeclaration(
+            name="estimation_method", classical_type=Struct(name="FinanceFunction")
+        ),
+        ClassicalParameterDeclaration(name="probability", classical_type=Real()),
+    ],
     return_type=Real(),
 )
 
 GAUSSIAN_FINANCE_POST_PROCESS = ClassicalFunctionDeclaration(
     name="gaussian_finance_post_process",
-    param_decls={
-        "finance_model": Struct(name="GaussianModel"),
-        "estimation_method": Struct(name="FinanceFunction"),
-        "probability": Real(),
-    },
+    positional_parameters=[
+        ClassicalParameterDeclaration(
+            name="finance_model", classical_type=Struct(name="GaussianModel")
+        ),
+        ClassicalParameterDeclaration(
+            name="estimation_method", classical_type=Struct(name="FinanceFunction")
+        ),
+        ClassicalParameterDeclaration(name="probability", classical_type=Real()),
+    ],
     return_type=Real(),
 )
 

classiq/interface/generator/application_apis/qsvm_declarations.py

@@ -3,18 +3,20 @@ import enum
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.classical_type import (
     ClassicalList,
-    Enum,
     Integer,
     Real,
-    Struct,
 )
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
+from classiq.interface.generator.functions.type_name import Enum, Struct
 from classiq.interface.generator.types.struct_declaration import StructDeclaration
+from classiq.interface.model.classical_parameter_declaration import (
+    ClassicalParameterDeclaration,
+)
 from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_function_declaration import (
-    QuantumFunctionDeclaration,
+    NamedParamsQuantumFunctionDeclaration,
 )
 
 
@@ -24,29 +26,33 @@ class FeatureMapType(enum.Enum):
 
 
 QSVM_PAULI_FEATURE_MAP_SIZE = "get_field(feature_map, 'feature_dimension')"
-QSVM_PAULI_FEATURE_MAP = QuantumFunctionDeclaration(
+QSVM_PAULI_FEATURE_MAP = NamedParamsQuantumFunctionDeclaration(
     name="pauli_feature_map",
-    param_decls={"feature_map": Struct(name="QSVMFeatureMapPauli")},
-    port_declarations={
-        "qbv": PortDeclaration(
+    positional_arg_declarations=[
+        ClassicalParameterDeclaration(
+            name="feature_map", classical_type=Struct(name="QSVMFeatureMapPauli")
+        ),
+        PortDeclaration(
             name="qbv",
             direction=PortDeclarationDirection.Inout,
             size=Expression(expr=QSVM_PAULI_FEATURE_MAP_SIZE),
-        )
-    },
+        ),
+    ],
 )
 
 QSVM_BLOCH_SPHERE_FEATURE_MAP_SIZE = "ceiling(feature_dimension/2)"
-QSVM_BLOCH_SPHERE_FEATURE_MAP = QuantumFunctionDeclaration(
+QSVM_BLOCH_SPHERE_FEATURE_MAP = NamedParamsQuantumFunctionDeclaration(
     name="bloch_sphere_feature_map",
-    param_decls={"feature_dimension": Integer()},
-    port_declarations={
-        "qbv": PortDeclaration(
+    positional_arg_declarations=[
+        ClassicalParameterDeclaration(
+            name="feature_dimension", classical_type=Integer()
+        ),
+        PortDeclaration(
             name="qbv",
             direction=PortDeclarationDirection.Inout,
             size=Expression(expr=QSVM_BLOCH_SPHERE_FEATURE_MAP_SIZE),
-        )
-    },
+        ),
+    ],
 )
 
 QSVM_FEATURE_MAP_PAULI = StructDeclaration(

classiq/interface/generator/arith/arithmetic_expression_abc.py

@@ -88,7 +88,27 @@ class ArithmeticExpressionABC(abc.ABC, FunctionParams):
         cls._validate_ast_obj(ast_obj)
 
         graph = parse_expression(expression)
-        cls._validate_expression_graph(graph, values)
+        try:
+            cls._validate_expression_graph(graph, values)
+        except ClassiqValueError as e:
+            # This flow was created specifically for inplace Boolean XOR operations like q1 ^ q2.
+            # We can't plug equality in previous stages due to SymPy restrictions.
+            # Note that we don't validate that the expression itself is Boolean (passing non-Boolean expressions
+            # as inplace is currently not supported, so it's a bug).
+            if not e.raw_message == "Expression does not support target assignment":
+                raise
+            ast_parsed_expression = ast.parse(expression)
+            ast_expr = ast_parsed_expression.body[0]
+            if (
+                not isinstance(ast_expr, ast.Expr)
+                or not isinstance(ast_expr.value, ast.BinOp)
+                or not isinstance(ast_expr.value.op, ast.BitXor)
+            ):
+                raise
+            expression = f"({expression}) == 1"
+            graph = parse_expression(expression)
+            cls._validate_expression_graph(graph, values)
+
         validate_arithmetic_result_type(
             graph=graph,
             definitions=definitions,