classiq 0.37.1__py3-none-any.whl → 0.39.0__py3-none-any.whl

classiq/interface/model/native_function_definition.py

@@ -1,11 +1,9 @@
-from typing import List
-
 import pydantic
 
-from classiq.interface.model.quantum_function_call import ConcreteQuantumStatement
 from classiq.interface.model.quantum_function_declaration import (
     QuantumFunctionDeclaration,
 )
+from classiq.interface.model.statement_block import StatementBlock
 from classiq.interface.model.validations.handles_validator import HandleValidator
 from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
@@ -22,7 +20,7 @@ class NativeFunctionDefinition(QuantumFunctionDeclaration):
     objects from other classes.
     """
 
-    body: List[ConcreteQuantumStatement] = pydantic.Field(
+    body: StatementBlock = pydantic.Field(
         default_factory=list, description="List of function calls to perform."
     )
 
@@ -33,6 +31,6 @@ class NativeFunctionDefinition(QuantumFunctionDeclaration):
             if isinstance(statement, VariableDeclarationStatement):
                 handle_validator.handle_variable_declaration(statement)
             else:
-                handle_validator.handle_call(statement)
+                handle_validator.handle_operation(statement)
 
         handle_validator.report_errored_handles(ClassiqValueError)

classiq/interface/model/power.py

@@ -0,0 +1,12 @@
+from typing import TYPE_CHECKING
+
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.model.quantum_statement import QuantumOperation
+
+if TYPE_CHECKING:
+    from classiq.interface.model.statement_block import StatementBlock
+
+
+class Power(QuantumOperation):
+    power: Expression
+    body: "StatementBlock"

classiq/interface/model/quantum_expressions/amplitude_loading_operation.py

@@ -36,9 +36,14 @@ class AmplitudeLoadingOperation(QuantumAssignmentOperation):
     ) -> Mapping[
         str, Union[SlicedHandleBinding, SubscriptHandleBinding, HandleBinding]
     ]:
-        if len(self.var_handles) == 0:
-            return dict()
-        return {AMPLITUDE_IO_NAME: self.var_handles[0]}
+        inouts = {self.result_name(): self.result_var}
+        if len(self.var_handles) == 1:
+            inouts[AMPLITUDE_IO_NAME] = self.var_handles[0]
+        return inouts
+
+    @property
+    def wiring_outputs(self) -> Mapping[str, HandleBinding]:
+        return {}
 
     def initialize_var_types(
         self,
@@ -50,7 +55,7 @@ class AmplitudeLoadingOperation(QuantumAssignmentOperation):
         var_type = var_types[self.var_handles[0].name]
         if not (
             isinstance(var_type, QuantumNumeric)
-            and var_type.fraction_digits == var_type.size_in_bits
+            and var_type.fraction_digits_value == var_type.size_in_bits
         ):
             raise ClassiqValueError(VAR_DOMAIN_ILLEGAL)
         super().initialize_var_types(var_types, machine_precision)

classiq/interface/model/quantum_expressions/control_state.py

@@ -4,7 +4,7 @@ from classiq.exceptions import ClassiqValueError
 def min_unsigned_bit_length(number: int) -> int:
     if number < 0:
         raise ClassiqValueError(
-            f"Quantum register is not signed but control value "  # noqa: B907
+            f"Quantum register is not signed but control value "
             f"'{number}' is negative"
         )
     return 1 if number == 0 else number.bit_length()
@@ -28,7 +28,7 @@ def to_twos_complement(value: int, bits: int, is_signed: bool) -> str:
     required_bits = min_bit_length(value, is_signed)
     if bits < required_bits:
         raise ClassiqValueError(
-            f"Cannot express '{value}' using {bits} bits: "  # noqa: B907
+            f"Cannot express '{value}' using {bits} bits: "
             f"at least {required_bits} bits are required"
         )
     if value >= 0:

classiq/interface/model/quantum_function_call.py

@@ -1,49 +1,35 @@
 import itertools
 import re
-from typing import Any, Dict, List, Mapping, Optional, Sequence, Set, Union
+from typing import Any, Dict, List, Mapping, Optional, Set, Type, Union
 
 import pydantic
-from pydantic import BaseModel
 
+from classiq.interface.ast_node import ASTNode
 from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.function_params import NAME_REGEX
-from classiq.interface.generator.functions import FunctionDeclaration
+from classiq.interface.generator.functions.function_declaration import (
+    FunctionDeclaration,
+)
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
-from classiq.interface.generator.quantum_function_call import (
-    BAD_CALL_NAME_ERROR_MSG,
-    SUFFIX_MARKER,
-    randomize_suffix,
-)
-from classiq.interface.helpers.custom_pydantic_types import PydanticNonEmptyString
-from classiq.interface.model.bind_operation import BindOperation
+from classiq.interface.model.call_synthesis_data import CallSynthesisData
 from classiq.interface.model.handle_binding import (
     HandleBinding,
     SlicedHandleBinding,
     SubscriptHandleBinding,
 )
-from classiq.interface.model.inplace_binary_operation import InplaceBinaryOperation
-from classiq.interface.model.numeric_reinterpretation import (
-    NumericReinterpretationOperation,
-)
-from classiq.interface.model.operator_synthesis_data import OperatorSynthesisData
-from classiq.interface.model.quantum_expressions.amplitude_loading_operation import (
-    AmplitudeLoadingOperation,
-)
-from classiq.interface.model.quantum_expressions.arithmetic_operation import (
-    ArithmeticOperation,
-)
 from classiq.interface.model.quantum_function_declaration import (
     QuantumFunctionDeclaration,
     QuantumOperandDeclaration,
 )
-from classiq.interface.model.quantum_if_operation import QuantumIfOperation
+from classiq.interface.model.quantum_lambda_function import (
+    LambdaListComprehension,
+    QuantumCallable,
+    QuantumLambdaFunction,
+    QuantumOperand,
+)
 from classiq.interface.model.quantum_statement import QuantumOperation
 from classiq.interface.model.validation_handle import get_unique_handle_names
-from classiq.interface.model.variable_declaration_statement import (
-    VariableDeclarationStatement,
-)
 
 from classiq.exceptions import ClassiqError, ClassiqValueError
 
@@ -91,8 +77,13 @@ def _validate_no_duplicated_handles(
 def _validate_no_mixing_sliced_and_whole_handles(
     inouts: Mapping[str, HandleBinding],
 ) -> None:
+    def _treat_subscript_as_slice(type_: Type[HandleBinding]) -> Type[HandleBinding]:
+        if type_ == SubscriptHandleBinding:
+            return SlicedHandleBinding
+        return type_
+
     inout_handle_names_to_types = {
-        handle_name: {type(handle) for handle in handles}
+        handle_name: {_treat_subscript_as_slice(type(handle)) for handle in handles}
         for handle_name, handles in itertools.groupby(
             inouts.values(), lambda handle: handle.name
         )
@@ -108,10 +99,16 @@ def _validate_no_mixing_sliced_and_whole_handles(
         )
 
 
-ArgValue = Union[Expression, "QuantumOperand", SlicedHandleBinding, HandleBinding]
+ArgValue = Union[
+    Expression,
+    QuantumOperand,
+    SlicedHandleBinding,
+    SubscriptHandleBinding,
+    HandleBinding,
+]
 
 
-class OperandIdentifier(BaseModel):
+class OperandIdentifier(ASTNode):
     name: str
     index: Expression
 
@@ -121,13 +118,6 @@ class QuantumFunctionCall(QuantumOperation):
         description="The function that is called"
     )
     params: Dict[str, Expression] = pydantic.Field(default_factory=dict)
-    release_by_inverse: bool = pydantic.Field(
-        default=False, description="Release zero inputs in inverse call."
-    )
-    should_control: bool = pydantic.Field(
-        default=True,
-        description="False value indicates this call shouldn't be controlled even if the flow is controlled.",
-    )
     inputs: Dict[str, HandleBinding] = pydantic.Field(
         default_factory=dict,
         description="A mapping from the input name to the wire it connects to",
@@ -142,12 +132,7 @@ class QuantumFunctionCall(QuantumOperation):
         default_factory=dict,
         description="A mapping from the output name to the wire it connects to",
     )
-    name: PydanticNonEmptyString = pydantic.Field(
-        default=None,
-        description="The name of the function instance. "
-        "If not set, determined automatically.",
-    )
-    operands: Dict[str, "QuantumOperand"] = pydantic.Field(
+    operands: Dict[str, QuantumOperand] = pydantic.Field(
         description="Function calls passed to the operator",
         default_factory=dict,
     )
@@ -157,8 +142,8 @@ class QuantumFunctionCall(QuantumOperation):
         default=None
     )
 
-    _operator_synthesis_data: OperatorSynthesisData = pydantic.PrivateAttr(
-        default_factory=OperatorSynthesisData
+    _synthesis_data: CallSynthesisData = pydantic.PrivateAttr(
+        default_factory=CallSynthesisData
     )
 
     @property
@@ -207,33 +192,6 @@ class QuantumFunctionCall(QuantumOperation):
             result.extend(self.outputs.values())
         return result
 
-    def __eq__(self, other: Any) -> bool:
-        return isinstance(other, QuantumFunctionCall) and self.name == other.name
-
-    def __hash__(self) -> int:
-        return hash(self.name)
-
-    @pydantic.validator("name", pre=True, always=True)
-    def _create_name(cls, name: Optional[str], values: Dict[str, Any]) -> str:
-        """
-        generates a name to a user defined-functions as follows:
-        <function_name>_<SUFFIX_MARKER>_<random_suffix>
-        """
-        if name is not None:
-            match = re.fullmatch(pattern=NAME_REGEX, string=name)
-            if match is None:
-                raise ValueError(BAD_CALL_NAME_ERROR_MSG)
-            return name
-
-        function = values.get("function")
-        if isinstance(function, OperandIdentifier):
-            function = function.name
-
-        suffix = f"{SUFFIX_MARKER}_{randomize_suffix()}"
-        if not function:
-            return name if name else suffix
-        return f"{function}_{suffix}"
-
     @property
     def pos_param_args(self) -> Dict[str, Expression]:
         return dict(
@@ -324,17 +282,11 @@ class QuantumFunctionCall(QuantumOperation):
                     qlambda.set_op_decl(op_decl)
 
     @property
-    def operator_synthesis_data(self) -> OperatorSynthesisData:
-        return self._operator_synthesis_data
-
-    def set_operator_synthesis_data(
-        self, operator_synthesis_data: OperatorSynthesisData
-    ) -> None:
-        self._operator_synthesis_data = operator_synthesis_data
+    def synthesis_data(self) -> CallSynthesisData:
+        return self._synthesis_data
 
-    @staticmethod
-    def _has_repetitions(name_list: Sequence[str]) -> bool:
-        return len(set(name_list)) < len(name_list)
+    def merge_synthesis_data(self, other: CallSynthesisData) -> None:
+        self._synthesis_data = self._synthesis_data.merge(other)
 
     @pydantic.root_validator()
     def validate_handles(cls, values: Dict[str, Any]) -> Dict[str, Any]:
@@ -349,67 +301,6 @@ class QuantumFunctionCall(QuantumOperation):
         return values
 
 
-ConcreteQuantumStatement = Union[
-    QuantumFunctionCall,
-    ArithmeticOperation,
-    AmplitudeLoadingOperation,
-    VariableDeclarationStatement,
-    BindOperation,
-    NumericReinterpretationOperation,
-    InplaceBinaryOperation,
-    QuantumIfOperation,
-]
-
-
-class QuantumLambdaFunction(BaseModel):
-    """
-    The definition of an anonymous function passed as operand to higher-level functions
-    """
-
-    rename_params: Dict[str, str] = pydantic.Field(
-        default_factory=dict,
-        description="Mapping of the declared param to the actual variable name used ",
-    )
-
-    body: List[ConcreteQuantumStatement] = pydantic.Field(
-        description="A list of function calls passed to the operator"
-    )
-
-    _func_decl: Optional[QuantumOperandDeclaration] = pydantic.PrivateAttr(default=None)
-
-    @property
-    def func_decl(self) -> Optional[QuantumOperandDeclaration]:
-        return self._func_decl
-
-    def set_op_decl(self, fd: QuantumOperandDeclaration) -> None:
-        self._func_decl = fd
-
-
-class LambdaListComprehension(BaseModel):
-    """
-    Specification of a list of lambda functions iteratively
-    """
-
-    count: Expression = pydantic.Field(
-        description="The number of lambda functions in the list"
-    )
-
-    index_var: str = pydantic.Field(
-        description="The name of the integer variable holding the iteration index"
-    )
-
-    func: QuantumLambdaFunction = pydantic.Field(
-        description="A lambda function definition replicated for index values 0 to count-1"
-    )
-
-
-QuantumCallable = Union[str, QuantumLambdaFunction]
-QuantumOperand = Union[QuantumCallable, List[QuantumCallable], LambdaListComprehension]
-
-QuantumFunctionCall.update_forward_refs()
-QuantumIfOperation.update_forward_refs(QuantumOperand=QuantumOperand)
-
-
 def get_lambda_defs(operand: QuantumOperand) -> List[QuantumCallable]:
     if isinstance(operand, list):
         return operand

classiq/interface/model/quantum_function_declaration.py

@@ -108,6 +108,14 @@ class QuantumFunctionDeclaration(FunctionDeclaration):
     ) -> None:
         pass
 
+    @property
+    def port_names(self) -> List[str]:
+        return list(self.port_declarations.keys())
+
+    @property
+    def operand_names(self) -> List[str]:
+        return list(self.operand_declarations.keys())
+
     def ports_by_direction(
         self, direction: PortDirection
     ) -> Mapping[str, PortDeclaration]:

classiq/interface/model/quantum_if_operation.py

@@ -5,7 +5,7 @@ from sympy import Equality
 from sympy.core.numbers import Integer
 
 from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.expressions.qmod_qnum_proxy import QmodQNumProxy
+from classiq.interface.generator.expressions.qmod_qscalar_proxy import QmodQNumProxy
 from classiq.interface.model.quantum_expressions.control_state import (
     min_bit_length,
     to_twos_complement,
@@ -17,8 +17,7 @@ from classiq.interface.model.quantum_expressions.quantum_expression import (
 from classiq.exceptions import ClassiqValueError
 
 if TYPE_CHECKING:
-    from classiq.interface.model.quantum_function_call import QuantumOperand
-
+    from classiq.interface.model.statement_block import StatementBlock
 
 QUANTUM_IF_INOUT_NAME = "ctrl"
 QUANTUM_IF_CONDITION_ARG_ERROR_MESSAGE_FORMAT = (
@@ -27,8 +26,8 @@ QUANTUM_IF_CONDITION_ARG_ERROR_MESSAGE_FORMAT = (
 )
 
 
-class QuantumIfOperation(QuantumExpressionOperation):
-    then: "QuantumOperand"
+class QuantumIf(QuantumExpressionOperation):
+    then: "StatementBlock"
     _ctrl: Optional[QmodQNumProxy] = pydantic.PrivateAttr(
         default=None,
     )

classiq/interface/model/quantum_lambda_function.py

@@ -0,0 +1,58 @@
+from typing import TYPE_CHECKING, Dict, List, Optional, Union
+
+import pydantic
+
+from classiq.interface.ast_node import ASTNode
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.model.quantum_function_declaration import (
+    QuantumOperandDeclaration,
+)
+
+if TYPE_CHECKING:
+    from classiq.interface.model.statement_block import StatementBlock
+
+
+class QuantumLambdaFunction(ASTNode):
+    """
+    The definition of an anonymous function passed as operand to higher-level functions
+    """
+
+    rename_params: Dict[str, str] = pydantic.Field(
+        default_factory=dict,
+        description="Mapping of the declared param to the actual variable name used ",
+    )
+
+    body: "StatementBlock" = pydantic.Field(
+        description="A list of function calls passed to the operator"
+    )
+
+    _func_decl: Optional[QuantumOperandDeclaration] = pydantic.PrivateAttr(default=None)
+
+    @property
+    def func_decl(self) -> Optional[QuantumOperandDeclaration]:
+        return self._func_decl
+
+    def set_op_decl(self, fd: QuantumOperandDeclaration) -> None:
+        self._func_decl = fd
+
+
+class LambdaListComprehension(ASTNode):
+    """
+    Specification of a list of lambda functions iteratively
+    """
+
+    count: Expression = pydantic.Field(
+        description="The number of lambda functions in the list"
+    )
+
+    index_var: str = pydantic.Field(
+        description="The name of the integer variable holding the iteration index"
+    )
+
+    func: QuantumLambdaFunction = pydantic.Field(
+        description="A lambda function definition replicated for index values 0 to count-1"
+    )
+
+
+QuantumCallable = Union[str, QuantumLambdaFunction]
+QuantumOperand = Union[QuantumCallable, List[QuantumCallable], LambdaListComprehension]

classiq/{quantum_register.py → interface/model/quantum_register.py}

@@ -1,7 +1,15 @@
 import itertools
 import sys
-from typing import _GenericAlias  # type: ignore[attr-defined]
-from typing import Any, Dict, List, Optional, Type, Union
+from typing import (  # type: ignore[attr-defined]
+    Any,
+    Dict,
+    Iterator,
+    List,
+    Optional,
+    Type,
+    Union,
+    _GenericAlias,
+)
 
 from classiq.interface.generator.arith.register_user_input import (
     RegisterArithmeticInfo,
@@ -19,7 +27,7 @@ if sys.version_info >= (3, 9):
 # This class is used for QReg, to support type-hint initialization
 #   Due to the `size` property of QReg
 class QRegGenericAlias(_GenericAlias, _root=True):  # type: ignore[call-arg]
-    def __call__(self, *args, **kwargs):
+    def __call__(self, *args: Any, **kwargs: Any) -> Any:
         arith_info = {}
         if self.size is not None:
             arith_info["size"] = self.size
@@ -48,13 +56,13 @@ class QRegGenericAlias(_GenericAlias, _root=True):  # type: ignore[call-arg]
 
     @property
     def integer_places(self) -> Optional[int]:
-        if len(self.__args__) in (1, 2) and type(self.__args__[0]) is int:
+        if len(self.__args__) in (1, 2) and isinstance(self.__args__[0], int):
             return self.__args__[0]
         return None
 
     @property
     def fraction_places(self) -> Optional[int]:
-        if len(self.__args__) == 2 and type(self.__args__[1]) is int:
+        if len(self.__args__) == 2 and isinstance(self.__args__[1], int):
             return self.__args__[1]
         return None
 
@@ -102,7 +110,7 @@ class QReg:
             )
         self._qubits[key] = value._qubits[0] if isinstance(key, int) else value._qubits  # type: ignore[call-overload]
 
-    def __iter__(self):
+    def __iter__(self) -> Iterator["QReg"]:
         return iter([self[idx] for idx in range(len(self))])
 
     def __eq__(self, other: Any) -> bool:
@@ -136,7 +144,7 @@ class QReg:
 
     def __class_getitem__(cls, params: Any) -> QRegGenericAlias:
         # Supporting python 3.7+, thus returning `typing._GenericAlias` instead of `types.GenericAlias`
-        if type(params) is int:
+        if isinstance(params, int):
             return QRegGenericAlias(cls, params)
 
         raise ClassiqQRegError(f"Invalid size: {params} ; int required")
@@ -171,8 +179,8 @@ class QSFixed(QReg):
         if (
             type(params) is tuple
             and len(params) == 2
-            and type(params[0]) is int
-            and type(params[1]) is int
+            and isinstance(params[0], int)
+            and isinstance(params[1], int)
         ):
             return QRegGenericAlias(cls, params)
 

classiq/interface/model/quantum_statement.py

@@ -1,7 +1,8 @@
 from typing import Mapping, Union
 
-from pydantic import BaseModel, Extra
+from pydantic import Extra
 
+from classiq.interface.ast_node import ASTNode
 from classiq.interface.model.handle_binding import (
     HandleBinding,
     SlicedHandleBinding,
@@ -9,7 +10,7 @@ from classiq.interface.model.handle_binding import (
 )
 
 
-class QuantumStatement(BaseModel):
+class QuantumStatement(ASTNode):
     class Config:
         extra = Extra.forbid