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

classiq/interface/generator/transpiler_basis_gates.py

@@ -63,7 +63,9 @@ THREE_QUBIT_GATES: BasisGates = frozenset(("ccx", "cswap"))
 DEFAULT_BASIS_GATES: BasisGates = SINGLE_QUBIT_GATES | BASIC_TWO_QUBIT_GATES
 ALL_GATES: BasisGates = SINGLE_QUBIT_GATES | TWO_QUBIT_GATES | THREE_QUBIT_GATES
 
-ROUTING_TWO_QUBIT_BASIS_GATES: BasisGates = frozenset(("cx", "ecr", "rzx"))
+ROUTING_TWO_QUBIT_BASIS_GATES: BasisGates = frozenset(
+    ("cx", "ecr", "rzx", "ryy", "rxx", "rzz", "cy", "cz", "cp", "swap")
+)
 DEFAULT_ROUTING_BASIS_GATES: BasisGates = SINGLE_QUBIT_GATES | frozenset(("cx",))
 # The Enum names are capitalized per recommendation in https://docs.python.org/3/library/enum.html#module-enum
 # The Enum values are lowered to keep consistency

classiq/interface/generator/types/compilation_metadata.py

@@ -4,3 +4,4 @@ from pydantic import BaseModel, Field, NonNegativeInt
 class CompilationMetadata(BaseModel):
     should_synthesize_separately: bool = Field(default=False)
     occurrences_number: NonNegativeInt = Field(default=1)
+    atomic_qualifiers: list[str] = Field(default_factory=list)

classiq/interface/hardware.py

@@ -33,6 +33,7 @@ class Provider(StrEnum):
     INTEL = "Intel"
     AQT = "AQT"
     IQCC = "IQCC"
+    CINECA = "CINECA"
 
     @property
     def id(self) -> "ProviderIDEnum":

classiq/interface/ide/visual_model.py

@@ -97,6 +97,7 @@ class AtomicGate(StrEnum):
     SWAP = "SWAP"
     IDENTITY = "IDENTITY"
     U = "U"
+    RESET = "RESET"
 
     @property
     def is_control_gate(self) -> bool:

classiq/interface/interface_version.py

@@ -1 +1 @@
-INTERFACE_VERSION = "8"
+INTERFACE_VERSION = "9"

classiq/interface/model/allocate.py

@@ -14,3 +14,10 @@ class Allocate(QuantumOperation):
     @property
     def wiring_outputs(self) -> Mapping[str, HandleBinding]:
         return {"out": self.target}
+
+    @property
+    def expressions(self) -> list[Expression]:
+        exprs = []
+        if self.size is not None:
+            exprs.append(self.size)
+        return exprs

classiq/interface/model/block.py

@@ -0,0 +1,12 @@
+from typing import TYPE_CHECKING, Literal
+
+from classiq.interface.model.quantum_statement import QuantumOperation
+
+if TYPE_CHECKING:
+    from classiq.interface.model.statement_block import StatementBlock
+
+
+class Block(QuantumOperation):
+    kind: Literal["Block"]
+
+    statements: "StatementBlock"

classiq/interface/model/classical_if.py

@@ -17,3 +17,7 @@ class ClassicalIf(QuantumOperation):
 
     def _as_back_ref(self: ASTNodeType) -> ASTNodeType:
         return reset_lists(self, ["then", "else_"])
+
+    @property
+    def expressions(self) -> list[Expression]:
+        return [self.condition]

classiq/interface/model/handle_binding.py

@@ -64,6 +64,9 @@ class HandleBinding(ASTNode):
     def __contains__(self, other_handle: "HandleBinding") -> bool:
         return self.collapse() in other_handle.collapse().prefixes()
 
+    def is_constant(self) -> bool:
+        return True
+
 
 class NestedHandleBinding(HandleBinding):
     base_handle: "ConcreteHandleBinding"
@@ -105,6 +108,9 @@ class NestedHandleBinding(HandleBinding):
             )
         return self
 
+    def is_constant(self) -> bool:
+        return self.base_handle.is_constant()
+
 
 class SubscriptHandleBinding(NestedHandleBinding):
     index: Expression
@@ -178,6 +184,13 @@ class SubscriptHandleBinding(NestedHandleBinding):
             )
         return super().replace_prefix(prefix, replacement)
 
