classiq 0.41.2__py3-none-any.whl → 0.42.0__py3-none-any.whl

classiq/applications/chemistry/chemistry_model_constructor.py

@@ -6,6 +6,12 @@ from classiq.interface.chemistry.fermionic_operator import (
     FermionicOperator,
     SummedFermionicOperator,
 )
+from classiq.qmod.builtins.structs import (
+    MoleculeProblem as QmodMoleculeProblem,
+    Molecule as QmodMolecule,
+    ChemistryAtom as QmodChemistryAtom,
+    Position as QmodPosition,
+)
 from classiq.interface.chemistry.ground_state_problem import (
     CHEMISTRY_PROBLEMS_TYPE,
     HamiltonianProblem,
@@ -185,42 +191,36 @@ _HAE_GATE_MAPPING: Dict[str, QuantumFunctionCall] = {
 }
 
 
-def _atoms_to_qmod_atoms(atoms: List[Atom]) -> str:
-    # fmt: off
-    atom_struct_literals = [
-        "struct_literal(ChemistryAtom,"
-            f"element={Element[atom.symbol]},"
-            "position=struct_literal(Position,"
-                f"x={atom.x},"
-                f"y={atom.y},"
-                f"z={atom.z}"
-            ")"
-        ")"
+def _atoms_to_qmod_atoms(atoms: List[Atom]) -> List[QmodChemistryAtom]:
+    return [
+        QmodChemistryAtom(
+            element=Element[atom.symbol],
+            position=QmodPosition(
+                x=atom.x,  # type:ignore[arg-type]
+                y=atom.y,  # type:ignore[arg-type]
+                z=atom.z,  # type:ignore[arg-type]
+            ),
+        )
         for atom in atoms
     ]
-    # fmt: on
-    return ",".join(atom_struct_literals)
 
 
 def molecule_problem_to_qmod(
     molecule_problem: MoleculeProblem,
-) -> str:
-    # fmt: off
-    return (
-        "struct_literal("
-        "MoleculeProblem,"
-        f"mapping={FermionMapping[molecule_problem.mapping.value.upper()]},"
-        f"z2_symmetries={molecule_problem.z2_symmetries},"
-        "molecule=struct_literal("
-        "Molecule,"
-        f"atoms=[{_atoms_to_qmod_atoms(molecule_problem.molecule.atoms)}],"
-        f"spin={molecule_problem.molecule.spin},"
-        f"charge={molecule_problem.molecule.charge}"
-        "),"
-        f"freeze_core={molecule_problem.freeze_core},"
-        f"remove_orbitals={molecule_problem.remove_orbitals}"
-        ")")
-    # fmt: on
+) -> QmodMoleculeProblem:
+    return QmodMoleculeProblem(
+        mapping=FermionMapping[molecule_problem.mapping.value.upper()],
+        z2_symmetries=molecule_problem.z2_symmetries,  # type:ignore[arg-type]
+        molecule=QmodMolecule(
+            atoms=_atoms_to_qmod_atoms(
+                molecule_problem.molecule.atoms
+            ),  # type:ignore[arg-type]
+            spin=molecule_problem.molecule.spin,  # type:ignore[arg-type]
+            charge=molecule_problem.molecule.charge,  # type:ignore[arg-type]
+        ),
+        freeze_core=molecule_problem.freeze_core,  # type:ignore[arg-type]
+        remove_orbitals=molecule_problem.remove_orbitals,  # type:ignore[arg-type]
+    )
 
 
 def _fermionic_operator_to_qmod_ladder_ops(
@@ -271,7 +271,7 @@ def _hamiltonian_problem_to_qmod_fock_hamiltonian_problem(
 
 def _convert_library_problem_to_qmod_problem(problem: CHEMISTRY_PROBLEMS_TYPE) -> str:
     if isinstance(problem, MoleculeProblem):
-        return molecule_problem_to_qmod(problem)
+        return str(molecule_problem_to_qmod(problem))
     elif isinstance(problem, HamiltonianProblem):
         return _hamiltonian_problem_to_qmod_fock_hamiltonian_problem(problem)
     else:

classiq/execution/execution_session.py

@@ -1,5 +1,5 @@
 import json
-from typing import Any, Callable, Dict, List, Optional, Union, cast
+from typing import Any, Callable, Dict, List, Optional, Tuple, Union, cast
 
 from classiq.interface.executor.execution_preferences import ExecutionPreferences
 from classiq.interface.executor.execution_result import ResultsCollection
@@ -24,7 +24,12 @@ from classiq.synthesis import SerializedQuantumProgram
 
 Hamiltonian = Union[List[QmodPyStruct], List[PauliTerm]]
 Program = Union[SerializedQuantumProgram, QuantumProgram]
-ExecutionParameters = Union[None, ExecutionParams, List[ExecutionParams]]
+ParsedExecutionParams = Dict[str, Union[float, int]]
+ExecutionParameters = Optional[Union[ExecutionParams, List[ExecutionParams]]]
+ParsedExecutionParameters = Optional[
+    Union[ParsedExecutionParams, List[ParsedExecutionParams]]
+]
+
 
 SAVE_RESULT = "\nsave({'result': result})\n"
 
@@ -52,8 +57,42 @@ def to_hamiltonian_str(hamiltonian: Hamiltonian) -> str:
     )
 
 
+def serialize(
+    item: Union[float, int, Tuple[int, ...], Tuple[float, ...]]
+) -> Union[str, List]:
+    if isinstance(item, tuple):
+        return list(item)
+    return str(item)
+
+
+def parse_params(params: ExecutionParams) -> ParsedExecutionParams:
+    result = {}
+    for key, values in params.items():
+        if isinstance(values, list):
+            for index, value in enumerate(values):
+                new_key = f"{key}_{index}"
+                result[new_key] = value
+        elif isinstance(values, (int, float)):
+            result[key] = values
+        else:
+            raise TypeError("Parameters were provided in un-supported format")
+    return result
+
+
 def format_parameters(execution_params: ExecutionParameters) -> str:
-    return json.dumps(execution_params, default=str) if execution_params else ""
+    parsed_parameters: ParsedExecutionParameters = None
+    if execution_params is None:
+        return ""
+    if isinstance(execution_params, dict):
+        parsed_parameters = parse_params(execution_params)
+
+    elif isinstance(execution_params, list):
+        parsed_parameters = [
+            parse_params(ep) if isinstance(ep, dict) else ep for ep in execution_params
+        ]
+
+    execution_params = cast(ExecutionParams, parsed_parameters)
+    return json.dumps(execution_params, default=serialize, indent=2)
 
 
 def create_estimate_execution_code(operation: str, **kwargs: Any) -> str:

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

classiq/interface/analyzer/analysis_params.py

@@ -2,7 +2,8 @@ from typing import Dict, List, Optional
 
 import numpy
 import pydantic
-from pydantic import Field
+from pydantic import Field, conint, constr
+from typing_extensions import Annotated
 
 from classiq.interface.backend.quantum_backend_providers import AnalyzerProviderVendor
 from classiq.interface.chemistry.ground_state_problem import MoleculeProblem
@@ -17,6 +18,12 @@ from classiq.interface.helpers.custom_pydantic_types import PydanticNonEmptyStri
 MAX_KB_OF_FILE = 500
 MAX_FILE_LENGTH = MAX_KB_OF_FILE * 1024
 
+MAX_QUBITS = 100
+MIN_QUBITS = 0
+MAX_COUNTS = 1000
+MAX_NUM_CLIFFORD = 1000
+MAX_NAME_LENGTH = 100
+
 
 class AnalysisParams(pydantic.BaseModel):
     qasm: PydanticNonEmptyString = Field(..., max_length=MAX_FILE_LENGTH)
@@ -40,13 +47,16 @@ class HardwareListParams(pydantic.BaseModel):
 
 class AnalysisOptionalDevicesParams(HardwareListParams):
     qubit_count: int = pydantic.Field(
-        default=..., description="number of qubits in the data"
+        default=...,
+        description="number of qubits in the data",
+        ge=MIN_QUBITS,
+        le=MAX_QUBITS,
     )
 
 
 class GateNamsMapping(pydantic.BaseModel):
-    qasm_name: str
-    display_name: str
+    qasm_name: Annotated[str, constr(max_length=MAX_NAME_LENGTH)]
+    display_name: Annotated[str, constr(max_length=MAX_NAME_LENGTH)]
 
 
 class LatexParams(AnalysisParams):
@@ -81,8 +91,8 @@ class CircuitAnalysisHardwareParams(AnalysisParams):
 
 class AnalysisRBParams(pydantic.BaseModel):
     hardware: str
-    counts: List[Dict[str, int]]
-    num_clifford: List[int]
+    counts: List[Dict[str, Annotated[int, conint(strict=True, gt=0, le=MAX_COUNTS)]]]
+    num_clifford: List[Annotated[int, conint(strict=True, gt=0, le=MAX_NUM_CLIFFORD)]]
 
 
 class ChemistryGenerationParams(pydantic.BaseModel):

classiq/interface/analyzer/result.py

@@ -5,6 +5,7 @@ import pydantic
 from pydantic import Field
 from typing_extensions import Annotated
 
+from classiq.interface.analyzer.analysis_params import MAX_FILE_LENGTH
 from classiq.interface.helpers.custom_pydantic_types import PydanticNonEmptyString
 from classiq.interface.helpers.versioned_model import VersionedModel
 
@@ -38,7 +39,7 @@ class DataID(pydantic.BaseModel):
 
 
 class QasmCode(pydantic.BaseModel):
-    code: str
+    code: str = Field(..., max_length=MAX_FILE_LENGTH)
 
 
 class AnalysisStatus(StrEnum):

classiq/interface/ast_node.py

@@ -20,9 +20,9 @@ class SourceReference(HashablePydanticBaseModel):
             f"file {os.path.basename(self.file_name)} " if self.file_name else ""
         )
         start_character_string = (
-            f" character {self.start_column}" if self.start_column else ""
+            f" character {self.start_column + 1}" if self.start_column > 0 else ""
         )
-        return f"{file_string}line {self.start_line}{start_character_string}"
+        return f"{file_string}line {self.start_line + 1}{start_character_string}"
 
 
 class ASTNode(HashablePydanticBaseModel):

classiq/interface/backend/pydantic_backend.py

@@ -40,9 +40,7 @@ else:
         regex=f"[A-Za-z0-9]{{{_IONQ_API_KEY_LENGTH}}}"
     )
 
