classiq 0.82.1__py3-none-any.whl → 0.84.0__py3-none-any.whl

classiq/interface/executor/user_budget.py

@@ -1,9 +1,9 @@
 import datetime
-from collections import defaultdict
 from typing import Optional
 
 import pydantic
 from pydantic import ConfigDict, Field
+from tabulate import tabulate
 
 from classiq.interface.helpers.versioned_model import VersionedModel
 
@@ -15,6 +15,7 @@ class UserBudget(VersionedModel):
     available_budget: float
     used_budget: float
     last_allocation_date: datetime.datetime
+    budget_limit: Optional[float] = Field(default=None)
 
     model_config = ConfigDict(extra="ignore")
 
@@ -22,35 +23,27 @@ class UserBudget(VersionedModel):
 class UserBudgets(VersionedModel):
     budgets: list[UserBudget] = pydantic.Field(default=[])
 
-    def print_budgets(self) -> None:
-        def format_header() -> str:
-            return f"| {'Provider':<20} | {'Available Budget':<18} | {'Used Budget':<18} | {'Currency':<8} |"
-
-        def format_row(
-            provider: str, available: float, used: float, currency: str
-        ) -> str:
-            return f"| {provider:<20} | {available:<18.3f} | {used:<18.3f} | {currency:<8} |"
-
-        table_data: dict = defaultdict(
-            lambda: {"used": 0.0, "available": 0.0, "currency": "USD"}
-        )
-
-        for budget in self.budgets:
-            provider = budget.provider
-            table_data[provider]["available"] += budget.available_budget
-            table_data[provider]["used"] += budget.used_budget
-            table_data[provider]["currency"] = budget.currency_code
-
-        line = "=" * 77
-        print(line)  # noqa: T201
-        print(format_header())  # noqa: T201
-        print(line)  # noqa: T201
-
-        for provider, values in table_data.items():
-            print(  # noqa: T201
-                format_row(
-                    provider, values["available"], values["used"], values["currency"]
-                )
-            )
-
-        print(line)  # noqa: T201
+    def __str__(self) -> str:
+        rows = [
+            [
+                budget.provider,
+                f"{budget.used_budget:.3f}",
+                f"{budget.available_budget:.3f}",
+                (
+                    f"{budget.budget_limit:.3f}"
+                    if budget.budget_limit is not None
+                    else "NOT SET"
+                ),
+                budget.currency_code,
+            ]
+            for budget in self.budgets
+        ]
+
+        headers = [
+            "Provider",
+            "Used Budget",
+            "Remaining Budget",
+            "Budget Limit",
+            "Currency",
+        ]
+        return tabulate(rows, headers=headers, tablefmt="grid")

classiq/interface/generator/application_apis/finance_declarations.py

@@ -9,8 +9,8 @@ from classiq.interface.generator.functions.classical_type import Real
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
+from classiq.interface.generator.functions.type_modifier import TypeModifier
 from classiq.interface.generator.functions.type_name import Struct
-from classiq.interface.generator.functions.type_qualifier import TypeQualifier
 from classiq.interface.model.classical_parameter_declaration import (
     ClassicalParameterDeclaration,
 )
@@ -56,13 +56,13 @@ def _generate_finance_function(
                     )
                 ),
                 direction=PortDeclarationDirection.Inout,
-                type_qualifier=TypeQualifier.Quantum,
+                type_modifier=TypeModifier.Mutable,
             ),
             PortDeclaration(
                 name=OBJECTIVE_PORT_NAME,
                 quantum_type=QuantumBit(),
                 direction=PortDeclarationDirection.Inout,
-                type_qualifier=TypeQualifier.Quantum,
+                type_modifier=TypeModifier.Mutable,
             ),
         ],
     )

classiq/interface/generator/expressions/atomic_expression_functions.py

@@ -11,15 +11,18 @@ CLASSIQ_BUILTIN_CLASSICAL_FUNCTIONS = {
     "molecule_ground_state_solution_post_process",
 }
 