+    def is_constant(self) -> bool:
+        return (
+            super().is_constant()
+            and self.index.is_evaluated()
+            and self.index.is_constant()
+        )
+
 
 class SlicedHandleBinding(NestedHandleBinding):
     start: Expression
@@ -284,6 +297,14 @@ class SlicedHandleBinding(NestedHandleBinding):
     def _is_evaluated(self) -> bool:
         return self.start.is_evaluated() and self.end.is_evaluated()
 
+    def is_constant(self) -> bool:
+        return (
+            super().is_constant()
+            and self._is_evaluated()
+            and self.start.is_constant()
+            and self.end.is_constant()
+        )
+
 
 class FieldHandleBinding(NestedHandleBinding):
     field: str

classiq/interface/model/inplace_binary_operation.py

@@ -41,3 +41,7 @@ class InplaceBinaryOperation(QuantumOperation):
                 )
             )
         return readable_inouts
+
+    @property
+    def expressions(self) -> list[Expression]:
+        return [self.value] if isinstance(self.value, Expression) else []

classiq/interface/model/model.py

@@ -103,7 +103,9 @@ class Model(VersionedModel, ASTNode):
     functions_compilation_metadata: dict[str, CompilationMetadata] = pydantic.Field(
         default_factory=dict
     )
-    execution_parameters: Optional[dict[str, ConcreteClassicalType]] = None
+    execution_parameters: Optional[dict[str, ConcreteClassicalType]] = pydantic.Field(
+        default=None, exclude=True
+    )
 
     @property
     def main_func(self) -> NativeFunctionDefinition:

classiq/interface/model/phase_operation.py

@@ -9,3 +9,7 @@ from classiq.interface.model.quantum_expressions.quantum_expression import (
 class PhaseOperation(QuantumExpressionOperation):
     kind: Literal["PhaseOperation"]
     theta: Expression
+
+    @property
+    def expressions(self) -> list[Expression]:
+        return super().expressions + [self.theta]

classiq/interface/model/port_declaration.py

@@ -8,6 +8,7 @@ from classiq.interface.generator.functions.concrete_types import ConcreteQuantum
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
+from classiq.interface.generator.functions.type_qualifier import TypeQualifier
 from classiq.interface.helpers.pydantic_model_helpers import values_with_discriminator
 from classiq.interface.model.parameter import Parameter
 
@@ -15,6 +16,8 @@ from classiq.interface.model.parameter import Parameter
 class AnonPortDeclaration(Parameter):
     quantum_type: ConcreteQuantumType
     direction: PortDeclarationDirection
+    # TODO remove default after BWC-breaking version
+    type_qualifier: TypeQualifier = pydantic.Field(default=TypeQualifier.Quantum)
     kind: Literal["PortDeclaration"]
 
     @pydantic.model_validator(mode="before")

classiq/interface/model/power.py

@@ -16,3 +16,7 @@ class Power(QuantumOperation):
 
     def _as_back_ref(self: ASTNodeType) -> ASTNodeType:
         return reset_lists(self, ["body"])
+
+    @property
+    def expressions(self) -> list[Expression]:
+        return [self.power]

classiq/interface/model/quantum_expressions/quantum_expression.py

@@ -46,6 +46,10 @@ class QuantumExpressionOperation(QuantumOperation):
     def wiring_inouts(self) -> Mapping[str, ConcreteHandleBinding]:
         return nameables_to_dict(self.var_handles)
 
+    @property
+    def expressions(self) -> list[Expression]:
+        return [self.expression]
+
 
 class QuantumAssignmentOperation(QuantumExpressionOperation):
     result_var: ConcreteHandleBinding = pydantic.Field(

classiq/interface/model/quantum_function_call.py

@@ -170,6 +170,10 @@ class QuantumFunctionCall(QuantumOperation):
             param for param in self.positional_args if isinstance(param, HandleBinding)
         ]
 
+    @property
+    def expressions(self) -> list[Expression]:
+        return [arg for arg in self.positional_args if isinstance(arg, Expression)]
+
     def _get_handles_by_direction(
         self, direction: PortDeclarationDirection
     ) -> list[tuple[int, AnonPortDeclaration, HandleBinding]]:

classiq/interface/model/quantum_function_declaration.py

@@ -87,7 +87,7 @@ class AnonQuantumFunctionDeclaration(FunctionDeclaration):
         ]
 
     @property