-    PydanticAliceBobApiKeyType = pydantic.constr(
-        regex=f"[A-Za-z0-9]{{{_ALICE_BOB_API_KEY_LENGTH}}}"
-    )
+    PydanticAliceBobApiKeyType = pydantic.constr(min_length=1, strip_whitespace=True)
 
     PydanticExecutionTimeout = pydantic.conint(gt=0, le=MAX_EXECUTION_TIMEOUT_SECONDS)
 

classiq/interface/chemistry/fermionic_operator.py

@@ -39,7 +39,10 @@ class FermionicOperator(HashablePydanticBaseModel):
     """
 
     op_list: list = pydantic.Field(
-        description="A list of tuples each containing an index and a character; for example [('+', 0), ('-', 1)].",
+        description=(
+            "A list of tuples each containing an index and a character; for "
+            "example [('+', 0), ('-', 1)]."
+        ),
     )
 
     @staticmethod
@@ -51,20 +54,27 @@ class FermionicOperator(HashablePydanticBaseModel):
                 raise ClassiqValueError("Ladder operator should be a tuple.") from exc
         if len(op) != 2:
             raise ClassiqValueError(
-                "Ladder operator tuple should be of length two; for example (1, '+')."
+                "Ladder operator tuple should be of length two; for example ('+', 1)."
             )
 
-        if op[0] not in ("+", "-"):
+        op_symbol = op[0]
+        if op_symbol == "LadderOperator.PLUS":
+            op_symbol = "+"
+        elif op_symbol == "LadderOperator.MINUS":
+            op_symbol = "-"
+        if op_symbol not in ("+", "-"):
             raise ClassiqValueError(
-                "The first term in a ladder operator tuple indicates if its a raising ('+')"
-                f" or lowering ('-') operator. Allowed input is: '+' or '-', received {op[0]}"
+                f"The first term in a ladder operator tuple indicates if its a raising "
+                f"(LadderOperator.PLUS / '+') or lowering (LadderOperator.MINUS / '-') "
+                f"operator. Received {op_symbol}"
             )
-        if not isinstance(op[1], int):
+        op_index = op[1]
+        if not isinstance(op_index, int):
             raise ClassiqValueError(
                 "The second term in a ladder operator tuple indicates its index and should be of type int"
             )
 
-        return op  # type: ignore[return-value] # mypy thinks that it is `Tuple[Any, ...]`, though the asserts here tell otherwise..
+        return (op_symbol, op_index)
 
     @pydantic.validator("op_list")
     def _validate_op_list(cls, op_list: list) -> list:

classiq/interface/generator/amplitude_loading.py

@@ -9,6 +9,7 @@ from classiq.interface.generator.arith.arithmetic_expression_validator import (
 )
 from classiq.interface.generator.arith.register_user_input import RegisterUserInput
 from classiq.interface.generator.expressions.expression_constants import (
+    BOOLEAN_LITERALS,
     FORBIDDEN_LITERALS,
     SUPPORTED_FUNC_NAMES,
     SUPPORTED_VAR_NAMES_REG,
@@ -36,6 +37,12 @@ class AmplitudeLoading(FunctionParams):
     size: pydantic.PositiveInt = pydantic.Field(
         description="The number of qubits of the amplitude input."
     )
+    fraction_digits: pydantic.NonNegativeInt = pydantic.Field(
+        description="The number of fraction digits of the amplitude input."
+    )
+    is_signed: bool = pydantic.Field(
+        description="Whether the amplitude input has a sign qubit."
+    )
     expression: PydanticExpressionStr = pydantic.Field(
         description="The mathematical expression of the amplitude loading function."
     )
@@ -64,8 +71,8 @@ class AmplitudeLoading(FunctionParams):
         expression = values.get("expression", "")
         literals = set(re.findall(SUPPORTED_VAR_NAMES_REG, expression))
 
-        not_allowed = literals.intersection(FORBIDDEN_LITERALS)
-        variables = literals.difference(SUPPORTED_FUNC_NAMES)
+        not_allowed = literals.intersection(FORBIDDEN_LITERALS) - BOOLEAN_LITERALS
+        variables = literals.difference(SUPPORTED_FUNC_NAMES) - BOOLEAN_LITERALS
         if not_allowed:
             raise ClassiqValueError(
                 f"The following names: {not_allowed} are not allowed"
@@ -89,5 +96,7 @@ class AmplitudeLoading(FunctionParams):
 
     @property
     def variable(self) -> str:
-        literals = set(re.findall(SUPPORTED_VAR_NAMES_REG, self.expression))
+        literals = (
+            set(re.findall(SUPPORTED_VAR_NAMES_REG, self.expression)) - BOOLEAN_LITERALS
+        )
         return list(literals.difference(SUPPORTED_FUNC_NAMES))[0]

classiq/interface/generator/application_apis/finance_declarations.py

@@ -1,5 +1,5 @@
 from enum import Enum
-from typing import Mapping
+from typing import TYPE_CHECKING, Callable, Mapping
 
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.classical_function_declaration import (
@@ -21,6 +21,10 @@ from classiq.interface.model.quantum_function_declaration import (
     QuantumFunctionDeclaration,
 )
 
+if TYPE_CHECKING:
+    from classiq.qmod.builtins.structs import GaussianModel
+    from classiq.qmod.symbolic_expr import SymbolicExpr
+
 FUNCTION_PORT_NAME = "func_port"
 OBJECTIVE_PORT_NAME = "obj_port"
 
@@ -36,6 +40,23 @@ FINANCE_FUNCTION_PORT_SIZE_MAPPING: Mapping[FinanceModelType, str] = {
 }
 
 
+def _get_gaussian_size(finance_model: "GaussianModel") -> "SymbolicExpr":
+    from classiq.qmod.symbolic import floor, log, sum as sym_sum
+
+    return (
+        finance_model.num_qubits
+        + finance_model.rhos.len
+        + floor(log(sym_sum(finance_model.loss), 2))
+        + 1
+    )
+
+
+FINANCE_FUNCTION_PORT_SIZE_FUNCTION_MAPPING: Mapping[FinanceModelType, Callable] = {
+    FinanceModelType.Gaussian: _get_gaussian_size,
+    FinanceModelType.LogNormal: lambda finance_model: finance_model.num_qubits,
+}
+
+
 def _generate_finance_function(
     finance_model: FinanceModelType,
 ) -> QuantumFunctionDeclaration:

classiq/interface/generator/expressions/atomic_expression_functions.py

@@ -1,8 +1,9 @@
 from classiq.interface.generator.functions.classical_type import CLASSICAL_ATTRIBUTES
 
-SUPPORTED_BUILTIN_FUNCTIONS = {"len", "sum", "print"}
+SUPPORTED_BUILTIN_FUNCTIONS = ["len", "sum", "print"]
 
 SUPPORTED_ATOMIC_EXPRESSION_FUNCTIONS = {
+    "do_subscript",
     "hypercube_entangler_graph",
     "grid_entangler_graph",
     "qft_const_adder_phase",

classiq/interface/generator/expressions/enums/classical_enum.py

@@ -1,4 +1,7 @@
 import enum
+from typing import Any, Mapping
+
+from classiq.interface.helpers.classproperty import classproperty
 
 
 class ClassicalEnum(int, enum.Enum):
@@ -7,3 +10,11 @@ class ClassicalEnum(int, enum.Enum):
 
     def __repr__(self) -> str:
         return str(self)
+
+    @classproperty
+    def type_name(cls) -> str:  # noqa: N805
+        return "Enum"
+
+    @classproperty
+    def fields(cls) -> Mapping[str, Any]:  # noqa: N805
+        return {i.name: i for i in cls}  # type:ignore[attr-defined]

classiq/interface/generator/expressions/enums/ladder_operator.py

@@ -1,16 +1,6 @@
-from typing_extensions import assert_never
-
 from classiq.interface.generator.expressions.enums.classical_enum import ClassicalEnum
 
 
 class LadderOperator(ClassicalEnum):
     PLUS = 0
     MINUS = 1
-
-    def __str__(self) -> str:
-        if self is LadderOperator.PLUS:
-            return "+"
-        elif self is LadderOperator.MINUS:
-            return "-"
-        else:
-            assert_never(self)

classiq/interface/generator/expressions/expression_constants.py

@@ -16,4 +16,5 @@ SUPPORTED_FUNC_NAMES: Set[str] = (
     .union(DEFAULT_SUPPORTED_FUNC_NAMES)
     .union(set(SYMPY_SUPPORTED_EXPRESSIONS))
 )
+BOOLEAN_LITERALS = {"True", "False"}
 FORBIDDEN_LITERALS: Set[str] = set(keyword.kwlist) - SUPPORTED_FUNC_NAMES

classiq/interface/generator/expressions/qmod_qarray_proxy.py

@@ -1,4 +1,4 @@
-from typing import Optional, Tuple, Union
+from typing import Any, Mapping, Optional, Tuple, Union
 
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.expressions.qmod_sized_proxy import QmodSizedProxy
@@ -56,6 +56,10 @@ class QmodQArrayProxy(QmodSizedProxy):
             return self._slice[0] + start, self._slice[0] + end
         return start, end
 
+    @property
+    def type_name(self) -> str:
+        return "Quantum array"
+
     @property
     def index(self) -> Optional[int]:
         return self._index
@@ -81,9 +85,18 @@ class QmodQArrayProxy(QmodSizedProxy):
 
         return HandleBinding(name=self._name)
 
+    @property
+    def fields(self) -> Mapping[str, Any]:
+        return {
+            "len": self.len,
+        }
+
     def __len__(self) -> int:
         if (slice_ := self.slice) is not None:
             return slice_[1] - slice_[0]
         elif self.index is not None:
             return 1
         return self._size
+
+    def __str__(self) -> str:
+        return str(self.handle)

classiq/interface/generator/expressions/qmod_qscalar_proxy.py

@@ -20,11 +20,12 @@ class QmodQScalarProxy(Symbol, QmodSizedProxy):
 
 
 class QmodQBitProxy(QmodQScalarProxy):
-    pass
+    @property
+    def type_name(self) -> str:
+        return "Quantum bit"
 
 
 class QmodQNumProxy(QmodQScalarProxy):
-
     def __init__(
         self, name: str, size: int, fraction_digits: int, is_signed: bool
     ) -> None:
@@ -32,6 +33,10 @@ class QmodQNumProxy(QmodQScalarProxy):
         self._fraction_digits = fraction_digits
         self._is_signed = is_signed
 
+    @property
+    def type_name(self) -> str:
+        return "Quantum numeric"
+
     @property
     def size(self) -> int:
         return self._size

classiq/interface/generator/expressions/qmod_sized_proxy.py

@@ -13,6 +13,13 @@ class QmodSizedProxy:
     def __len__(self) -> int:
         return self._size
 
+    def __str__(self) -> str:
+        return str(self.handle)
+
+    @property
+    def type_name(self) -> str:
+        raise NotImplementedError
+
     @property
     def handle(self) -> "HandleBinding":
         raise ClassiqNotImplementedError("cannot compute handle")
@@ -23,6 +30,4 @@ class QmodSizedProxy:
 
     @property
     def fields(self) -> Mapping[str, Any]:
-        return {
-            "len": self.len,
-        }
+        return {}

classiq/interface/generator/expressions/qmod_struct_instance.py

@@ -16,9 +16,20 @@ class QmodStructInstance:
         self.struct_declaration = struct_declaration
         self._fields = fields
 
+    @property
+    def type_name(self) -> str:
+        return f"Struct {self.struct_declaration.name}"
+
     @property
     def fields(self) -> Mapping[str, Any]:
         return types.MappingProxyType(self._fields)
 
+    def __str__(self) -> str:
+        return repr(self)
+
     def __repr__(self) -> str:
-        return repr(self._fields)
+        fields = ", ".join(
+            f"{field_name}={field_value}"
+            for field_name, field_value in self._fields.items()
+        )
+        return f"{self.struct_declaration.name}({fields})"