classiq 0.70.0__py3-none-any.whl → 0.72.0__py3-none-any.whl

classiq/__init__.py

@@ -34,13 +34,10 @@ from classiq.applications.combinatorial_optimization import (
     execute_qaoa,
     pyo_model_to_hamiltonian,
 )
-from classiq.applications.finance import construct_finance_model
-from classiq.applications.grover import construct_grover_model
 from classiq.applications.hamiltonian.pauli_decomposition import (
     hamiltonian_to_matrix,
     matrix_to_hamiltonian,
 )
-from classiq.applications.qsvm import construct_qsvm_model
 from classiq.executor import (
     execute,
     execute_async,
@@ -65,11 +62,8 @@ from classiq.synthesis import (
 )
 
 _application_constructors_all = [
-    "construct_qsvm_model",
     "construct_combinatorial_optimization_model",
     "construct_chemistry_model",
-    "construct_finance_model",
-    "construct_grover_model",
     "molecule_problem_to_qmod",
 ]
 

classiq/_internals/client.py

@@ -23,6 +23,7 @@ from classiq._internals.authentication import token_manager
 from classiq._internals.host_checker import HostChecker
 
 _FRONTEND_VARIANT: str = "classiq-sdk"
+_SDK_ENV: str = "sdk-env"
 _INTERFACE_VARIANT: str = "classiq-interface-sdk"
 _USERAGENT_SEPARATOR: str = " "
 
@@ -74,12 +75,21 @@ def _get_user_agent_header() -> Headers:
     python_version = (
         f"python({_get_python_execution_environment()})/{platform.python_version()}"
     )
+
+    sdk_env_value = os.getenv("SDK_ENV", "Default")
     os_platform = f"{os.name}/{platform.platform()}"
     frontend_version = f"{_FRONTEND_VARIANT}/{_VERSION}"
     interface_version = f"{_INTERFACE_VARIANT}/{_VERSION}"
+    sdk_env = f"{_SDK_ENV}/{sdk_env_value}"
     return {
         "User-Agent": _USERAGENT_SEPARATOR.join(
-            (python_version, os_platform, frontend_version, interface_version)
+            (
+                python_version,
+                os_platform,
+                frontend_version,
+                interface_version,
+                sdk_env,
+            )
         )
     }
 

classiq/applications/chemistry/chemistry_model_constructor.py

@@ -1,30 +1,17 @@
-# flake8: noqa
-
-from typing import Optional, cast
 from collections.abc import Mapping
+from typing import Optional, cast
 
 from classiq.interface.chemistry.fermionic_operator import (
     FermionicOperator,
     SummedFermionicOperator,
 )
-from classiq.interface.model.allocate import Allocate
-from classiq.interface.model.quantum_statement import QuantumStatement
-from classiq.qmod.builtins.structs import (
-    MoleculeProblem as QmodMoleculeProblem,
-    Molecule as QmodMolecule,
-    ChemistryAtom as QmodChemistryAtom,
-    Position as QmodPosition,
-)
 from classiq.interface.chemistry.ground_state_problem import (
     CHEMISTRY_PROBLEMS_TYPE,
     HamiltonianProblem,
     MoleculeProblem,
 )
 from classiq.interface.chemistry.molecule import Atom
-from classiq.qmod.builtins.enums import (
-    Element,
-    FermionMapping,
-)
+from classiq.interface.exceptions import ClassiqError
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.function_params import IOName
 from classiq.interface.generator.functions.classical_type import (
@@ -34,6 +21,7 @@ from classiq.interface.generator.functions.classical_type import (
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
+from classiq.interface.model.allocate import Allocate
 from classiq.interface.model.classical_parameter_declaration import (
     ClassicalParameterDeclaration,
 )
@@ -43,6 +31,7 @@ from classiq.interface.model.native_function_definition import NativeFunctionDef
 from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.quantum_lambda_function import QuantumLambdaFunction
+from classiq.interface.model.quantum_statement import QuantumStatement
 
 from classiq.applications.chemistry.ansatz_parameters import (
     AnsatzParameters,
@@ -53,8 +42,21 @@ from classiq.applications.chemistry.ansatz_parameters import (
 from classiq.applications.chemistry.chemistry_execution_parameters import (
     ChemistryExecutionParameters,
 )
-from classiq.interface.exceptions import ClassiqError
+from classiq.qmod.builtins.enums import (
+    Element,
+    FermionMapping,
+)
+from classiq.qmod.builtins.structs import (
+    ChemistryAtom as QmodChemistryAtom,
+    Molecule as QmodMolecule,
+    MoleculeProblem as QmodMoleculeProblem,
+    Position as QmodPosition,
+)
 from classiq.qmod.utilities import qmod_val_to_expr_str
+
+# isort: split
+
+# This import causes a circular import if done earlier. We use isort: split to avoid it
 from classiq.open_library.functions.hea import full_hea
 
 _LADDER_OPERATOR_TYPE_INDICATOR_TO_QMOD_MAPPING: dict[str, str] = {

classiq/applications/combinatorial_helpers/optimization_model.py

@@ -4,6 +4,7 @@ from itertools import filterfalse
 from typing import Optional, Union
 
 import pyomo.environ as pyo
+import sympy
 from pyomo.core import ConcreteModel
 from pyomo.core.base import _GeneralVarData
 from pyomo.core.base.constraint import _GeneralConstraintData
@@ -179,8 +180,13 @@ class OptimizationModel:
             objective_map.sympy2pyomo |= penalty_map.sympy2pyomo
             for key, value in penalty_map.pyomo2sympy.items():
                 objective_map.pyomo2sympy[key] = value
+        sympy_renaming = {
+            var: sympy.Symbol(str(var).replace(",", "_").replace("'", "_"))
+            for var in objective_expr.free_symbols
+        }
+        objective_expr = objective_expr.subs(sympy_renaming)
         sympy_mapping = {
-            sympy_var: (
+            sympy_renaming[sympy_var]: (
                 get_field_name(pyomo_var)
                 if not is_index_var(pyomo_var)
                 else (
@@ -190,4 +196,5 @@ class OptimizationModel:
             )
             for pyomo_var, sympy_var in objective_map.pyomo2sympy.items()
         }
-        self.objective_not_encoded_sympy = sympy_mapping, objective_expr
+        compiled_expr = compile(str(objective_expr), "<string>", "eval")
+        self.objective_not_encoded_sympy = sympy_mapping, objective_expr, compiled_expr

classiq/applications/combinatorial_helpers/pyomo_utils.py

@@ -7,6 +7,7 @@ from contextlib import contextmanager
 from enum import Enum
 from functools import reduce
 from operator import mul
+from types import CodeType
 from typing import Any, Optional, TypeVar, Union
 
 import pydantic
@@ -362,6 +363,7 @@ def _get_qmod_field_type(var_name: str, var_data: _GeneralVarData) -> type[QVar]
 def evaluate_objective(
     var_mapping: dict[Any, Union[str, tuple[str, tuple[int, ...]]]],
     sympy_expr: sympy.Expr,
+    code_expr: CodeType,
     struct_obj: Any,
 ) -> Any:
     sympy_assignment = {
@@ -375,7 +377,10 @@ def evaluate_objective(
 
     # classical objective evaluation
     if not isinstance(struct_obj, QStruct):
-        return float(sympy_expr.evalf(subs=sympy_assignment))
+        var_assignment = {
+            str(sympy_var): value for sympy_var, value in sympy_assignment.items()
+        }
+        return eval(code_expr, {}, var_assignment)  # noqa: S307
 
     # quantum objective evaluation
     expr_str = str(sympy_expr).replace("'", "")

classiq/applications/finance/__init__.py

@@ -4,10 +4,7 @@ from classiq.interface.finance import (
     log_normal_model_input,
 )
 
-from .finance_model_constructor import construct_finance_model
-
 __all__ = [
-    "construct_finance_model",
     "function_input",
     "gaussian_model_input",
     "log_normal_model_input",

classiq/applications/qsvm/__init__.py

@@ -2,9 +2,7 @@ from classiq.qmod.builtins.enums import QSVMFeatureMapEntanglement
 
 from ..qsvm import qsvm_data_generation
 from .qsvm import *  # noqa: F403
-from .qsvm_model_constructor import construct_qsvm_model
 
 __all__ = [
     "QSVMFeatureMapEntanglement",
-    "construct_qsvm_model",
 ]

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

classiq/interface/backend/backend_preferences.py

@@ -477,6 +477,27 @@ class IQCCBackendPreferences(BackendPreferences):
     slurm_account: str
 
 
+class CINECABackendPreferences(BackendPreferences):
+    """
+    Represents the backend preferences specific to CINECA.
+
+    Attributes:
+        ssh_username: The username to use when connecting to the SSH server on the login node.
+        ssh_private_key_path: The path to the ssh private key on local machine.
+    """
+
+    backend_service_provider: ProviderTypeVendor.CINECA = pydantic.Field(
+        default=ProviderVendor.CINECA
+    )
+
+    ssh_username: str = pydantic.Field(
+        description="Username to use when connecting to the SSH server on the login node."
+    )
+    ssh_private_key_path: str = pydantic.Field(
+        description="Path of private key file on local machine to use when connecting to the SSH server on the login node."
+    )
+
+
 def is_exact_simulator(backend_preferences: BackendPreferences) -> bool:
     return backend_preferences.backend_name in EXACT_SIMULATORS
 
@@ -509,6 +530,7 @@ BackendPreferencesTypes = Union[
     IntelBackendPreferences,
     AQTBackendPreferences,
     IQCCBackendPreferences,
+    CINECABackendPreferences,
 ]
 
 __all__ = [

classiq/interface/backend/quantum_backend_providers.py

@@ -21,6 +21,7 @@ class ProviderVendor(StrEnum):
     INTEL = "Intel"
     AQT = "AQT"
     IQCC = "IQCC"
+    CINECA = "CINECA"
 
 
 class ProviderTypeVendor:
@@ -35,6 +36,7 @@ class ProviderTypeVendor:
     INTEL = Literal[ProviderVendor.INTEL]
     AQT = Literal[ProviderVendor.AQT]
     IQCC = Literal[ProviderVendor.IQCC]
+    CINECA = Literal[ProviderVendor.CINECA]
 
 
 class ClassiqSimulatorBackendNames(StrEnum):

classiq/interface/debug_info/debug_info.py

@@ -10,6 +10,7 @@ from classiq.interface.generator.generated_circuit_data import (
     OperationLevel,
     StatementType,
 )
+from classiq.interface.model.block import Block
 from classiq.interface.model.statement_block import ConcreteQuantumStatement
 
 ParameterValue = Union[float, int, str, None]
@@ -84,6 +85,9 @@ def get_back_refs(
 ) -> list[ConcreteQuantumStatement]:
     back_refs: list[ConcreteQuantumStatement] = []
     while (node := debug_info.node) is not None:
+        #  For backwards compatibility, we make sure that the back_ref is not a block
+        #  Remove this check when we start saving blocks in the debug info collection.
+        assert not isinstance(node, Block)
         back_refs.insert(0, node)
         if node.back_ref is None:
             break

classiq/interface/generator/expressions/expression_constants.py

@@ -20,6 +20,3 @@ BOOLEAN_LITERALS = {"True", "False"}
 FORBIDDEN_LITERALS: set[str] = set(keyword.kwlist) - SUPPORTED_FUNC_NAMES
 CPARAM_EXECUTION_SUFFIX: Final[str] = "_param"
 RESERVED_EXPRESSIONS: frozenset[str] = frozenset({"i"})
-CPARAM_EXECUTION_SUFFIX_PATTERN = (
-    rf"({CPARAM_EXECUTION_SUFFIX}|^({'|'.join(RESERVED_EXPRESSIONS)}))(_\d+)*$"
-)

classiq/interface/generator/expressions/expression_types.py

@@ -4,6 +4,9 @@ from sympy import Expr
 from sympy.logic.boolalg import Boolean
 
 from classiq.interface.generator.expressions.handle_identifier import HandleIdentifier
+from classiq.interface.generator.expressions.proxies.classical.any_classical_value import (
+    AnyClassicalValue,
+)
 from classiq.interface.generator.expressions.proxies.classical.classical_proxy import (
     ClassicalProxy,
 )
@@ -21,10 +24,12 @@ RuntimeConstant = Union[
     list,
     bool,
     QmodStructInstance,
-    QmodSizedProxy,
     TypeProxy,
     HandleIdentifier,
+]
+Proxies = Union[
+    QmodSizedProxy,
     ClassicalProxy,
 ]
-RuntimeExpression = Union[Expr, Boolean]
-ExpressionValue = Union[RuntimeConstant, RuntimeExpression]
+RuntimeExpression = Union[AnyClassicalValue, Expr, Boolean]
+ExpressionValue = Union[RuntimeConstant, Proxies, RuntimeExpression]

classiq/interface/generator/expressions/proxies/classical/any_classical_value.py

@@ -0,0 +1,135 @@
+from typing import Any
+
+
+class AnyClassicalValue:
+    def __init__(self, expr: str) -> None:
+        self._expr = expr
+
+    def __str__(self) -> str:
+        return self._expr
+
+    def __repr__(self) -> str:
+        return str(self)
+
+    def __getitem__(self, item: Any) -> "AnyClassicalValue":
+        if isinstance(item, slice):
+            subscript = ""
+            if item.start is not None:
+                subscript += str(item.start)
+            subscript += ":"
+            if item.stop is not None:
+                subscript += str(item.stop)
+            if item.step is not None:
+                subscript += f":{item.stop}"
+            item = subscript
+        return AnyClassicalValue(f"{self}[{item}]")
+
+    @staticmethod
+    def _binary_op(lhs: Any, rhs: Any, op: str) -> "AnyClassicalValue":
+        return AnyClassicalValue(f"{lhs} {op} {rhs}")
+
+    @staticmethod
+    def _unary_op(arg: Any, op: str) -> "AnyClassicalValue":
+        return AnyClassicalValue(f"{op}({arg})")
+
+    def __add__(self, other: Any) -> "AnyClassicalValue":
+        return AnyClassicalValue._binary_op(self, other, "+")
+
+    def __sub__(self, other: Any) -> "AnyClassicalValue":
+        return AnyClassicalValue._binary_op(self, other, "-")
+
+    def __mul__(self, other: Any) -> "AnyClassicalValue":
+        return AnyClassicalValue._binary_op(self, other, "*")
+
+    def __truediv__(self, other: Any) -> "AnyClassicalValue":
+        return AnyClassicalValue._binary_op(self, other, "/")
+
+    def __floordiv__(self, other: Any) -> "AnyClassicalValue":
+        return AnyClassicalValue._binary_op(self, other, "//")
+
+    def __mod__(self, other: Any) -> "AnyClassicalValue":
+        return AnyClassicalValue._binary_op(self, other, "%")
+
+    def __pow__(self, other: Any) -> "AnyClassicalValue":
+        return AnyClassicalValue._binary_op(self, other, "**")
+
+    def __lshift__(self, other: Any) -> "AnyClassicalValue":
+        return AnyClassicalValue._binary_op(self, other, "<<")
+
+    def __rshift__(self, other: Any) -> "AnyClassicalValue":
+        return AnyClassicalValue._binary_op(self, other, ">>")
+
+    def __and__(self, other: Any) -> "AnyClassicalValue":
+        return AnyClassicalValue._binary_op(self, other, "&")
+
+    def __xor__(self, other: Any) -> "AnyClassicalValue":
+        return AnyClassicalValue._binary_op(self, other, "^")
+
+    def __or__(self, other: Any) -> "AnyClassicalValue":
+        return AnyClassicalValue._binary_op(self, other, "|")
+
+    def __radd__(self, other: Any) -> "AnyClassicalValue":
+        return AnyClassicalValue._binary_op(other, self, "+")
+
+    def __rsub__(self, other: Any) -> "AnyClassicalValue":
+        return AnyClassicalValue._binary_op(other, self, "-")
+
+    def __rmul__(self, other: Any) -> "AnyClassicalValue":
+        return AnyClassicalValue._binary_op(other, self, "*")
+
+    def __rtruediv__(self, other: Any) -> "AnyClassicalValue":
+        return AnyClassicalValue._binary_op(other, self, "/")
+
+    def __rfloordiv__(self, other: Any) -> "AnyClassicalValue":
+        return AnyClassicalValue._binary_op(other, self, "//")
+
+    def __rmod__(self, other: Any) -> "AnyClassicalValue":
+        return AnyClassicalValue._binary_op(other, self, "%")
+
+    def __rpow__(self, other: Any) -> "AnyClassicalValue":
+        return AnyClassicalValue._binary_op(other, self, "**")
+
+    def __rlshift__(self, other: Any) -> "AnyClassicalValue":
+        return AnyClassicalValue._binary_op(other, self, "<<")
+
+    def __rrshift__(self, other: Any) -> "AnyClassicalValue":
+        return AnyClassicalValue._binary_op(other, self, ">>")
+
+    def __rand__(self, other: Any) -> "AnyClassicalValue":
+        return AnyClassicalValue._binary_op(other, self, "&")
+
+    def __rxor__(self, other: Any) -> "AnyClassicalValue":
+        return AnyClassicalValue._binary_op(other, self, "^")
+
+    def __ror__(self, other: Any) -> "AnyClassicalValue":
+        return AnyClassicalValue._binary_op(other, self, "|")
+
+    def __lt__(self, other: Any) -> "AnyClassicalValue":
+        return AnyClassicalValue._binary_op(self, other, "<")
+
+    def __le__(self, other: Any) -> "AnyClassicalValue":
+        return AnyClassicalValue._binary_op(self, other, "<=")
+
+    def __eq__(self, other: Any) -> "AnyClassicalValue":  # type:ignore[override]
+        return AnyClassicalValue._binary_op(self, other, "==")
+
+    def __ne__(self, other: Any) -> "AnyClassicalValue":  # type: ignore[override]
+        return AnyClassicalValue._binary_op(self, other, "!=")
+
+    def __gt__(self, other: Any) -> "AnyClassicalValue":
+        return AnyClassicalValue._binary_op(self, other, ">")
+
+    def __ge__(self, other: Any) -> "AnyClassicalValue":
+        return AnyClassicalValue._binary_op(self, other, ">=")
+
+    def __neg__(self) -> "AnyClassicalValue":
+        return AnyClassicalValue._unary_op(self, "-")
+
+    def __pos__(self) -> "AnyClassicalValue":
+        return AnyClassicalValue._unary_op(self, "+")
+
+    def __abs__(self) -> "AnyClassicalValue":
+        return AnyClassicalValue._unary_op(self, "abs")
+
+    def __invert__(self) -> "AnyClassicalValue":
+        return AnyClassicalValue._unary_op(self, "~")

classiq/interface/generator/expressions/proxies/classical/classical_array_proxy.py

@@ -38,6 +38,10 @@ class ClassicalArrayProxy(NonSymbolicExpr, ClassicalProxy):
     def type_name(self) -> str:
         return "Array"
 
+    @property
+    def length(self) -> int:
+        return self._length
+
     def __getitem__(self, key: Union[slice, int, Integer]) -> ClassicalProxy:
         return (
             self._get_slice(key) if isinstance(key, slice) else self._get_subscript(key)

classiq/interface/generator/expressions/proxies/classical/classical_struct_proxy.py

@@ -17,11 +17,15 @@ class ClassicalStructProxy(NonSymbolicExpr, ClassicalProxy):
         super().__init__(handle)
         self._decl = decl
 
+    @property
+    def struct_declaration(self) -> "StructDeclaration":
+        return self._decl
+
     @property
     def fields(self) -> Mapping[str, "ExpressionValue"]:
         return {
             field_name: field_type.get_classical_proxy(
-                FieldHandleBinding(base_handle=self.handle, field_name=field_name)
+                FieldHandleBinding(base_handle=self.handle, field=field_name)
             )
             for field_name, field_type in self._decl.variables.items()
         }

classiq/interface/generator/expressions/proxies/classical/utils.py

@@ -0,0 +1,34 @@
+from classiq.interface.exceptions import ClassiqInternalExpansionError
+from classiq.interface.generator.expressions.proxies.classical.classical_array_proxy import (
+    ClassicalArrayProxy,
+)
+from classiq.interface.generator.expressions.proxies.classical.classical_proxy import (
+    ClassicalProxy,
+)
+from classiq.interface.generator.expressions.proxies.classical.classical_scalar_proxy import (
+    ClassicalScalarProxy,
+)
+from classiq.interface.generator.expressions.proxies.classical.classical_struct_proxy import (
+    ClassicalStructProxy,
+)
+from classiq.interface.generator.functions.classical_type import (
+    ClassicalArray,
+    ClassicalType,
+)
+from classiq.interface.generator.functions.type_name import TypeName
+
+
+def get_proxy_type(proxy: ClassicalProxy) -> ClassicalType:
+    if isinstance(proxy, ClassicalScalarProxy):
+        classical_type = proxy._classical_type
+    elif isinstance(proxy, ClassicalArrayProxy):
+        classical_type = ClassicalArray(
+            element_type=proxy._element_type, size=proxy.length
+        )
+    elif isinstance(proxy, ClassicalStructProxy):
+        classical_type = TypeName(name=proxy._decl.name)
+    else:
+        raise ClassiqInternalExpansionError(
+            f"Unrecognized classical proxy {type(proxy).__name__}"
+        )
+    return classical_type

classiq/interface/generator/functions/builtins/internal_operators.py

@@ -2,6 +2,7 @@ CTRL_VAR_PREFIX = "ctrl__"
 CONTROL_OPERATOR_NAME = "control"
 INVERT_OPERATOR_NAME = "invert"
 REPEAT_OPERATOR_NAME = "iteration"
+CLASSICAL_IF_OPERATOR_NAME = "classical_if"
 POWER_OPERATOR_NAME = "power"
 UNCOMPUTE_OPERATOR_NAME = "uncompute"
 WITHIN_APPLY_NAME = "within_apply"

classiq/interface/generator/functions/classical_type.py

@@ -98,7 +98,7 @@ class StructMetaType(ClassicalType):
 class ClassicalArray(ClassicalType):
     kind: Literal["array"]
     element_type: "ConcreteClassicalType"
-    size: pydantic.PositiveInt
+    size: int
 
     @pydantic.model_validator(mode="before")
     @classmethod

classiq/interface/generator/functions/type_name.py

@@ -1,9 +1,11 @@
 from collections.abc import Mapping
+from itertools import chain
 from typing import TYPE_CHECKING, Any, Literal, Optional
 
 import pydantic
 
 from classiq.interface.exceptions import ClassiqExpansionError
+from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.expressions.proxies.classical.classical_proxy import (
     ClassicalProxy,
 )
@@ -97,6 +99,12 @@ class TypeName(ClassicalType, QuantumType):
     def has_classical_struct_decl(self) -> bool:
         return self._classical_struct_decl is not None
 
+    @property
+    def classical_struct_decl(self) -> "StructDeclaration":
+        if self._classical_struct_decl is None:
+            raise ClassiqExpansionError(f"Type {self.name!r} is undefined")
+        return self._classical_struct_decl
+
     def set_classical_struct_decl(self, decl: "StructDeclaration") -> None:
         self._classical_struct_decl = decl
 
@@ -105,6 +113,14 @@ class TypeName(ClassicalType, QuantumType):
             raise ClassiqExpansionError(f"Type {self.name!r} is undefined")
         return ClassicalStructProxy(handle, self._classical_struct_decl)
 
+    @property
+    def expressions(self) -> list[Expression]:
+        return list(
+            chain.from_iterable(
+                field_type.expressions for field_type in self.fields.values()
+            )
+        )
+
 
 class Enum(TypeName):
     pass

classiq/interface/generator/functions/type_qualifier.py

@@ -0,0 +1,7 @@
+from classiq.interface.enum_utils import StrEnum
+
+
+class TypeQualifier(StrEnum):
+    Const = "const"
+    QFree = "qfree"
+    Quantum = "quantum"

classiq/interface/generator/generated_circuit_data.py

@@ -83,7 +83,7 @@ class GeneratedRegister(pydantic.BaseModel):
     @staticmethod
     def demangle_name(name: str) -> str:
         if is_captured_var_name(name):
-            return demangle_capture_name(name)
+            name = demangle_capture_name(name)
         return demangle_name(name)
 
 
@@ -233,6 +233,19 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
             return list()
         return self.generated_function.control_states
 
+    @property
+    def control_qubits(self) -> tuple[int, ...]:
+        control_states_names = {
+            control_state.name for control_state in self.control_states
+        }
+        return tuple(
+            qubit
+            for register in self.registers
+            for qubit in register.qubit_indexes_absolute
+            if register.role is RegisterRole.INPUT
+            and register.name in control_states_names
+        )
+
     def propagate_absolute_qubits(self) -> "FunctionDebugInfoInterface":
         if self.absolute_qubits is None:
             return self

classiq/interface/generator/hardware/hardware_data.py

@@ -110,10 +110,12 @@ class HardwareData(pydantic.BaseModel):
             for gate in specified_basis_gates
             if gate in TWO_QUBIT_GATES and gate not in ROUTING_TWO_QUBIT_BASIS_GATES
         ]
+
         if invalid_gates:
             raise ClassiqValueError(
                 "Connectivity-aware synthesis with non-symmetric coupling map "
-                "is currently supported for the following two-qubit gates only: cx, ecr, rzx."
+                "is currently supported for the following two-qubit gates only: "
+                "cx, ecr, rzx, ryy, rxx, rzz, cy, cp, cz, swap"
             )
 
         return self

classiq/interface/generator/quantum_function_call.py

@@ -40,7 +40,10 @@ from classiq.interface.generator.slice_parsing_utils import (
     SLICING,
     parse_io_slicing,
 )
-from classiq.interface.generator.synthesis_execution_parameter import PydanticPowerType
+from classiq.interface.generator.synthesis_execution_parameter import (
+    ClassicalArg,
+    PydanticPowerType,
+)
 from classiq.interface.generator.user_defined_function_params import CustomFunction
 from classiq.interface.helpers.custom_pydantic_types import PydanticNonEmptyString
 from classiq.interface.helpers.hashable_pydantic_base_model import (
@@ -148,6 +151,10 @@ class SynthesisQuantumFunctionCall(BaseModel):
         description="The name of the function instance. "
         "If not set, determined automatically.",
     )
+    caller_parameters: Optional[list[str]] = pydantic.Field(default=None)
+    parameter_assignments: Optional[dict[str, ClassicalArg]] = pydantic.Field(
+        default=None
+    )
     source_id: Optional[UUID] = pydantic.Field(default=None)
     arithmetic_id: Optional[str] = pydantic.Field(default=None)
     inverse_op_id: Optional[UUID] = pydantic.Field(default=None)

classiq/interface/generator/synthesis_execution_parameter.py

@@ -6,3 +6,4 @@ from classiq.interface.backend.pydantic_backend import PydanticExecutionParamete
 
 PydanticIntSynthesisExecutionParameter = Union[PydanticExecutionParameter, int]
 PydanticPowerType: TypeAlias = PydanticIntSynthesisExecutionParameter
+ClassicalArg = Union[float, str]