-    def param_names(self) -> Sequence[str]:
+    def param_names(self) -> list[str]:
         return [param.get_name() for param in self.param_decls]
 
     @property

classiq/interface/model/quantum_statement.py

@@ -8,6 +8,7 @@ from pydantic import ConfigDict
 from typing_extensions import Self
 
 from classiq.interface.ast_node import ASTNode
+from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.helpers.pydantic_model_helpers import values_with_discriminator
 from classiq.interface.model.handle_binding import (
     ConcreteHandleBinding,
@@ -39,6 +40,10 @@ class QuantumStatement(ASTNode):
     def _set_kind(cls, values: Any) -> dict[str, Any]:
         return values_with_discriminator(values, "kind", cls.__name__)
 
+    @property
+    def expressions(self) -> list[Expression]:
+        return []
+
 
 @dataclass
 class HandleMetadata:

classiq/interface/model/quantum_type.py

@@ -71,6 +71,10 @@ class QuantumType(HashableASTNode):
     def is_evaluated(self) -> bool:
         raise NotImplementedError
 
+    @property
+    def expressions(self) -> list[Expression]:
+        return []
+
 
 class QuantumScalar(QuantumType):
     def get_proxy(self, handle: "HandleBinding") -> QmodQScalarProxy:
@@ -174,6 +178,13 @@ class QuantumBitvector(QuantumType):
             and self.element_type.is_evaluated
         )
 
+    @property
+    def expressions(self) -> list[Expression]:
+        exprs = self.element_type.expressions
+        if self.length is not None:
+            exprs.append(self.length)
+        return exprs
+
 
 class QuantumNumeric(QuantumScalar):
     kind: Literal["qnum"]
@@ -265,6 +276,17 @@ class QuantumNumeric(QuantumScalar):
             self.fraction_digits is not None and not self.fraction_digits.is_evaluated()
         )
 
+    @property
+    def expressions(self) -> list[Expression]:
+        exprs = []
+        if self.size is not None:
+            exprs.append(self.size)
+        if self.is_signed is not None:
+            exprs.append(self.is_signed)
+        if self.fraction_digits is not None:
+            exprs.append(self.fraction_digits)
+        return exprs
+
 
 class RegisterQuantumType(BaseModel):
     quantum_types: "ConcreteQuantumType"

classiq/interface/model/repeat.py

@@ -17,3 +17,7 @@ class Repeat(QuantumOperation):
 
     def _as_back_ref(self: ASTNodeType) -> ASTNodeType:
         return reset_lists(self, ["body"])
+
+    @property
+    def expressions(self) -> list[Expression]:
+        return [self.count]

classiq/interface/model/statement_block.py

@@ -4,6 +4,7 @@ from pydantic import Field
 
 from classiq.interface.model.allocate import Allocate
 from classiq.interface.model.bind_operation import BindOperation
+from classiq.interface.model.block import Block
 from classiq.interface.model.classical_if import ClassicalIf
 from classiq.interface.model.control import Control
 from classiq.interface.model.inplace_binary_operation import InplaceBinaryOperation
@@ -41,12 +42,14 @@ ConcreteQuantumStatement = Annotated[
         Control,
         WithinApply,
         PhaseOperation,
+        Block,
     ],
     Field(..., discriminator="kind"),
 ]
 
 StatementBlock = list[ConcreteQuantumStatement]
 
+Block.model_rebuild()
 Control.model_rebuild()
 QuantumLambdaFunction.model_rebuild()
 Repeat.model_rebuild()

classiq/interface/model/variable_declaration_statement.py

@@ -1,5 +1,6 @@
 from typing import Literal
 