-SUPPORTED_CLASSIQ_BUILTIN_FUNCTIONS = {
-    *CLASSIQ_BUILTIN_CLASSICAL_FUNCTIONS,
+CLASSIQ_EXPR_FUNCTIONS = {
     "do_div",
     "do_slice",
     "do_subscript",
     "get_type",
     "struct_literal",
     "get_field",
-    "mod_inverse",
+}
+
+SUPPORTED_CLASSIQ_BUILTIN_FUNCTIONS = {
+    *CLASSIQ_BUILTIN_CLASSICAL_FUNCTIONS,
+    *CLASSIQ_EXPR_FUNCTIONS,
 }
 
 SUPPORTED_CLASSIQ_SYMPY_WRAPPERS = {
@@ -30,6 +33,11 @@ SUPPORTED_CLASSIQ_SYMPY_WRAPPERS = {
     "LogicalXor",
     "RShift",
     "LShift",
+    "mod_inverse",
+    "min",
+    "Min",
+    "max",
+    "Max",
 }
 
 SUPPORTED_ATOMIC_EXPRESSION_FUNCTIONS = {

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

@@ -21,12 +21,6 @@ def subscript_to_str(index: Any) -> str:
 
 
 class AnyClassicalValue(sympy.Symbol):
-
-    is_commutative = None
-    is_infinite = None
-    is_finite = None
-    is_extended_real = None
-
     def __getitem__(self, item: Any) -> "AnyClassicalValue":
         if isinstance(item, slice):
             return AnyClassicalValue(f"{self}[{subscript_to_str(item)}]")

classiq/interface/generator/functions/classical_type.py

@@ -98,39 +98,6 @@ class Bool(ClassicalType):
         return values_with_discriminator(values, "kind", "bool")
 
 
-class ClassicalList(ClassicalType):
-    kind: Literal["list"]
-    element_type: "ConcreteClassicalType"
-
-    @pydantic.model_validator(mode="before")
-    @classmethod
-    def _set_kind(cls, values: Any) -> dict[str, Any]:
-        return values_with_discriminator(values, "kind", "list")
-
-    def get_classical_proxy(self, handle: HandleBinding) -> ClassicalProxy:
-        return ClassicalArrayProxy(
-            handle, self.element_type, AnyClassicalValue(f"get_field({handle}, 'len')")
-        )
-
-    @property
-    def expressions(self) -> list[Expression]:
-        return self.element_type.expressions
-
-    @property
-    def is_purely_declarative(self) -> bool:
-        return super().is_purely_declarative and self.element_type.is_purely_declarative
-
-    @property
-    def is_purely_generative(self) -> bool:
-        return super().is_purely_generative and self.element_type.is_purely_generative
-
-    def get_raw_type(self) -> "ConcreteClassicalType":
-        raw_type = ClassicalArray(element_type=self.element_type.get_raw_type())
-        if self._is_generative:
-            raw_type.set_generative()
-        return raw_type
-
-
 class StructMetaType(ClassicalType):
     kind: Literal["type_proxy"]
 
@@ -146,8 +113,8 @@ class StructMetaType(ClassicalType):
 class ClassicalArray(ClassicalType):
     kind: Literal["array"]
     element_type: "ConcreteClassicalType"
-    size: Optional[int] = None
-    length: Optional[Expression] = pydantic.Field(exclude=True, default=None)
+    size: Optional[int] = pydantic.Field(exclude=True, default=None)
+    length: Optional[Expression] = None
 
     @pydantic.model_validator(mode="before")
     @classmethod

classiq/interface/generator/functions/concrete_types.py

@@ -5,7 +5,6 @@ from pydantic import Field
 from classiq.interface.generator.functions.classical_type import (
     Bool,
     ClassicalArray,
-    ClassicalList,
     ClassicalTuple,
     Estimation,
     Histogram,
@@ -29,7 +28,6 @@ ConcreteClassicalType = Annotated[
         Integer,
         Real,
         Bool,
-        ClassicalList,
         StructMetaType,
         TypeName,
         ClassicalArray,
@@ -41,7 +39,6 @@ ConcreteClassicalType = Annotated[
     ],
     Field(discriminator="kind"),
 ]
-ClassicalList.model_rebuild()
 ClassicalArray.model_rebuild()
 ClassicalTuple.model_rebuild()
 

classiq/interface/generator/functions/type_modifier.py

@@ -0,0 +1,22 @@
+from classiq.interface.enum_utils import StrEnum
+from classiq.interface.exceptions import ClassiqInternalExpansionError
+
+
+class TypeModifier(StrEnum):
+    Const = "const"
+    Permutable = "permutable"
+    Mutable = "mutable"
+    Inferred = "inferred"
+
+    @staticmethod
+    def and_(first: "TypeModifier", second: "TypeModifier") -> "TypeModifier":
+        if second is TypeModifier.Inferred:
+            raise ClassiqInternalExpansionError
+        if first is TypeModifier.Mutable or second is TypeModifier.Mutable:
+            return TypeModifier.Mutable
+        elif first is TypeModifier.Permutable or second is TypeModifier.Permutable:
+            return TypeModifier.Permutable
+        else:
+            if first is not TypeModifier.Const and second is not TypeModifier.Const:
+                raise ClassiqInternalExpansionError("Unexpected type modifiers")
+            return TypeModifier.Const

classiq/interface/generator/generated_circuit_data.py

@@ -28,8 +28,6 @@ from classiq.interface.model.statement_block import (
 )
 
 from classiq.model_expansions.capturing.mangling_utils import (
-    demangle_capture_name,
-    demangle_name,
     is_captured_var_name,
 )
 
@@ -85,12 +83,6 @@ class GeneratedRegister(pydantic.BaseModel):
     def is_captured(self) -> bool:
         return is_captured_var_name(self.name)
 
-    @staticmethod
-    def demangle_name(name: str) -> str:
-        if is_captured_var_name(name):
-            name = demangle_capture_name(name)
-        return demangle_name(name)
-
 
 class GeneratedFunction(pydantic.BaseModel):
     name: str
@@ -202,8 +194,8 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
     @property
     def name(self) -> str:
         generated_name = self.generated_function.name if self.generated_function else ""
-        # Temp fix for currently "supported" statements (same as for level_ property)
-        if generated_name in {StatementType.CONTROL, StatementType.POWER}:
+        # Temp fix for remaining old "supported" statements - power
+        if generated_name == StatementType.POWER:
             return generated_name
 
         back_ref = self.first_back_ref
@@ -243,8 +235,8 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
 
     @property
     def level(self) -> OperationLevel:
-        # Temp fix for currently "supported" statements
-        if self.name in {StatementType.CONTROL, StatementType.POWER}:
+        # Temp fix for remaining old "supported" statements - power
+        if self.name == StatementType.POWER:
             return OperationLevel.QMOD_STATEMENT
 
         if self.first_back_ref is None:
@@ -275,15 +267,12 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
 
     @property
     def control_qubits(self) -> tuple[int, ...]:
-        control_states_names = {
-            control_state.name for control_state in self.control_states
-        }
         return tuple(
             qubit
             for register in self.registers
             for qubit in register.qubit_indexes_absolute
             if register.role is RegisterRole.INPUT
-            and register.name in control_states_names
+            and register.name == self.control_variable
         )
 
     def propagate_absolute_qubits(self) -> "FunctionDebugInfoInterface":

classiq/interface/generator/model/model.py

@@ -11,6 +11,9 @@ from classiq.interface.generator.types.qstruct_declaration import QStructDeclara
 from classiq.interface.generator.types.struct_declaration import StructDeclaration
 from classiq.interface.helpers.validation_helpers import is_list_unique
 from classiq.interface.helpers.versioned_model import VersionedModel
+from classiq.interface.model.classical_parameter_declaration import (
+    ClassicalParameterDeclaration,
+)
 from classiq.interface.model.quantum_type import RegisterQuantumTypeDict
 
 TYPE_LIBRARY_DUPLICATED_TYPE_NAMES = (
@@ -71,3 +74,8 @@ class ExecutionModel(ClassiqBaseModel):
     register_filter_bitstrings: dict[str, list[str]] = pydantic.Field(
         default_factory=dict,
     )
+
+    circuit_execution_params: dict[str, ClassicalParameterDeclaration] = pydantic.Field(
+        default_factory=dict,
+        description="Mapping between a execution parameter name and its declaration",
+    )

classiq/interface/generator/quantum_program.py

@@ -166,19 +166,6 @@ class QuantumProgram(VersionedModel, CircuitCodeInterface):
         with open(filename, "w") as file:
             file.write(self.model_dump_json(indent=4))
 
-    @classmethod
-    def from_qprog(cls, qprog: "QuantumProgram") -> "QuantumProgram":
-        """
-        Creates a `QuantumProgram` instance from a raw quantum program string.
-
-        Args:
-            qprog: The raw quantum program in string format.
-
-        Returns:
-            QuantumProgram: The `QuantumProgram` instance.
-        """
-        return qprog
-
     @property
     def _can_use_transpiled_code(self) -> bool:
         return self.data.execution_data is None

classiq/interface/generator/types/compilation_metadata.py

@@ -6,9 +6,6 @@ class CompilationMetadata(BaseModel):
     occurrences_number: NonNegativeInt = Field(default=1)
     _occupation_number: NonNegativeInt = PrivateAttr(default=0)
     unchecked: list[str] = Field(default_factory=list)
-    atomic_qualifiers: list[str] = Field(
-        default_factory=list, exclude=True
-    )  # TODO remove after deprecation https://classiq.atlassian.net/browse/CLS-2671                                                                                                                                                                                       atomic_qualifiers: list[str] = Field(default_factory=list)
 
     @property
     def occupation_number(self) -> NonNegativeInt:

classiq/interface/helpers/model_normalizer.py

@@ -5,7 +5,7 @@ from classiq.interface.ast_node import ASTNode
 from classiq.interface.debug_info.debug_info import DebugInfoCollection
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.classical_type import ClassicalType
-from classiq.interface.generator.functions.type_qualifier import TypeQualifier
+from classiq.interface.generator.functions.type_modifier import TypeModifier
 from classiq.interface.generator.visitor import Transformer, Visitor
 from classiq.interface.model.model import Model
 from classiq.interface.model.port_declaration import AnonPortDeclaration
@@ -32,7 +32,7 @@ class ModelNormalizer(Visitor):
         expr.expr = ast.unparse(ExprNormalizer().visit(ast.parse(expr.expr)))
 
     def visit_AnonPortDeclaration(self, decl: AnonPortDeclaration) -> None:
-        decl.type_qualifier = TypeQualifier.Quantum
+        decl.type_modifier = TypeModifier.Mutable
 
 
 class ClearModelInternals(Transformer):

classiq/interface/ide/visual_model.py

@@ -110,7 +110,9 @@ class Operation(pydantic.BaseModel):
     name: str
     qasm_name: str = pydantic.Field(default="")
     details: str = pydantic.Field(default="")
-    children: list["Operation"]
+    children: list["Operation"] = pydantic.Field(default_factory=list)
+    # children_ids is optional in order to support backwards compatibility.
+    children_ids: list[int] = pydantic.Field(default_factory=list)
     operation_data: Optional[OperationData] = None
     operation_links: OperationLinks
     control_qubits: tuple[int, ...] = pydantic.Field(default_factory=tuple)
@@ -129,5 +131,7 @@ class Operation(pydantic.BaseModel):
 
 
 class ProgramVisualModel(VersionedModel):
-    main_operation: Operation
+    main_operation: Operation = pydantic.Field(default=None)
+    id_to_operations: dict[int, Operation] = pydantic.Field(default_factory=dict)
+    main_operation_id: int = pydantic.Field(default=None)
     program_data: ProgramData

classiq/interface/model/model.py

@@ -185,11 +185,16 @@ class Model(VersionedModel, ASTNode):
         return constants
 
     def dump_no_metadata(self) -> dict[str, Any]:
-        return self.model_dump(
-            exclude={
-                "constraints",
-                "execution_preferences",
-                "preferences",
-                "functions_compilation_metadata",
-            },
+        compilation_metadata_with_unchecked = {
+            name: CompilationMetadata(unchecked=comp_metadata.unchecked)
+            for name, comp_metadata in self.functions_compilation_metadata.items()
+            if len(comp_metadata.unchecked) > 0
+        }
+        model = self.model_copy(
+            update={
+                "functions_compilation_metadata": compilation_metadata_with_unchecked,
+            }
+        )
+        return model.model_dump(
+            exclude={"constraints", "execution_preferences", "preferences"},
         )

classiq/interface/model/port_declaration.py

@@ -8,7 +8,9 @@ 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.generator.functions.type_modifier import (
+    TypeModifier,
+)
 from classiq.interface.helpers.pydantic_model_helpers import values_with_discriminator
 from classiq.interface.model.parameter import Parameter
 
@@ -16,8 +18,8 @@ from classiq.interface.model.parameter import Parameter
 class AnonPortDeclaration(Parameter):
     quantum_type: ConcreteQuantumType
     direction: PortDeclarationDirection
-    type_qualifier: TypeQualifier
     kind: Literal["PortDeclaration"]
+    type_modifier: TypeModifier
 
     @pydantic.model_validator(mode="before")
     @classmethod

classiq/{qmod/native → interface/pretty_print}/expression_to_qmod.py

@@ -6,7 +6,7 @@ from typing import Callable, Optional
 
 import numpy as np
 
-from classiq.qmod.utilities import DEFAULT_DECIMAL_PRECISION
+from classiq.interface.constants import DEFAULT_DECIMAL_PRECISION
 
 IDENTIFIER = re.compile(r"[a-zA-Z_]\w*")
 BINARY_OPS: Mapping[type[ast.operator], str] = {
@@ -40,6 +40,10 @@ COMPARE_OPS: Mapping[type[ast.cmpop], str] = {
 LIST_FORMAT_CHAR_LIMIT = 20
 
 
+class PrettyPrinterError(AssertionError):
+    pass
+
+
 @dataclass
 class ASTToQMODCode:
     level: int
@@ -59,10 +63,13 @@ class ASTToQMODCode:
         elif isinstance(node, ast.Attribute):
             # Enum attribute access
             if not isinstance(node.value, ast.Name) or not isinstance(node.attr, str):
-                raise AssertionError("Error parsing enum attribute access")
+                raise PrettyPrinterError("Error parsing enum attribute access")
             if not (IDENTIFIER.match(node.value.id) and IDENTIFIER.match(node.attr)):
-                raise AssertionError("Error parsing enum attribute access")
-            return f"{node.value.id!s}::{node.attr!s}"
+                raise PrettyPrinterError("Error parsing enum attribute access")
+            # FIXME: identify enum member accesses by type name (CLS-2858)
+            if len(node.value.id) > 0 and node.value.id[0].isupper():
+                return f"{node.value.id!s}::{node.attr!s}"
+            return f"{node.value.id!s}.{node.attr!s}"
         elif isinstance(node, ast.Name):
             return node.id
         elif isinstance(node, ast.Num):
@@ -91,7 +98,7 @@ class ASTToQMODCode:
             )
         elif isinstance(node, ast.Compare):
             if len(node.ops) != 1 or len(node.comparators) != 1:
-                raise AssertionError("Error parsing comparison expression.")
+                raise PrettyPrinterError("Error parsing comparison expression.")
             return "({} {} {})".format(
                 self.ast_to_code(node.left),
                 COMPARE_OPS[type(node.ops[0])],
@@ -108,20 +115,20 @@ class ASTToQMODCode:
         elif isinstance(node, ast.Slice):
             # A QMOD expression does not support slice step
             if node.lower is None or node.upper is None or node.step is not None:
-                raise AssertionError("Error parsing slice expression.")
+                raise PrettyPrinterError("Error parsing slice expression.")
             return f"{self.ast_to_code(node.lower)}:{self.ast_to_code(node.upper)}"
         elif isinstance(node, ast.Call):
             func = self.ast_to_code(node.func)
             if func == "get_field":
                 if len(node.args) != 2:
-                    raise AssertionError("Error parsing struct field access.")
+                    raise PrettyPrinterError("Error parsing struct field access.")
                 field = str(self.ast_to_code(node.args[1])).replace("'", "")
                 if not IDENTIFIER.match(field):
-                    raise AssertionError("Error parsing struct field access.")
+                    raise PrettyPrinterError("Error parsing struct field access.")
                 return f"{self.ast_to_code(node.args[0])}.{field}"
             elif func == "struct_literal":
                 if len(node.args) != 1 or not isinstance(node.args[0], ast.Name):
-                    raise AssertionError("Error parsing struct literal.")
+                    raise PrettyPrinterError("Error parsing struct literal.")
                 keywords = node.keywords
                 initializer_list = self.indent_items(
                     lambda: [
@@ -133,7 +140,7 @@ class ASTToQMODCode:
                 return f"{self.ast_to_code(node.args[0])} {{{initializer_list}}}"
             elif func == "do_subscript":
                 if len(node.args) != 2:
-                    raise AssertionError("Error parsing array access.")
+                    raise PrettyPrinterError("Error parsing array access.")
                 return f"{self.ast_to_code(node.args[0])}[{self.ast_to_code(node.args[1])}]"
             else:
                 return "{}({})".format(
@@ -142,7 +149,7 @@ class ASTToQMODCode:
         elif isinstance(node, ast.Expr):
             return self._cleaned_ast_to_code(node.value)
         else:
-            raise AssertionError("Error parsing expression: unsupported AST node.")
+            raise PrettyPrinterError("Error parsing expression: unsupported AST node.")
 
     def indent_items(self, items: Callable[[], list[str]]) -> str:
         should_indent = (

classiq/interface/server/routes.py

@@ -91,3 +91,7 @@ IQCC_LIST_AUTH_TARGETS_FULL_PATH = IQCC_PREFIX + IQCC_LIST_AUTH_TARGETS_SUFFIX
 
 USER_BUDGETS_SUFFIX = "/all"
 USER_BUDGETS_FULL_PATH = USER_BUDGETS_PREFIX + USER_BUDGETS_SUFFIX
+USER_BUDGET_SET_LIMIT_SUFFIX = "/set_limit"
+USER_BUDGET_SET_LIMIT_FULL_PATH = USER_BUDGETS_PREFIX + USER_BUDGET_SET_LIMIT_SUFFIX
+USER_BUDGET_CLEAR_LIMIT_SUFFIX = "/clear_limit"
+USER_BUDGET_CLEAR_LIMIT_FULL_PATH = USER_BUDGETS_PREFIX + USER_BUDGET_CLEAR_LIMIT_SUFFIX

classiq/model_expansions/atomic_expression_functions_defs.py

@@ -39,7 +39,6 @@ from classiq.interface.generator.functions.classical_function_declaration import
 from classiq.interface.generator.functions.classical_type import (
     Bool,
     ClassicalArray,
-    ClassicalList,
     ClassicalTuple,
     ClassicalType,
     OpaqueHandle,
@@ -91,7 +90,7 @@ def qmod_val_to_python(val: ExpressionValue, qmod_type: ClassicalType) -> Any:
         if isinstance(val, (Enum, int)):
             return val
 
-    elif isinstance(qmod_type, (ClassicalArray, ClassicalList)):
+    elif isinstance(qmod_type, ClassicalArray):
         if isinstance(val, list):
             return [qmod_val_to_python(elem, qmod_type.element_type) for elem in val]
 
@@ -145,9 +144,9 @@ def python_val_to_qmod(val: Any, qmod_type: ClassicalType) -> ExpressionValue:
             field_name: python_val_to_qmod(val[field_name], field_type)
             for field_name, field_type in struct_decl.variables.items()
         }
-        return QmodStructInstance(struct_decl.model_copy(), qmod_dict)
+        return QmodStructInstance(struct_decl.model_copy(deep=True), qmod_dict)
 
-    if isinstance(qmod_type, (ClassicalList, ClassicalArray)):
+    if isinstance(qmod_type, ClassicalArray):
         if not isinstance(val, list):
             raise ClassiqInternalExpansionError("Bad value for list")
         return [python_val_to_qmod(elem, qmod_type.element_type) for elem in val]
@@ -182,7 +181,7 @@ def python_call_wrapper(func: Callable, *args: ExpressionValue) -> Any:
 
 def struct_literal(struct_type_symbol: Symbol, **kwargs: Any) -> QmodStructInstance:
     return QmodStructInstance(
-        QMODULE.type_decls[struct_type_symbol.name].model_copy(),
+        QMODULE.type_decls[struct_type_symbol.name].model_copy(deep=True),
         {field: sympy_to_python(field_value) for field, field_value in kwargs.items()},
     )
 
@@ -330,6 +329,40 @@ def mod_inverse(a: Any, b: Any) -> Any:
     return sympy.mod_inverse(a, b)
 
 
+def min_wrapper(*vals: Any) -> Any:
+    try:
+        return sympy.Min(*vals)
+    except ValueError:
+        return AnyClassicalValue(f"Min({', '.join(map(str, vals))})")
+
+
+min_wrapper.__name__ = "min"
+
+
+def Min_wrapper(*vals: Any) -> Any:  # noqa: N802
+    return min_wrapper(*vals)
+
+
+Min_wrapper.__name__ = "Min"
+
+
+def max_wrapper(*vals: Any) -> Any:
+    try:
+        return sympy.Max(*vals)
+    except ValueError:
+        return AnyClassicalValue(f"Max({', '.join(map(str, vals))})")
+
+
+max_wrapper.__name__ = "max"
+
+
+def Max_wrapper(*vals: Any) -> Any:  # noqa: N802
+    return max_wrapper(*vals)
+
+
+Max_wrapper.__name__ = "Max"
+
+
 CORE_LIB_FUNCTIONS_LIST: list[Callable] = [
     print,
     do_sum,
@@ -347,6 +380,10 @@ CORE_LIB_FUNCTIONS_LIST: list[Callable] = [
     RShift,
     LShift,
     mod_inverse,
+    min_wrapper,
+    Min_wrapper,
+    max_wrapper,
+    Max_wrapper,
 ]