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

classiq/interface/model/quantum_type.py

@@ -1,22 +1,26 @@
 from typing import Any, Dict, Literal, Optional, Union
 
 import pydantic
-from pydantic import Extra
+from pydantic import Extra, Field
+from typing_extensions import Annotated
 
+from classiq.interface.ast_node import HashableASTNode
 from classiq.interface.generator.arith.register_user_input import (
     RegisterArithmeticInfo,
     RegisterUserInput,
 )
 from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.helpers.hashable_pydantic_base_model import (
-    HashablePydanticBaseModel,
+from classiq.interface.generator.expressions.qmod_qscalar_proxy import (
+    QmodQNumProxy,
+    QmodQScalarProxy,
 )
+from classiq.interface.generator.expressions.qmod_sized_proxy import QmodSizedProxy
 from classiq.interface.helpers.pydantic_model_helpers import values_with_discriminator
 
 from classiq.exceptions import ClassiqValueError
 
 
-class QuantumType(HashablePydanticBaseModel):
+class QuantumType(HashableASTNode):
     class Config:
         extra = Extra.forbid
 
@@ -40,8 +44,16 @@ class QuantumType(HashablePydanticBaseModel):
     def set_size_in_bits(self, val: int) -> None:
         self._size_in_bits = val
 
+    def get_proxy(self, name: str) -> QmodSizedProxy:
+        return QmodSizedProxy(size=self.size_in_bits)
 
-class QuantumBit(QuantumType):
+
+class QuantumScalar(QuantumType):
+    def get_proxy(self, name: str) -> QmodQScalarProxy:
+        return QmodQScalarProxy(name, size=self.size_in_bits)
+
+
+class QuantumBit(QuantumScalar):
     kind: Literal["qbit"]
 
     def __init__(self, **kwargs: Any) -> None:
@@ -69,83 +81,69 @@ class QuantumBitvector(QuantumArray):
             self._size_in_bits = self.length.to_int_value()
 
 
-class QuantumNumeric(QuantumType):
+class QuantumNumeric(QuantumScalar):
+    kind: Literal["qnum"]
+
     size: Optional[Expression] = pydantic.Field()
-    kind: str = pydantic.Field()
+    is_signed: Optional[Expression] = pydantic.Field()
+    fraction_digits: Optional[Expression] = pydantic.Field()
 
     @pydantic.root_validator(pre=True)
     def _set_kind(cls, values: Dict[str, Any]) -> Dict[str, Any]:
         return values_with_discriminator(values, "kind", "qnum")
 
-    _is_signed: bool = pydantic.PrivateAttr(default=False)
-
-    _fraction_digits: int = pydantic.PrivateAttr(default=0)
+    @pydantic.root_validator
+    def _validate_fields(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        has_sign = values["is_signed"] is not None
+        has_fraction_digits = values["fraction_digits"] is not None
+        if has_sign and not has_fraction_digits or not has_sign and has_fraction_digits:
+            raise ClassiqValueError(
+                "Assign neither or both of is_signed and fraction_digits"
+            )
+        return values
 
     @property
-    def size_in_bits_expr(self) -> Optional[Expression]:
-        return self.size
+    def has_sign(self) -> bool:
+        return self.is_signed is not None
 
     @property
-    def is_signed(self) -> bool:
-        return self._is_signed
-
-    def set_signed(self, val: bool) -> None:
-        self._is_signed = val
+    def sign_value(self) -> bool:
+        return False if self.is_signed is None else self.is_signed.to_bool_value()
 
     @property
-    def fraction_digits(self) -> int:
-        return self._fraction_digits
+    def has_fraction_digits(self) -> bool:
+        return self.fraction_digits is not None
 
-    def set_fraction_digits(self, val: int) -> None:
-        self._fraction_digits = val
+    @property
+    def fraction_digits_value(self) -> int:
+        return (
+            0 if self.fraction_digits is None else self.fraction_digits.to_int_value()
+        )
 
     def _update_size_in_bits_from_declaration(self) -> None:
         if self.size is not None and self.size.is_evaluated():
             self._size_in_bits = self.size.to_int_value()
 
-
-class QuantumInteger(QuantumNumeric):
-    kind: Literal["qint"]
-
-    @pydantic.root_validator(pre=True)
-    def _set_kind(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        return values_with_discriminator(values, "kind", "qint")
-
-
-class QuantumFixedReal(QuantumNumeric):
-    fraction_places: Expression = pydantic.Field()
-
-    kind: Literal["qfixed"]
-
-    @pydantic.root_validator(pre=True)
-    def _set_kind(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        return values_with_discriminator(values, "kind", "qfixed")
-
-    @property
-    def fraction_digits(self) -> int:
-        return self.fraction_places.to_int_value()
-
-    def set_fraction_digits(self, val: int) -> None:
-        if val != self.fraction_places.to_int_value():
-            raise ClassiqValueError(
-                "Cannot assign value of fixed-point number with incompatible fraction digits"
-            )
+    def get_proxy(self, name: str) -> QmodQNumProxy:
+        return QmodQNumProxy(
+            name,
+            size=self.size_in_bits,
+            fraction_digits=self.fraction_digits_value,
+            is_signed=self.sign_value,
+        )
 
 
-ConcreteQuantumType = Union[
-    QuantumBit,
-    QuantumBitvector,
-    QuantumNumeric,
-    QuantumInteger,
-    QuantumFixedReal,
+ConcreteQuantumType = Annotated[
+    Union[QuantumBit, QuantumBitvector, QuantumNumeric],
+    Field(discriminator="kind", default_factory=QuantumBitvector),
 ]
 
 
 def register_info_to_quantum_type(reg_info: RegisterArithmeticInfo) -> QuantumNumeric:
     result = QuantumNumeric()
     result.set_size_in_bits(reg_info.size)
-    result.set_signed(reg_info.is_signed)
-    result.set_fraction_digits(reg_info.fraction_places)
+    result.is_signed = Expression(expr=str(reg_info.is_signed))
+    result.fraction_digits = Expression(expr=str(reg_info.fraction_places))
     return result
 
 
@@ -153,10 +151,11 @@ UNRESOLVED_SIZE = 1000
 
 
 def quantum_var_to_register(name: str, qtype: QuantumType) -> RegisterUserInput:
-    signed = qtype.is_signed if isinstance(qtype, QuantumNumeric) else False
-    if isinstance(qtype, (QuantumFixedReal, QuantumNumeric)):
-        fraction_places = qtype.fraction_digits
+    if isinstance(qtype, QuantumNumeric):
+        signed = qtype.sign_value
+        fraction_places = qtype.fraction_digits_value
     else:
+        signed = False
         fraction_places = 0
     return RegisterUserInput(
         name=name,

classiq/interface/model/quantum_variable_declaration.py

@@ -1,8 +1,8 @@
 from typing import Any, Mapping, Optional
 
 import pydantic
-from pydantic import BaseModel
 
+from classiq.interface.ast_node import ASTNode
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.model.quantum_type import (
     ConcreteQuantumType,
@@ -11,9 +11,9 @@ from classiq.interface.model.quantum_type import (
 )
 
 
-class QuantumVariableDeclaration(BaseModel):
+class QuantumVariableDeclaration(ASTNode):
     name: str
-    quantum_type: ConcreteQuantumType = pydantic.Field(default_factory=QuantumBitvector)
+    quantum_type: ConcreteQuantumType
     size: Optional[Expression] = pydantic.Field(default=None)
 
     @pydantic.validator("size")

classiq/interface/model/repeat.py

@@ -0,0 +1,13 @@
+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 Repeat(QuantumOperation):
+    iter_var: str
+    count: Expression
+    body: "StatementBlock"

classiq/interface/model/resolvers/function_call_resolver.py

@@ -1,11 +1,17 @@
+import itertools
 from typing import Any, Mapping
 
 from classiq.interface.generator.visitor import Visitor
+from classiq.interface.model.control import Control
+from classiq.interface.model.invert import Invert
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.quantum_function_declaration import (
     QuantumFunctionDeclaration,
 )
+from classiq.interface.model.quantum_if_operation import QuantumIf
+from classiq.interface.model.repeat import Repeat
+from classiq.interface.model.within_apply_operation import WithinApply
 
 
 class FunctionCallResolver(Visitor):
@@ -15,6 +21,26 @@ class FunctionCallResolver(Visitor):
     ) -> None:
         self._quantum_function_dict = quantum_function_dict
 
+    def visit_Invert(self, invert: Invert) -> None:
+        for fc in invert.body:
+            self.visit(fc)
+
+    def visit_Repeat(self, repeat: Repeat) -> None:
+        for fc in repeat.body:
+            self.visit(fc)
+
+    def visit_Control(self, control: Control) -> None:
+        for fc in control.body:
+            self.visit(fc)
+
+    def visit_QuantumIf(self, quantum_if: QuantumIf) -> None:
+        for fc in quantum_if.then:
+            self.visit(fc)
+
+    def visit_WithinApply(self, within_apply: WithinApply) -> None:
+        for fc in itertools.chain(within_apply.compute, within_apply.action):
+            self.visit(fc)
+
     def visit_QuantumFunctionCall(self, fc: QuantumFunctionCall) -> None:
         fc.resolve_function_decl(self._quantum_function_dict, check_operands=True)
         self.visit_BaseModel(fc)

classiq/interface/model/statement_block.py

@@ -0,0 +1,49 @@
+from typing import List, Union
+
+from classiq.interface.model.bind_operation import BindOperation
+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.power import Power
+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_call import QuantumFunctionCall
+from classiq.interface.model.quantum_if_operation import QuantumIf
+from classiq.interface.model.quantum_lambda_function import QuantumLambdaFunction
+from classiq.interface.model.repeat import Repeat
+from classiq.interface.model.variable_declaration_statement import (
+    VariableDeclarationStatement,
+)
+from classiq.interface.model.within_apply_operation import WithinApply
+
+ConcreteQuantumStatement = Union[
+    QuantumFunctionCall,
+    ArithmeticOperation,
+    AmplitudeLoadingOperation,
+    VariableDeclarationStatement,
+    BindOperation,
+    InplaceBinaryOperation,
+    Control,
+    Repeat,
+    Power,
+    Invert,
+    ClassicalIf,
+    QuantumIf,
+    WithinApply,
+]
+
+StatementBlock = List[ConcreteQuantumStatement]
+
+Control.update_forward_refs(StatementBlock=StatementBlock)
+QuantumIf.update_forward_refs(StatementBlock=StatementBlock)
+QuantumLambdaFunction.update_forward_refs(StatementBlock=StatementBlock)
+Repeat.update_forward_refs(StatementBlock=StatementBlock)
+Power.update_forward_refs(StatementBlock=StatementBlock)
+Invert.update_forward_refs(StatementBlock=StatementBlock)
+WithinApply.update_forward_refs(StatementBlock=StatementBlock)
+ClassicalIf.update_forward_refs(StatementBlock=StatementBlock)

classiq/interface/model/validations/handles_validator.py

@@ -1,9 +1,8 @@
 from typing import Dict, Mapping, Set, Union
 
 from classiq.interface.generator.function_params import PortDirection
-from classiq.interface.generator.functions.core_lib_declarations.quantum_operators import (
-    APPLY,
-    OPERAND_FIELD_NAME,
+from classiq.interface.generator.functions.builtins.quantum_operators import (
+    APPLY_OPERATOR,
 )
 from classiq.interface.model.handle_binding import (
     HandleBinding,
@@ -11,11 +10,9 @@ from classiq.interface.model.handle_binding import (
     SubscriptHandleBinding,
 )
 from classiq.interface.model.port_declaration import PortDeclaration
-from classiq.interface.model.quantum_function_call import (
-    QuantumFunctionCall,
-    QuantumLambdaFunction,
-)
+from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.quantum_statement import QuantumOperation
+from classiq.interface.model.statement_block import StatementBlock
 from classiq.interface.model.validation_handle import HandleState, ValidationHandle
 from classiq.interface.model.validations.handle_validation_base import (
     HandleValidationBase,
@@ -23,6 +20,7 @@ from classiq.interface.model.validations.handle_validation_base import (
 from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
 )
+from classiq.interface.model.within_apply_operation import WithinApply
 
 from classiq.exceptions import ClassiqValueError
 
@@ -57,12 +55,15 @@ class HandleValidator(HandleValidationBase):
     def _validation_handles_state(self) -> Mapping[str, ValidationHandle]:
         return self._handles_to_state
 
-    def handle_call(self, call: QuantumOperation) -> None:
-        if isinstance(call, QuantumFunctionCall) and call.function == APPLY.name:
-            self._handle_apply(call)
-        self._handle_inputs(call.wiring_inputs)
-        self._handle_outputs(call.wiring_outputs)
-        self._handle_inouts(call.wiring_inouts)
+    def handle_operation(self, op: QuantumOperation) -> None:
+        if isinstance(op, QuantumFunctionCall) and op.function == APPLY_OPERATOR.name:
+            call_name = op.operands[APPLY_OPERATOR.operand_names[0]]
+            self._handle_apply([QuantumFunctionCall(function=call_name)])
+        elif isinstance(op, WithinApply):
+            self._handle_apply(op.action)
+        self._handle_inputs(op.wiring_inputs)
+        self._handle_outputs(op.wiring_outputs)
+        self._handle_inouts(op.wiring_inouts)
 
     def handle_variable_declaration(
         self, declaration: VariableDeclarationStatement
@@ -130,13 +131,10 @@ class HandleValidator(HandleValidationBase):
                 f"Invalid use of inout handle {handle!r}, used both in slice or subscript and whole"
             )
 
-    def _handle_apply(self, call: QuantumFunctionCall) -> None:
-        operand = call.operands[OPERAND_FIELD_NAME]
-        if not isinstance(operand, QuantumLambdaFunction):
-            return
+    def _handle_apply(self, body: StatementBlock) -> None:
         local_variables: Set[str] = set()
         output_capturing_variables: Set[str] = set()
-        for statement in operand.body:
+        for statement in body:
             if isinstance(statement, VariableDeclarationStatement):
                 local_variables.add(statement.name)
             elif isinstance(statement, QuantumOperation):

classiq/interface/model/within_apply_operation.py

@@ -0,0 +1,11 @@
+from typing import TYPE_CHECKING
+
+from classiq.interface.model.quantum_statement import QuantumOperation
+
+if TYPE_CHECKING:
+    from classiq.interface.model.statement_block import StatementBlock
+
+
+class WithinApply(QuantumOperation):
+    compute: "StatementBlock"
+    action: "StatementBlock"

classiq/interface/pyomo_extension/pyomo_sympy_bimap.py

@@ -1,10 +1,13 @@
+from typing import Any
+
 import sympy
 from pyomo.core.base import _GeneralVarData
+from pyomo.core.expr.sympy_tools import PyomoSympyBimap
 
 
 # This code is a pure copy paste from pyomo.core.expr.sympy_tools.PyomoSympyBimap.getSympySymbol
 # except one line.
-def get_sympy_symbol(self, pyomo_object):
+def get_sympy_symbol(self: PyomoSympyBimap, pyomo_object: Any) -> sympy.Symbol:
     if pyomo_object in self.pyomo2sympy:
         return self.pyomo2sympy[pyomo_object]
     # Pyomo currently ONLY supports Real variables (not complex

classiq/interface/server/routes.py

@@ -44,6 +44,11 @@ TASKS_SOLVE_SUFFIX = "/tasks/solve"
 MODEL_GENERATE_PREFIX = "/generate_model"
 CHEMISTRY_GENERATE_MODEL_PATH = MODEL_GENERATE_PREFIX + "/chemistry"
 
+CHEMISTRY_QMOD_PATH = "/generate_model/chemistry/qmod"
+GROVER_QMOD_PATH = "/generate_model/grover/qmod"
+FINANCE_QMOD_PATH = "/generate_model/finance/qmod"
+
+
 TASK_TRAIN_SUFFIX = TASKS_SUFFIX + "/train"
 TASK_TEST_SUFFIX = TASKS_SUFFIX + "/test"
 TASK_PREDICT_SUFFIX = TASKS_SUFFIX + "/predict"
@@ -73,10 +78,6 @@ FINANCE_GENERATE_MODEL_PATH = MODEL_GENERATE_PREFIX + "/finance"
 
 GROVER_GENERATE_MODEL_PATH = MODEL_GENERATE_PREFIX + "/grover"
 
-QMOD_PREFIX = ANALYZER_PREFIX + "/qmods"
-QMOD_METADATA_PATH = QMOD_PREFIX + "/metadata"
-QMOD_FILE_PATH = QMOD_PREFIX + "/file"
-
 CONVERSION_GENERATED_CIRCUIT_TO_EXECUTION_INPUT_SUFFIX = "/execution_input"
 CONVERSION_GENERATED_CIRCUIT_TO_EXECUTION_INPUT_FULL = (
     CONVERSION_PREFIX + CONVERSION_GENERATED_CIRCUIT_TO_EXECUTION_INPUT_SUFFIX

classiq/qmod/__init__.py

@@ -1,12 +1,16 @@
 from . import symbolic
 from .builtins import *  # noqa: F403
 from .builtins import __all__ as _builtins_all
-from .classical_function import CFunc
+from .cfunc import cfunc
+from .expression_query import get_expression_numeric_attributes
+from .qfunc import qfunc
+from .qmod_constant import QConstant
 from .qmod_parameter import Array, QParam
-from .qmod_struct import QStruct
+from .qmod_struct import struct
 from .qmod_variable import Input, Output, QArray, QBit, QNum
 from .quantum_callable import QCallable, QCallableList
-from .quantum_function import QFunc, create_model
+from .quantum_function import create_model
+from .write_qmod import write_qmod
 
 __all__ = [
     "QParam",
@@ -18,9 +22,12 @@ __all__ = [
     "QNum",
     "QCallable",
     "QCallableList",
-    "QStruct",
-    "QFunc",
-    "CFunc",
+    "QConstant",
+    "struct",
+    "qfunc",
+    "cfunc",
     "create_model",
     "symbolic",
+    "write_qmod",
+    "get_expression_numeric_attributes",
 ] + _builtins_all

classiq/qmod/builtins/classical_execution_primitives.py

@@ -1,4 +1,4 @@
-from typing import Dict, List, Optional
+from typing import Dict, List, Optional, Union
 
 from classiq.interface.executor.execution_preferences import QaeWithQpeEstimationMethod
 from classiq.interface.executor.iqae_result import IQAEResult
@@ -6,32 +6,38 @@ from classiq.interface.executor.result import EstimationResult, ExecutionDetails
 from classiq.interface.executor.vqe_result import VQESolverResult
 from classiq.interface.generator.expressions.enums import Optimizer
 from classiq.interface.generator.functions.qmod_python_interface import QmodPyStruct
-from classiq.interface.generator.types.combinatorial_problem import (
-    CombinatorialOptimizationStructDeclaration,
-)
 
 from classiq.applications.qsvm.qsvm import Data, Labels
+from classiq.exceptions import ClassiqError
+
+ExecutionParams = Dict[str, Union[float, int]]
+
+_CALL_IN_QFUNC_ERROR = (
+    'Cannot call "{}" in a quantum context. "{}" is a classical execution primitive.'
+)
+
 
-ExecutionParams = Dict[str, float]
+def _raise_error(primitive_name: str) -> None:
+    raise ClassiqError(_CALL_IN_QFUNC_ERROR.format(primitive_name, primitive_name))
 
 
 def save(values_to_save: dict) -> None:
-    pass
+    _raise_error("save")
 
 
-def sample(  # type: ignore
+def sample(  # type: ignore[return]
     execution_params: Optional[ExecutionParams] = None,
 ) -> ExecutionDetails:
-    pass
+    _raise_error("sample")
 
 
-def estimate(  # type: ignore
+def estimate(  # type: ignore[return]
     hamiltonian: List[QmodPyStruct], execution_params: Optional[ExecutionParams] = None
 ) -> EstimationResult:
-    pass
+    _raise_error("estimate")
 
 
-def vqe(  # type: ignore
+def vqe(  # type: ignore[return]
     hamiltonian: List[QmodPyStruct],
     maximize: bool,
     initial_point: List[int],
@@ -42,56 +48,43 @@ def vqe(  # type: ignore
     skip_compute_variance: bool,
     alpha_cvar: float,
 ) -> VQESolverResult:
-    pass
+    _raise_error("vqe")
 
 
-def qae_with_qpe_result_post_processing(  # type: ignore
+def qae_with_qpe_result_post_processing(  # type: ignore[return]
     estimation_register_size: int,
     estimation_method: QaeWithQpeEstimationMethod,
     result: ExecutionDetails,
 ) -> float:
-    pass
+    _raise_error("qae_with_qpe_result_post_processing")
 
 
-def qsvm_full_run(  # type: ignore
+def qsvm_full_run(  # type: ignore[return]
     train_data: Data,
     train_labels: Labels,
     test_data: Data,
     test_labels: Labels,
     predict_data: Data,
 ) -> QmodPyStruct:
-    pass
+    _raise_error("qsvm_full_run")
 
 
-def iqae(  # type: ignore
+def iqae(  # type: ignore[return]
     epsilon: float,
     alpha: float,
     execution_params: Optional[ExecutionParams] = None,
 ) -> IQAEResult:
-    pass
+    _raise_error("iqae")
 
 
-def molecule_ground_state_solution_post_process(  # type: ignore
+def molecule_ground_state_solution_post_process(  # type: ignore[return]
     problem: QmodPyStruct, vqe_result: VQESolverResult
 ) -> QmodPyStruct:
-    pass
-
-
-def optimization_problem_to_hamiltonian(  # type: ignore
-    problem_struct: CombinatorialOptimizationStructDeclaration, penalty_energy: float
-) -> List[QmodPyStruct]:
-    pass
-
-
-def get_optimization_solution(  # type: ignore
-    problem_struct: CombinatorialOptimizationStructDeclaration,
-    vqe_result: VQESolverResult,
-    penalty_energy: float,
-) -> List[QmodPyStruct]:
-    pass
+    _raise_error("molecule_ground_state_solution_post_process")
 
 
 __all__ = [
+    "ExecutionParams",
     "save",
     "sample",
     "estimate",
@@ -100,8 +93,6 @@ __all__ = [
     "qsvm_full_run",
     "iqae",
     "molecule_ground_state_solution_post_process",
-    "optimization_problem_to_hamiltonian",
-    "get_optimization_solution",
 ]