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

classiq/interface/model/quantum_function_declaration.py

@@ -2,18 +2,16 @@ from typing import (
     Any,
     ClassVar,
     Dict,
-    List,
     Literal,
-    Mapping,
     Sequence,
     Set,
-    Type,
     Union,
 )
 
 import pydantic
 from typing_extensions import Annotated
 
+from classiq.interface.generator.arith.register_user_input import RegisterUserInput
 from classiq.interface.generator.function_params import ArithmeticIODict, PortDirection
 from classiq.interface.generator.functions.function_declaration import (
     FunctionDeclaration,
@@ -22,218 +20,122 @@ from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
 from classiq.interface.helpers.pydantic_model_helpers import (
-    Nameable,
     values_with_discriminator,
 )
-from classiq.interface.helpers.validation_helpers import (
-    validate_nameables_mapping,
-    validate_nameables_no_overlap,
-)
 from classiq.interface.model.classical_parameter_declaration import (
+    AnonClassicalParameterDeclaration,
     ClassicalParameterDeclaration,
 )
-from classiq.interface.model.port_declaration import PortDeclaration
+from classiq.interface.model.port_declaration import (
+    AnonPortDeclaration,
+    PortDeclaration,
+)
 from classiq.interface.model.quantum_type import quantum_var_to_register
 
-from classiq.exceptions import ClassiqValueError
-
-
-def _is_equiv_kw_and_pos_decl(kw_decl: Nameable, pos_decl: Nameable) -> bool:
-    if isinstance(pos_decl, ClassicalParameterDeclaration):
-        return pos_decl.classical_type == kw_decl
-    return pos_decl == kw_decl
-
-
-def _populate_declaration_dicts_with_positional_lists(
-    pos_decls: Sequence[Nameable],
-    kw_decls: Dict[str, Nameable],
-    param_type: Type[Nameable],
-) -> None:
-    for pos_decl in pos_decls:
-        if not isinstance(pos_decl, param_type):
-            continue
-        kw_decl = kw_decls.get(pos_decl.name)
-        if kw_decl is not None and not _is_equiv_kw_and_pos_decl(kw_decl, pos_decl):
-            raise ClassiqValueError(
-                f"{param_type.__name__} parameter with name {pos_decl.name} already declared"
-            )
-        kw_decls[pos_decl.name] = (
-            pos_decl.classical_type  # type:ignore[assignment]
-            if isinstance(pos_decl, ClassicalParameterDeclaration)
-            else pos_decl
-        )
-
-
-PositionalArg = Annotated[
-    Union[ClassicalParameterDeclaration, "QuantumOperandDeclaration", PortDeclaration],
+AnonPositionalArg = Annotated[
+    Union[
+        AnonClassicalParameterDeclaration,
+        "AnonQuantumOperandDeclaration",
+        AnonPortDeclaration,
+    ],
     pydantic.Field(..., discriminator="kind"),
 ]
 
 
 def _ports_to_registers(
-    port_declarations: Dict[str, PortDeclaration], direction: PortDirection
-) -> ArithmeticIODict:
-    return {
-        name: quantum_var_to_register(name, port_decl.quantum_type)
-        for name, port_decl in port_declarations.items()
+    port_declarations: Sequence[AnonPortDeclaration], direction: PortDirection
+) -> Sequence[RegisterUserInput]:
+    return [
+        quantum_var_to_register(port_decl.get_name(), port_decl.quantum_type)
+        for port_decl in port_declarations
         if port_decl.direction.includes_port_direction(direction)
-    }
+    ]
 
 
-class QuantumFunctionDeclaration(FunctionDeclaration):
+class AnonQuantumFunctionDeclaration(FunctionDeclaration):
     """
     Facilitates the creation of a common quantum function interface object.
     """
 
-    port_declarations: Dict[str, PortDeclaration] = pydantic.Field(
-        description="The input and output ports of the function.",
-        default_factory=dict,
+    positional_arg_declarations: Sequence[AnonPositionalArg] = pydantic.Field(
+        default_factory=list
     )
 
-    operand_declarations: Mapping[str, "QuantumOperandDeclaration"] = pydantic.Field(
-        description="The expected interface of the quantum function operands",
-        default_factory=dict,
-    )
+    @property
+    def port_declarations(self) -> Sequence[AnonPortDeclaration]:
+        return [
+            arg
+            for arg in self.positional_arg_declarations
+            if isinstance(arg, AnonPortDeclaration)
+        ]
 
-    positional_arg_declarations: List[PositionalArg] = pydantic.Field(
-        default_factory=list
-    )
+    @property
+    def operand_declarations(self) -> Sequence["AnonQuantumOperandDeclaration"]:
+        return [
+            arg
+            for arg in self.positional_arg_declarations
+            if isinstance(arg, AnonQuantumOperandDeclaration)
+        ]
 
-    BUILTIN_FUNCTION_DECLARATIONS: ClassVar[Dict[str, "QuantumFunctionDeclaration"]] = (
-        {}
-    )
+    @property
+    def param_decls(self) -> Sequence[AnonClassicalParameterDeclaration]:
+        return [
+            arg
+            for arg in self.positional_arg_declarations
+            if isinstance(arg, AnonClassicalParameterDeclaration)
+        ]
+
+    @property
+    def param_names(self) -> Sequence[str]:
+        return [param.get_name() for param in self.param_decls]
 
     @property
     def input_set(self) -> Set[str]:
-        return set(self.inputs.keys())
+        return {inp.name for inp in self.inputs}
 
     @property
     def output_set(self) -> Set[str]:
-        return set(self.outputs.keys())
+        return {output.name for output in self.outputs}
 
     @property
-    def inputs(self) -> ArithmeticIODict:
+    def inputs(self) -> Sequence[RegisterUserInput]:
         return _ports_to_registers(self.port_declarations, PortDirection.Input)
 
     @property
-    def outputs(self) -> ArithmeticIODict:
+    def outputs(self) -> Sequence[RegisterUserInput]:
         return _ports_to_registers(self.port_declarations, PortDirection.Output)
 
-    def update_logic_flow(
-        self, function_dict: Mapping[str, "QuantumFunctionDeclaration"]
-    ) -> None:
-        pass
-
     @property
-    def port_names(self) -> List[str]:
-        return list(self.port_declarations.keys())
+    def port_names(self) -> Sequence[str]:
+        return [port.get_name() for port in self.port_declarations]
 
     @property
-    def operand_names(self) -> List[str]:
-        return list(self.operand_declarations.keys())
+    def operand_names(self) -> Sequence[str]:
+        return [operand.get_name() for operand in self.operand_declarations]
 
     def ports_by_direction(
         self, direction: PortDirection
-    ) -> Mapping[str, PortDeclaration]:
-        return {
-            name: port
-            for name, port in self.port_declarations.items()
+    ) -> Sequence[AnonPortDeclaration]:
+        return [
+            port
+            for port in self.port_declarations
             if port.direction.includes_port_direction(direction)
-        }
+        ]
 
     def ports_by_declaration_direction(
         self, direction: PortDeclarationDirection
     ) -> Set[str]:
         return {
-            name
-            for name, port in self.port_declarations.items()
+            port.get_name()
+            for port in self.port_declarations
             if port.direction == direction
         }
 
-    def get_positional_arg_decls(self) -> List[PositionalArg]:
-        result: List[PositionalArg] = self.positional_arg_declarations
-        if not result:
-            result = [
-                ClassicalParameterDeclaration(name=name, classical_type=ctype)
-                for name, ctype in self.param_decls.items()
-            ]
-            result.extend(self.operand_declarations.values())
-            result.extend(self.port_declarations.values())
-        return result
-
-    @pydantic.validator("operand_declarations")
-    def _validate_operand_declarations_names(
-        cls, operand_declarations: Dict[str, "QuantumOperandDeclaration"]
-    ) -> Dict[str, "QuantumOperandDeclaration"]:
-        validate_nameables_mapping(operand_declarations, "Operand")
-        return operand_declarations
-
-    @pydantic.validator("port_declarations")
-    def _validate_port_declarations_names(
-        cls, port_declarations: Dict[str, PortDeclaration]
-    ) -> Dict[str, PortDeclaration]:
-        validate_nameables_mapping(port_declarations, "Port")
-        return port_declarations
-
-    @pydantic.root_validator()
-    def _validate_params_and_operands_uniqueness(
-        cls, values: Dict[str, Any]
-    ) -> Dict[str, Any]:
-        operand_declarations = values.get("operand_declarations")
-        parameter_declarations = values.get("param_decls")
-        port_declarations = values.get("port_declarations")
-        operand_parameter = validate_nameables_no_overlap(
-            operand_declarations, parameter_declarations, "operand", "parameter"
-        )
-        operand_port = validate_nameables_no_overlap(
-            operand_declarations, port_declarations, "operand", "port"
-        )
-        parameter_port = validate_nameables_no_overlap(
-            parameter_declarations, port_declarations, "parameter", "port"
-        )
-        error_message = ",".join(
-            msg
-            for msg in [operand_parameter, operand_port, parameter_port]
-            if msg is not None
-        )
-
-        if error_message:
-            raise ClassiqValueError(error_message)
-
-        return values
-
-    @pydantic.root_validator()
-    def _reduce_positional_declarations_to_keyword(
-        cls, values: Dict[str, Any]
-    ) -> Dict[str, Any]:
-        operand_declarations = values.get("operand_declarations", dict())
-        parameter_declarations = values.get("param_decls", dict())
-        port_declarations = values.get("port_declarations", dict())
-
-        positional_arg_declarations = values.get("positional_arg_declarations", list())
-
-        _populate_declaration_dicts_with_positional_lists(
-            positional_arg_declarations,
-            parameter_declarations,
-            ClassicalParameterDeclaration,
-        )
-        _populate_declaration_dicts_with_positional_lists(
-            positional_arg_declarations,
-            operand_declarations,
-            QuantumOperandDeclaration,
-        )
-        _populate_declaration_dicts_with_positional_lists(
-            positional_arg_declarations, port_declarations, PortDeclaration
-        )
-
-        values["operand_declarations"] = operand_declarations
-        values["param_decls"] = parameter_declarations
-        values["port_declarations"] = port_declarations
-
-        return values
-
-
-class QuantumOperandDeclaration(QuantumFunctionDeclaration):
+    def rename(self, new_name: str) -> "QuantumFunctionDeclaration":
+        return QuantumFunctionDeclaration(**{**self.__dict__, "name": new_name})
+
+
+class AnonQuantumOperandDeclaration(AnonQuantumFunctionDeclaration):
     kind: Literal["QuantumOperandDeclaration"]
 
     is_list: bool = pydantic.Field(
@@ -245,5 +147,85 @@ class QuantumOperandDeclaration(QuantumFunctionDeclaration):
     def _set_kind(cls, values: Dict[str, Any]) -> Dict[str, Any]:
         return values_with_discriminator(values, "kind", "QuantumOperandDeclaration")
 
+    def rename(self, new_name: str) -> "QuantumOperandDeclaration":
+        return QuantumOperandDeclaration(**{**self.__dict__, "name": new_name})
+
+
+AnonQuantumFunctionDeclaration.update_forward_refs()
+
+
+class QuantumFunctionDeclaration(AnonQuantumFunctionDeclaration):
+    name: str
+
+    BUILTIN_FUNCTION_DECLARATIONS: ClassVar[
+        Dict[str, "NamedParamsQuantumFunctionDeclaration"]
+    ] = {}
+
+
+class QuantumOperandDeclaration(
+    QuantumFunctionDeclaration, AnonQuantumOperandDeclaration
+):
+    pass
 
-QuantumFunctionDeclaration.update_forward_refs()
+
+PositionalArg = Annotated[
+    Union[
+        ClassicalParameterDeclaration,
+        QuantumOperandDeclaration,
+        PortDeclaration,
+    ],
+    pydantic.Field(..., discriminator="kind"),
+]
+
+
+class NamedParamsQuantumFunctionDeclaration(QuantumFunctionDeclaration):
+
+    positional_arg_declarations: Sequence[PositionalArg] = pydantic.Field(
+        default_factory=list
+    )
+
+    @property
+    def port_declarations_dict(self) -> Dict[str, PortDeclaration]:
+        return {port.name: port for port in self.port_declarations}
+
+    @property
+    def operand_declarations_dict(self) -> Dict[str, QuantumOperandDeclaration]:
+        return {op.name: op for op in self.operand_declarations}
+
+    @property
+    def param_decls_dict(self) -> Dict[str, ClassicalParameterDeclaration]:
+        return {param.name: param for param in self.param_decls}
+
+    @property
+    def inputs_dict(self) -> ArithmeticIODict:
+        return _ports_to_registers_dict(self.port_declarations, PortDirection.Input)
+
+    @property
+    def inouts_dict(self) -> ArithmeticIODict:
+        return _ports_to_registers_dict(self.port_declarations, PortDirection.Inout)
+
+    @property
+    def outputs_dict(self) -> ArithmeticIODict:
+        return _ports_to_registers_dict(self.port_declarations, PortDirection.Output)
+
+    @property
+    def port_declarations(self) -> Sequence[PortDeclaration]:
+        return super().port_declarations  # type:ignore[return-value]
+
+    @property
+    def operand_declarations(self) -> Sequence[QuantumOperandDeclaration]:
+        return super().operand_declarations  # type:ignore[return-value]
+
+    @property
+    def param_decls(self) -> Sequence[ClassicalParameterDeclaration]:
+        return super().param_decls  # type:ignore[return-value]
+
+
+def _ports_to_registers_dict(
+    port_declarations: Sequence[PortDeclaration], direction: PortDirection
+) -> ArithmeticIODict:
+    return {
+        port_decl.name: quantum_var_to_register(port_decl.name, port_decl.quantum_type)
+        for port_decl in port_declarations
+        if port_decl.direction.includes_port_direction(direction)
+    }

classiq/interface/model/quantum_lambda_function.py

@@ -1,12 +1,14 @@
-from typing import TYPE_CHECKING, Dict, List, Optional, Union
+from typing import TYPE_CHECKING, Dict, List, Optional, Union, cast
 
 import pydantic
 
 from classiq.interface.ast_node import ASTNode
 from classiq.interface.model.quantum_function_declaration import (
-    QuantumOperandDeclaration,
+    AnonQuantumOperandDeclaration,
 )
 
+from classiq.exceptions import ClassiqError
+
 if TYPE_CHECKING:
     from classiq.interface.model.statement_block import StatementBlock
 
@@ -18,22 +20,38 @@ class QuantumLambdaFunction(ASTNode):
 
     rename_params: Dict[str, str] = pydantic.Field(
         default_factory=dict,
-        description="Mapping of the declared param to the actual variable name used ",
+    )
+
+    pos_rename_params: List[str] = pydantic.Field(
+        default_factory=list,
+        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)
+    _func_decl: Optional[AnonQuantumOperandDeclaration] = pydantic.PrivateAttr(
+        default=None
+    )
 
     @property
-    def func_decl(self) -> Optional[QuantumOperandDeclaration]:
+    def func_decl(self) -> AnonQuantumOperandDeclaration:
+        if self._func_decl is None:
+            raise ClassiqError("Could not resolve lambda signature.")
         return self._func_decl
 
-    def set_op_decl(self, fd: QuantumOperandDeclaration) -> None:
+    def set_op_decl(self, fd: AnonQuantumOperandDeclaration) -> None:
         self._func_decl = fd
 
+    def get_rename_params(self) -> List[str]:
+        if self.pos_rename_params:
+            return self.pos_rename_params
+        return [
+            self.rename_params.get(cast(str, param.name), cast(str, param.name))
+            for param in self.func_decl.positional_arg_declarations
+        ]
+
 
 QuantumCallable = Union[str, QuantumLambdaFunction]
 QuantumOperand = Union[QuantumCallable, List[QuantumCallable]]

classiq/interface/model/quantum_statement.py

@@ -1,13 +1,13 @@
-from typing import Any, Dict, Mapping, Union
+from dataclasses import dataclass
+from typing import Any, Dict, Mapping, Optional, Sequence
 
 from pydantic import Extra, root_validator
 
 from classiq.interface.ast_node import ASTNode
 from classiq.interface.helpers.pydantic_model_helpers import values_with_discriminator
 from classiq.interface.model.handle_binding import (
+    ConcreteHandleBinding,
     HandleBinding,
-    SlicedHandleBinding,
-    SubscriptHandleBinding,
 )
 
 
@@ -22,19 +22,45 @@ class QuantumStatement(ASTNode):
         return values_with_discriminator(values, "kind", cls.__name__)  # type: ignore[attr-defined]
 
 
+@dataclass
+class HandleMetadata:
+    handle: HandleBinding
+    readable_location: Optional[str] = None
+
+
 class QuantumOperation(QuantumStatement):
     @property
     def wiring_inputs(self) -> Mapping[str, HandleBinding]:
         return dict()
 
     @property
-    def wiring_inouts(
-        self,
-    ) -> Mapping[
-        str, Union[SlicedHandleBinding, SubscriptHandleBinding, HandleBinding]
-    ]:
+    def inputs(self) -> Sequence[HandleBinding]:
+        return list(self.wiring_inputs.values())
+
+    @property
+    def wiring_inouts(self) -> Mapping[str, ConcreteHandleBinding]:
         return dict()
 
+    @property
+    def inouts(self) -> Sequence[HandleBinding]:
+        return list(self.wiring_inouts.values())
+
     @property
     def wiring_outputs(self) -> Mapping[str, HandleBinding]:
         return dict()
+
+    @property
+    def outputs(self) -> Sequence[HandleBinding]:
+        return list(self.wiring_outputs.values())
+
+    @property
+    def readable_inputs(self) -> Sequence[HandleMetadata]:
+        return [HandleMetadata(handle=handle) for handle in self.inputs]
+
+    @property
+    def readable_inouts(self) -> Sequence[HandleMetadata]:
+        return [HandleMetadata(handle=handle) for handle in self.inouts]
+
+    @property
+    def readable_outputs(self) -> Sequence[HandleMetadata]:
+        return [HandleMetadata(handle=handle) for handle in self.outputs]

classiq/interface/model/quantum_type.py

@@ -1,8 +1,7 @@
-from typing import Any, Dict, Literal, Optional, Union
+from typing import TYPE_CHECKING, Any, Dict, Literal, Optional
 
 import pydantic
-from pydantic import Extra, Field
-from typing_extensions import Annotated
+from pydantic import BaseModel, Extra, Field
 
 from classiq.interface.ast_node import HashableASTNode
 from classiq.interface.generator.arith.register_user_input import (
@@ -22,6 +21,11 @@ from classiq.interface.model.handle_binding import HandleBinding
 
 from classiq.exceptions import ClassiqValueError
 
+if TYPE_CHECKING:
+    from classiq.interface.generator.functions.concrete_types import ConcreteQuantumType
+
+    from classiq.qmod.qmod_variable import QArray, QBit, QNum, QVar
+
 
 class QuantumType(HashableASTNode):
     class Config:
@@ -56,7 +60,10 @@ class QuantumType(HashableASTNode):
 
     @property
     def type_name(self) -> str:
-        return self.get_proxy(HandleBinding(name="DUMMY")).type_name
+        raise NotImplementedError
+
+    def to_qvar(self, origin: HandleBinding) -> "QVar":
+        raise NotImplementedError
 
 
 class QuantumScalar(QuantumType):
@@ -82,6 +89,15 @@ class QuantumBit(QuantumScalar):
     def get_proxy(self, handle: "HandleBinding") -> QmodQBitProxy:
         return QmodQBitProxy(handle)
 
+    @property
+    def type_name(self) -> str:
+        return "Quantum bit"
+
+    def to_qvar(self, origin: HandleBinding) -> "QBit":
+        from classiq.qmod.qmod_variable import QBit
+
+        return QBit(origin)
+
 
 class QuantumBitvector(QuantumType):
     kind: Literal["qvec"]
@@ -120,7 +136,7 @@ class QuantumBitvector(QuantumType):
         assert self.size_in_bits % element_size == 0
         return QmodQArrayProxy(
             handle,
-            self.element_type.get_proxy,
+            self.element_type,
             element_size,
             self.size_in_bits // element_size,
         )
@@ -131,6 +147,15 @@ class QuantumBitvector(QuantumType):
         length = [self.length.expr] if self.length is not None else []
         return f"QArray[{', '.join(element_type + length)}]"
 
+    @property
+    def type_name(self) -> str:
+        return "Quantum array"
+
+    def to_qvar(self, origin: HandleBinding) -> "QArray":
+        from classiq.qmod.qmod_variable import QArray
+
+        return QArray(origin, element_type=self.element_type, length=self.length)
+
 
 class QuantumNumeric(QuantumScalar):
     kind: Literal["qnum"]
@@ -193,12 +218,29 @@ class QuantumNumeric(QuantumScalar):
             return f"QNum[{self.size.expr}, {self.is_signed.expr}, {self.fraction_digits.expr}]"
         return "QNum"
 
+    @property
+    def type_name(self) -> str:
+        return "Quantum numeric"
+
+    def to_qvar(self, origin: HandleBinding) -> "QNum":
+        from classiq.qmod.qmod_variable import QNum
+
+        return QNum(origin, self.size, self.is_signed, self.fraction_digits)
+
+
+class RegisterQuantumType(BaseModel):
+    quantum_types: "ConcreteQuantumType"
+    size: int = Field(default=1)
 
-ConcreteQuantumType = Annotated[
-    Union[QuantumBit, QuantumBitvector, QuantumNumeric],
-    Field(discriminator="kind", default_factory=QuantumBitvector),
-]
-QuantumBitvector.update_forward_refs()
+    @property
+    def qmod_type_name(self) -> str:
+        try:
+            return self.quantum_types.qmod_type_name.split("[")[0]
+        except AttributeError:
+            return "default"
+
+
+RegisterQuantumTypeDict = Dict[str, RegisterQuantumType]
 
 
 def register_info_to_quantum_type(reg_info: RegisterArithmeticInfo) -> QuantumNumeric:
@@ -225,3 +267,12 @@ def quantum_var_to_register(name: str, qtype: QuantumType) -> RegisterUserInput:
         is_signed=signed,
         fraction_places=fraction_places,
     )
+
+
+def quantum_type_to_register_quantum_type(
+    qtype: QuantumType, size: int
+) -> RegisterQuantumType:
+    return RegisterQuantumType(
+        quantum_types=qtype,
+        size=size,
+    )

classiq/interface/model/quantum_variable_declaration.py

@@ -4,8 +4,8 @@ import pydantic
 
 from classiq.interface.ast_node import ASTNode
 from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.functions.concrete_types import ConcreteQuantumType
 from classiq.interface.model.quantum_type import (
-    ConcreteQuantumType,
     QuantumBitvector,
     QuantumNumeric,
 )

classiq/interface/model/statement_block.py

@@ -8,6 +8,7 @@ from classiq.interface.model.classical_if import ClassicalIf
 from classiq.interface.model.control import Control
 from classiq.interface.model.inplace_binary_operation import InplaceBinaryOperation
 from classiq.interface.model.invert import Invert
+from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.power import Power
 from classiq.interface.model.quantum_expressions.amplitude_loading_operation import (
     AmplitudeLoadingOperation,
@@ -50,3 +51,4 @@ Power.update_forward_refs(StatementBlock=StatementBlock)
 Invert.update_forward_refs(StatementBlock=StatementBlock)
 WithinApply.update_forward_refs(StatementBlock=StatementBlock)
 ClassicalIf.update_forward_refs(StatementBlock=StatementBlock)
+NativeFunctionDefinition.update_forward_refs(StatementBlock=StatementBlock)

classiq/interface/model/validation_handle.py

@@ -12,6 +12,13 @@ class HandleState(Enum):
     UNINITIALIZED = 1
     ERRORED = 2
 
+    def __invert__(self) -> "HandleState":
+        if self == HandleState.INITIALIZED:
+            return HandleState.UNINITIALIZED
+        if self == HandleState.UNINITIALIZED:
+            return HandleState.INITIALIZED
+        return self
+
 
 @dataclasses.dataclass
 class ValidationHandle: