classiq 0.89.0__py3-none-any.whl → 0.90.0__py3-none-any.whl

classiq/evaluators/qmod_node_evaluators/utils.py

@@ -4,6 +4,7 @@ import sympy
 
 from classiq.interface.exceptions import ClassiqInternalExpansionError
 from classiq.interface.generator.functions.classical_type import (
+    Bool,
     ClassicalArray,
     ClassicalTuple,
     ClassicalType,
@@ -100,3 +101,35 @@ def is_classical_integer(qmod_type: QmodType) -> bool:
     return isinstance(qmod_type, Integer) or (
         isinstance(qmod_type, TypeName) and qmod_type.is_enum
     )
+
+
+def get_sympy_val(val: sympy.Basic) -> Union[bool, int, float, complex]:
+    if hasattr(val, "is_Boolean") and val.is_Boolean:
+        return bool(val)
+    if (hasattr(val, "is_integer") and val.is_integer) or (
+        hasattr(val, "is_Integer") and val.is_Integer
+    ):
+        return int(val)
+    if hasattr(val, "is_real") and val.is_real:
+        return float(val)
+    if (hasattr(val, "is_complex") and val.is_complex) or (
+        hasattr(val, "is_imaginary") and val.is_imaginary
+    ):
+        return complex(val)
+    raise ClassiqInternalExpansionError("Unidentified sympy value")
+
+
+def get_sympy_type(val: sympy.Basic) -> ClassicalType:
+    if hasattr(val, "is_Boolean") and val.is_Boolean:
+        return Bool()
+    if (hasattr(val, "is_integer") and val.is_integer) or (
+        hasattr(val, "is_Integer") and val.is_Integer
+    ):
+        return Integer()
+    if (
+        (hasattr(val, "is_real") and val.is_real)
+        or (hasattr(val, "is_complex") and val.is_complex)
+        or (hasattr(val, "is_imaginary") and val.is_imaginary)
+    ):
+        return Real()
+    raise ClassiqInternalExpansionError("Unidentified sympy value")

classiq/evaluators/qmod_type_inference/classical_type_inference.py

@@ -20,6 +20,8 @@ from classiq.interface.generator.functions.type_name import Enum, Struct, TypeNa
 from classiq.interface.generator.types.struct_declaration import StructDeclaration
 from classiq.interface.helpers.backward_compatibility import zip_strict
 
+from classiq.evaluators.qmod_node_evaluators.utils import get_sympy_type
+
 
 def _copy_generative_flag(
     from_type: ClassicalType, to_type: Optional[ClassicalType]
@@ -57,13 +59,8 @@ def infer_classical_type(value: Any) -> ClassicalType:
             )
         )
         return classical_type
-    # FIXME: Remove sympy compatibility (CLS-3214)
-    if (
-        isinstance(value, sympy.Basic)
-        and len(value.free_symbols) == 0
-        and value.is_complex
-    ):
-        return Real()
+    if isinstance(value, sympy.Basic):
+        return get_sympy_type(value)
     raise ClassiqInternalExpansionError
 
 

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

classiq/interface/analyzer/analysis_params.py

@@ -1,12 +1,9 @@
 from typing import Annotated, Optional
 
-import numpy
 import pydantic
-from pydantic import ConfigDict, Field, StringConstraints
+from pydantic import Field, StringConstraints
 
 from classiq.interface.backend.quantum_backend_providers import AnalyzerProviderVendor