+from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.model.quantum_statement import QuantumStatement
 from classiq.interface.model.quantum_variable_declaration import (
     QuantumVariableDeclaration,
@@ -8,3 +9,7 @@ from classiq.interface.model.quantum_variable_declaration import (
 
 class VariableDeclarationStatement(QuantumStatement, QuantumVariableDeclaration):
     kind: Literal["VariableDeclarationStatement"]
+
+    @property
+    def expressions(self) -> list[Expression]:
+        return self.quantum_type.expressions

classiq/interface/server/routes.py

@@ -43,8 +43,6 @@ TASKS_VISUAL_MODEL_SUFFIX = TASKS_SUFFIX + "/visual_model"
 TASKS_SOLVE_SUFFIX = "/tasks/solve"
 
 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"

classiq/model_expansions/atomic_expression_functions_defs.py

@@ -1,8 +1,8 @@
 from collections.abc import Mapping
 from enum import Enum
-from typing import Any, Callable, Union
+from typing import Any, Callable, Union, get_args
 
-from sympy import Eq, Expr, Number, Piecewise, Symbol
+from sympy import Eq, Expr, Piecewise, Symbol
 
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
@@ -12,6 +12,9 @@ from classiq.interface.generator.expressions.expression_types import (
     ExpressionValue,
     QmodStructInstance,
 )
+from classiq.interface.generator.expressions.proxies.classical.any_classical_value import (
+    AnyClassicalValue,
+)
 from classiq.interface.generator.expressions.proxies.quantum.qmod_qscalar_proxy import (
     QmodQNumProxy,
 )
@@ -54,6 +57,10 @@ from classiq.model_expansions.sympy_conversion.expression_to_sympy import (
 from classiq.model_expansions.sympy_conversion.sympy_to_python import (
     sympy_to_python,
 )
+from classiq.model_expansions.utils.sympy_utils import (
+    is_constant_subscript,
+    unwrap_sympy_numeric,
+)
 from classiq.qmod.model_state_container import QMODULE
 
 
@@ -151,9 +158,13 @@ def struct_literal(struct_type_symbol: Symbol, **kwargs: Any) -> QmodStructInsta
 
 
 def get_field(
-    proxy: Union[QmodSizedProxy, QmodStructInstance, QmodQStructProxy, list],
+    proxy: Union[
+        QmodSizedProxy, QmodStructInstance, QmodQStructProxy, list, AnyClassicalValue
+    ],
     field: str,
 ) -> ExpressionValue:
+    if isinstance(proxy, AnyClassicalValue):
+        return AnyClassicalValue(f"({proxy}).{field}")
     if isinstance(proxy, type) and issubclass(proxy, Enum):
         return getattr(proxy, field)
     if isinstance(proxy, Symbol) and not isinstance(proxy, QmodSizedProxy):
@@ -189,20 +200,25 @@ def get_type(struct_type: Symbol) -> TypeProxy:
     return TypeProxy(QMODULE.type_decls[struct_type.name])
 
 
-def _unwrap_sympy_numeric(n: Any) -> Any:
-    if not isinstance(n, Number) or not n.is_constant():
-        return n
-    if n.is_Integer:
-        return int(n)
-    return float(n)
-
-
 def do_div(lhs: Any, rhs: Any) -> Any:
-    lhs = _unwrap_sympy_numeric(lhs)
-    rhs = _unwrap_sympy_numeric(rhs)
+    lhs = unwrap_sympy_numeric(lhs)
+    rhs = unwrap_sympy_numeric(rhs)
     return lhs / rhs
 
 
+_EXPRESSION_TYPES = get_args(ExpressionValue)
+
+
+def _is_qmod_value(val: Any) -> bool:
+    if not isinstance(val, slice):
+        return isinstance(val, _EXPRESSION_TYPES)
+    if val.start is not None and not isinstance(val.start, _EXPRESSION_TYPES):
+        return False
+    if val.stop is not None and not isinstance(val.stop, _EXPRESSION_TYPES):
+        return False
+    return val.step is None or isinstance(val.step, _EXPRESSION_TYPES)
+
+
 def do_subscript(value: Any, index: Any) -> Any:
     if not isinstance(value, list) or not isinstance(index, QmodQNumProxy):
         if isinstance(index, (QmodSizedProxy, QmodStructInstance)):
@@ -214,6 +230,12 @@ def do_subscript(value: Any, index: Any) -> Any:
                 f"\t2. `l[n]`, where `l` is a list of classical real numbers and `n` "
                 f"is a classical or quantum integer."
             )
+        if (
+            isinstance(value, list)
+            and not is_constant_subscript(index)
+            and _is_qmod_value(index)
+        ):
+            return AnyClassicalValue(str(value))[index]
         return value[index]
     if index.is_signed or index.fraction_digits > 0:
         raise ClassiqExpansionError(