-from classiq.interface.chemistry.ground_state_problem import MoleculeProblem
-from classiq.interface.executor.optimizer_preferences import OptimizerPreferences
 from classiq.interface.generator.hardware.hardware_data import SynthesisHardwareData
 from classiq.interface.generator.model.preferences.preferences import (
     TranspilationOption,
@@ -103,24 +100,3 @@ class AnalysisRBParams(pydantic.BaseModel):
     num_clifford: list[
         Annotated[int, Annotated[int, Field(strict=True, gt=0, le=MAX_NUM_CLIFFORD)]]
     ]
-
-
-class ChemistryGenerationParams(pydantic.BaseModel):
-    model_config = ConfigDict(title="Chemistry")
-
-    molecule: MoleculeProblem = pydantic.Field(
-        title="Molecule",
-        default=...,
-        description="The molecule to generate the VQE ansatz for",
-    )
-    optimizer_preferences: OptimizerPreferences = pydantic.Field(
-        default=..., description="Execution options for the classical Optimizer"
-    )
-
-    def initial_point(self) -> Optional[numpy.ndarray]:
-        if self.optimizer_preferences.initial_point is not None:
-            return numpy.ndarray(
-                self.optimizer_preferences.initial_point  # type: ignore[arg-type]
-            )
-        else:
-            return None

classiq/interface/analyzer/result.py

@@ -40,6 +40,10 @@ class QasmCode(pydantic.BaseModel):
     code: str = Field(..., max_length=MAX_FILE_LENGTH)
 
 
+class QmodCode(VersionedModel):
+    code: str = Field(..., max_length=MAX_FILE_LENGTH)
+
+
 class AnalysisStatus(StrEnum):
     NONE = "none"
     SUCCESS = "success"

classiq/interface/chemistry/ground_state_problem.py

@@ -1,4 +1,5 @@
-from typing import Annotated, Literal, Optional, Union, cast
+import warnings
+from typing import Annotated, Any, Literal, Optional, Union, cast
 
 import pydantic
 from pydantic import ConfigDict, Field
@@ -7,7 +8,7 @@ from pydantic_core.core_schema import ValidationInfo
 from classiq.interface.chemistry.fermionic_operator import SummedFermionicOperator
 from classiq.interface.chemistry.molecule import Molecule
 from classiq.interface.enum_utils import StrEnum
-from classiq.interface.exceptions import ClassiqValueError
+from classiq.interface.exceptions import ClassiqDeprecationWarning, ClassiqValueError
 from classiq.interface.helpers.hashable_pydantic_base_model import (
     HashablePydanticBaseModel,
 )
@@ -52,6 +53,19 @@ class GroundStateProblem(HashablePydanticBaseModel):
     )
     num_qubits: Optional[int] = pydantic.Field(default=None)
 
+    def __init__(self, /, **data: Any) -> None:
+        warnings.warn(
+            (
+                f"The class `{self.__class__.__name__}` is deprecated and will no "
+                "longer be supported starting on 2025-09-18 at the earliest. "
+                "For more information on Classiq's chemistry application, see "
+                "https://docs.classiq.io/latest/explore/applications/chemistry/classiq_chemistry_application/classiq_chemistry_application/."
+            ),
+            category=ClassiqDeprecationWarning,
+            stacklevel=2,
+        )
+        super().__init__(**data)
+
     @pydantic.field_validator("z2_symmetries")
     @classmethod
     def _validate_z2_symmetries(cls, z2_symmetries: bool, info: ValidationInfo) -> bool:

classiq/interface/executor/optimizer_preferences.py

@@ -1,12 +1,4 @@
-from typing import Optional
-
-import pydantic
-from pydantic import BaseModel
-from pydantic_core.core_schema import ValidationInfo
-
 from classiq.interface.enum_utils import StrEnum
-from classiq.interface.exceptions import ClassiqValueError
-from classiq.interface.helpers.custom_pydantic_types import PydanticAlphaParamCVAR
 
 
 class CostType(StrEnum):
@@ -22,107 +14,3 @@ class OptimizerType(StrEnum):
     NELDER_MEAD = "NELDER_MEAD"
     ADAM = "ADAM"
     SLSQP = "SLSQP"
-
-
-class OptimizerPreferences(BaseModel):
-    name: OptimizerType = pydantic.Field(
-        default=OptimizerType.COBYLA, description="Classical optimization algorithm."
-    )
-    num_shots: Optional[pydantic.PositiveInt] = pydantic.Field(
-        default=None,
-        description="Number of repetitions of the quantum ansatz.",
-    )
-    max_iteration: pydantic.PositiveInt = pydantic.Field(
-        default=100, description="Maximal number of optimizer iterations"
-    )
-    tolerance: Optional[pydantic.PositiveFloat] = pydantic.Field(
-        default=None, description="Final accuracy in the optimization"
-    )
-    step_size: Optional[pydantic.PositiveFloat] = pydantic.Field(
-        default=None,
-        description="step size for numerically " "calculating the gradient",
-    )
-    random_seed: Optional[int] = pydantic.Field(
-        default=None,
-        description="The random seed used for the generation",
-    )
-    initial_point: Optional[list[float]] = pydantic.Field(
-        default=None,
-        description="Initial values for the ansatz parameters",
-    )
-    skip_compute_variance: bool = pydantic.Field(
-        default=False,
-        description="If True, the optimizer will not compute the variance of the ansatz.",
-    )
-
-    @pydantic.field_validator("tolerance", mode="before")
-    @classmethod
-    def check_tolerance(
-        cls, tolerance: Optional[pydantic.PositiveFloat], info: ValidationInfo
-    ) -> Optional[pydantic.PositiveFloat]:
-        optimizer_type = info.data.get("type")
-        if tolerance is not None and optimizer_type == OptimizerType.SPSA:
-            raise ClassiqValueError("No tolerance param for SPSA optimizer")
-
-        if tolerance is None and optimizer_type != OptimizerType.SPSA:
-            tolerance = pydantic.PositiveFloat(0.001)
-
-        return tolerance
-
-    @pydantic.field_validator("step_size", mode="before")
-    @classmethod
-    def check_step_size(
-        cls, step_size: Optional[pydantic.PositiveFloat], info: ValidationInfo
-    ) -> Optional[pydantic.PositiveFloat]:
-        optimizer_type = info.data.get("name")
-        if step_size is not None and optimizer_type not in (
-            OptimizerType.L_BFGS_B,
-            OptimizerType.ADAM,
-        ):
-            raise ClassiqValueError(
-                "Use step_size only for L_BFGS_B or ADAM optimizers."
-            )
-
-        if step_size is None and optimizer_type in (
-            OptimizerType.L_BFGS_B,
-            OptimizerType.ADAM,
-        ):
-            step_size = pydantic.PositiveFloat(0.05)
-
-        return step_size
-
-
-class GroundStateOptimizer(OptimizerPreferences):
-    pass
-
-
-class CombinatorialOptimizer(OptimizerPreferences):
-    cost_type: CostType = pydantic.Field(
-        default=CostType.CVAR,
-        description="Summarizing method of the measured bit strings",
-    )
-    alpha_cvar: Optional[PydanticAlphaParamCVAR] = pydantic.Field(
-        default=None, description="Parameter for the CVAR summarizing method"
-    )
-    is_maximization: bool = pydantic.Field(
-        default=False,
-        description="Whether the optimization goal is to maximize",
-    )
-    should_check_valid_solutions: bool = pydantic.Field(
-        default=False,
-        description="Whether to check if all the solutions satisfy the constraints",
-    )
-
-    @pydantic.field_validator("alpha_cvar", mode="before")
-    @classmethod
-    def check_alpha_cvar(
-        cls, alpha_cvar: Optional[PydanticAlphaParamCVAR], info: ValidationInfo
-    ) -> Optional[PydanticAlphaParamCVAR]:
-        cost_type = info.data.get("cost_type")
-        if alpha_cvar is not None and cost_type != CostType.CVAR:
-            raise ClassiqValueError("Use CVAR params only for CostType.CVAR.")
-
-        if alpha_cvar is None and cost_type == CostType.CVAR:
-            alpha_cvar = PydanticAlphaParamCVAR(0.2)
-
-        return alpha_cvar

classiq/interface/generator/application_apis/chemistry_declarations.py

@@ -20,7 +20,9 @@ FOCK_HAMILTONIAN_PROBLEM_PARAM = ClassicalParameterDeclaration(
     name="fock_hamiltonian_problem",
     classical_type=Struct(name="FockHamiltonianProblem"),
 )
-FOCK_HAMILTONIAN_SIZE = "get_field(get_field(fock_hamiltonian_problem_to_hamiltonian(fock_hamiltonian_problem)[0], 'pauli'), 'len')"
+FOCK_HAMILTONIAN_SIZE = (
+    "fock_hamiltonian_problem_to_hamiltonian(fock_hamiltonian_problem)[0].pauli.len"
+)
 
 
 class ChemistryProblemType(Enum):

classiq/interface/generator/arith/arithmetic_expression_validator.py

@@ -88,13 +88,8 @@ class ExpressionValidator(ast.NodeVisitor):
             ast_expr = ast.parse(adjusted_expression, filename="", mode=self._mode)
         except SyntaxError as e:
             raise ClassiqValueError(f"Failed to parse expression {expression!r}") from e
-        try:
-            self._ast_obj = self.rewrite_ast(ast_expr)
-            self.visit(self._ast_obj)
-        except RecursionError as e:
-            raise ClassiqValueError(
-                f"Failed to parse expression since it is too long: {expression}"
-            ) from e
+        self._ast_obj = self.rewrite_ast(ast_expr)
+        self.visit(self._ast_obj)
 
     @staticmethod
     def _get_adjusted_expression(expression: str) -> str:

classiq/interface/generator/expressions/evaluated_expression.py

@@ -10,10 +10,11 @@ from classiq.interface.backend.pydantic_backend import EXECUTION_PARAMETER_PATTE
 from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.expressions.expression_types import (
     ExpressionValue,
-    QmodStructInstance,
     RuntimeConstant,
 )
-from classiq.interface.generator.expressions.handle_identifier import HandleIdentifier
+from classiq.interface.generator.expressions.proxies.classical.qmod_struct_instance import (
+    QmodStructInstance,
+)
 
 
 @dataclass(frozen=True)
@@ -21,9 +22,6 @@ class EvaluatedExpression:
     value: ExpressionValue
 
     def is_constant(self, constant_type: Optional[type] = None) -> bool:
-        if self.value is None:
-            return False
-
         return isinstance(
             self.value,
             get_args(RuntimeConstant) if constant_type is None else constant_type,
@@ -49,14 +47,6 @@ class EvaluatedExpression:
     def to_list(self) -> list:
         return self.as_constant_type(list)
 
-    def to_handle(self) -> HandleIdentifier:
-        if not isinstance(self.value, HandleIdentifier):
-            raise ClassiqValueError(
-                f"Invalid access to expression {self.value} as HandleIdentifier"
-            )
-
-        return self.value
-
     def to_struct_dict(self) -> Mapping[str, Any]:
         if not isinstance(self.value, QmodStructInstance):
             raise ClassiqValueError(

classiq/interface/generator/expressions/expression_types.py

@@ -1,35 +1,21 @@
-from typing import Union
+from typing import TYPE_CHECKING, Union
 
-from sympy import Basic
-from sympy.logic.boolalg import Boolean
+import sympy
 
-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,
-)
 from classiq.interface.generator.expressions.proxies.classical.qmod_struct_instance import (
     QmodStructInstance,
 )
-from classiq.interface.generator.expressions.proxies.quantum.qmod_sized_proxy import (
-    QmodSizedProxy,
-)
-from classiq.interface.generator.expressions.type_proxy import TypeProxy
+
+if TYPE_CHECKING:
+    from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
 
 RuntimeConstant = Union[
     int,
     float,
     list,
     bool,
+    complex,
     QmodStructInstance,
-    TypeProxy,
-    HandleIdentifier,
-]
-Proxies = Union[
-    QmodSizedProxy,
-    ClassicalProxy,
+    sympy.Basic,
 ]
-RuntimeExpression = Union[AnyClassicalValue, Basic, Boolean]
-ExpressionValue = Union[RuntimeConstant, Proxies, RuntimeExpression]
+ExpressionValue = Union[RuntimeConstant, "QmodAnnotatedExpression"]

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

@@ -1,5 +1,5 @@
 from collections.abc import Mapping
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Union
 
 if TYPE_CHECKING:
     from classiq.interface.generator.expressions.expression_types import ExpressionValue
@@ -18,7 +18,7 @@ class ClassicalProxy:
         return str(self.handle)
 
     @property
-    def fields(self) -> Mapping[str, "ExpressionValue"]:
+    def fields(self) -> Mapping[str, Union["ExpressionValue", "ClassicalProxy"]]:
         raise NotImplementedError
 
     @property

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

@@ -8,7 +8,6 @@ from classiq.interface.generator.expressions.proxies.classical.classical_proxy i
 from classiq.interface.model.handle_binding import FieldHandleBinding, HandleBinding
 
 if TYPE_CHECKING:
-    from classiq.interface.generator.expressions.expression_types import ExpressionValue
     from classiq.interface.generator.types.struct_declaration import StructDeclaration
 
 
@@ -22,7 +21,7 @@ class ClassicalStructProxy(NonSymbolicExpr, ClassicalProxy):
         return self._decl
 
     @property
-    def fields(self) -> Mapping[str, "ExpressionValue"]:
+    def fields(self) -> Mapping[str, ClassicalProxy]:
         return {
             field_name: field_type.get_classical_proxy(
                 FieldHandleBinding(base_handle=self.handle, field=field_name)

classiq/interface/generator/functions/concrete_types.py

@@ -47,7 +47,7 @@ PythonClassicalPydanticTypes = (Enum,)
 
 ConcreteQuantumType = Annotated[
     Union[QuantumBit, QuantumBitvector, QuantumNumeric, TypeName],
-    Field(discriminator="kind", default_factory=QuantumBitvector),
+    Field(discriminator="kind"),
 ]
 QuantumBitvector.model_rebuild()
 TypeName.model_rebuild()

classiq/interface/generator/generated_circuit_data.py

@@ -17,6 +17,7 @@ from classiq.interface.generator.register_role import RegisterRole
 from classiq.interface.generator.synthesis_metadata.synthesis_execution_data import (
     ExecutionData,
 )
+from classiq.interface.model.block import Block
 from classiq.interface.model.quantum_expressions.arithmetic_operation import (
     ArithmeticOperationKind,
 )
@@ -210,10 +211,13 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
             )
             name_with_suffix = self.add_suffix_from_generated_name(generated_name, name)
             return name_with_suffix
+        if isinstance(back_ref, Block) and back_ref.label is not None:
+            return back_ref.label
 
         statement_kind: str = back_ref.kind
         if isinstance(back_ref, ArithmeticOperation):
             statement_kind = back_ref.operation_kind.value
+
         return self.add_suffix_from_generated_name(
             generated_name, STATEMENTS_NAME[statement_kind]
         )

classiq/interface/generator/preferences/qasm_to_qmod_params.py

@@ -0,0 +1,14 @@
+from pydantic import BaseModel
+
+from classiq.interface.analyzer.result import QasmCode
+from classiq.interface.enum_utils import StrEnum
+
+
+class QmodFormat(StrEnum):
+    NATIVE = "native"
+    PYTHON = "python"
+
+
+class QasmToQmodParams(BaseModel):
+    qasm: QasmCode
+    qmod_format: QmodFormat

classiq/interface/helpers/model_normalizer.py

@@ -1,4 +1,3 @@
-import ast
 from typing import Any
 
 from classiq.interface.ast_node import ASTNode
@@ -10,8 +9,6 @@ from classiq.interface.generator.visitor import Transformer, Visitor
 from classiq.interface.model.model import Model
 from classiq.interface.model.port_declaration import AnonPortDeclaration
 
-from classiq.model_expansions.transformers.model_renamer import ExprNormalizer
-
 
 class ModelNormalizer(Visitor):
     def visit(self, node: Any) -> None:
@@ -28,9 +25,6 @@ class ModelNormalizer(Visitor):
         model.functions.sort(key=lambda x: x.name)
         self.generic_visit(model)
 
-    def visit_Expression(self, expr: Expression) -> None:
-        expr.expr = ast.unparse(ExprNormalizer().visit(ast.parse(expr.expr)))
-
     def visit_AnonPortDeclaration(self, decl: AnonPortDeclaration) -> None:
         decl.type_modifier = TypeModifier.Mutable
 

classiq/interface/ide/visual_model.py

@@ -171,6 +171,7 @@ class Operation(pydantic.BaseModel):
     expanded: bool = pydantic.Field(default=False)
     show_expanded_label: bool = pydantic.Field(default=False)
     is_low_level_fallback: bool = pydantic.Field(default=False)
+    is_measurement: bool = pydantic.Field(default=False)
 
     model_config = ConfigDict(frozen=True)
 

classiq/interface/model/handle_binding.py

@@ -349,7 +349,7 @@ class FieldHandleBinding(NestedHandleBinding):
 
     @property
     def qmod_expr(self) -> str:
-        return f"get_field({self.base_handle.qmod_expr}, '{self.field}')"
+        return f"{self.base_handle.qmod_expr}.{self.field}"
 
     @property
     def identifier(self) -> str:

classiq/interface/model/port_declaration.py

@@ -13,10 +13,11 @@ from classiq.interface.generator.functions.type_modifier import (
 )
 from classiq.interface.helpers.pydantic_model_helpers import values_with_discriminator
 from classiq.interface.model.parameter import Parameter
+from classiq.interface.model.quantum_type import QuantumBitvector
 
 
 class AnonPortDeclaration(Parameter):
-    quantum_type: ConcreteQuantumType
+    quantum_type: ConcreteQuantumType = pydantic.Field(default_factory=QuantumBitvector)
     direction: PortDeclarationDirection
     kind: Literal["PortDeclaration"]
     type_modifier: TypeModifier

classiq/interface/model/quantum_expressions/arithmetic_operation.py

@@ -1,12 +1,9 @@
 from collections.abc import Mapping, Sequence
-from typing import Literal
-
-from pydantic import PrivateAttr
+from typing import Literal, cast
 
 from classiq.interface.enum_utils import StrEnum
 from classiq.interface.generator.arith.arithmetic import (
     ARITHMETIC_EXPRESSION_RESULT_NAME,
-    compute_arithmetic_result_type,
 )
 from classiq.interface.model.handle_binding import (
     ConcreteHandleBinding,
@@ -18,6 +15,9 @@ from classiq.interface.model.quantum_expressions.quantum_expression import (
 from classiq.interface.model.quantum_statement import HandleMetadata
 from classiq.interface.model.quantum_type import QuantumType
 
+from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
+from classiq.model_expansions.arithmetic import NumericAttributes
+
 
 class ArithmeticOperationKind(StrEnum):
     InplaceAdd = "inplace_add"
@@ -29,7 +29,7 @@ class ArithmeticOperation(QuantumAssignmentOperation):
     kind: Literal["ArithmeticOperation"]
 
     operation_kind: ArithmeticOperationKind
-    _classical_assignment: bool = PrivateAttr(default=False)
+    classical_assignment: bool = False
 
     @property
     def is_inplace(self) -> bool:
@@ -44,16 +44,20 @@ class ArithmeticOperation(QuantumAssignmentOperation):
         machine_precision: int,
     ) -> None:
         super().initialize_var_types(var_types, machine_precision)
-        self._result_type = compute_arithmetic_result_type(
-            self.expression.expr, var_types, machine_precision
-        )
+        expr_val = self.expression.value.value
+        if isinstance(expr_val, QmodAnnotatedExpression):
+            self._result_type = expr_val.get_quantum_type(expr_val.root)
+        else:
+            self._result_type = NumericAttributes.from_constant(
+                cast(float, expr_val), machine_precision
+            ).to_quantum_numeric()
 
     @property
     def wiring_inouts(
         self,
     ) -> Mapping[str, ConcreteHandleBinding]:
         inouts = dict(super().wiring_inouts)
-        if self.is_inplace and not self._classical_assignment:
+        if self.is_inplace and not self.classical_assignment:
             inouts[self.result_name()] = self.result_var
         return inouts
 
@@ -63,7 +67,7 @@ class ArithmeticOperation(QuantumAssignmentOperation):
             HandleMetadata(handle=handle, readable_location="in an expression")
             for handle in self.var_handles
         ]
-        if self.is_inplace and not self._classical_assignment:
+        if self.is_inplace and not self.classical_assignment:
             inouts.append(
                 HandleMetadata(
                     handle=self.result_var,
@@ -74,13 +78,13 @@ class ArithmeticOperation(QuantumAssignmentOperation):
 
     @property
     def wiring_outputs(self) -> Mapping[str, HandleBinding]:
-        if self.is_inplace or self._classical_assignment:
+        if self.is_inplace or self.classical_assignment:
             return {}
         return super().wiring_outputs
 
     @property
     def readable_outputs(self) -> Sequence[HandleMetadata]:
-        if self.is_inplace or self._classical_assignment:
+        if self.is_inplace or self.classical_assignment:
             return []
         return [
             HandleMetadata(

classiq/interface/model/quantum_type.py

@@ -532,7 +532,7 @@ class QuantumNumeric(QuantumScalar):
 
 
 class RegisterQuantumType(BaseModel):
-    quantum_types: "ConcreteQuantumType"
+    quantum_types: "ConcreteQuantumType" = Field(default_factory=QuantumBitvector)
     size: int = Field(default=1)
 
     @property

classiq/interface/server/routes.py

@@ -44,9 +44,6 @@ TASKS_VISUALIZE_SUFFIX = TASKS_SUFFIX + "/visualize"
 TASKS_VISUAL_MODEL_SUFFIX = TASKS_SUFFIX + "/visual_model"
 TASKS_SOLVE_SUFFIX = "/tasks/solve"
 
-CHEMISTRY_QMOD_PATH = "/generate_model/chemistry/qmod"
-
-
 TASK_TRAIN_SUFFIX = TASKS_SUFFIX + "/train"
 TASK_TEST_SUFFIX = TASKS_SUFFIX + "/test"
 TASK_PREDICT_SUFFIX = TASKS_SUFFIX + "/predict"
@@ -75,6 +72,8 @@ 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
 )
+QASM_TO_QMOD_SUFFIX = "/qasm_to_qmod"
+QASM_TO_QMOD_FULL_PATH = CONVERSION_PREFIX + QASM_TO_QMOD_SUFFIX
 
 STATIC_SEMANTICS_VALIDATION_PATH = "/validate_static_semantics"