classiq 0.46.1__py3-none-any.whl → 0.47.0__py3-none-any.whl

classiq/interface/generator/arith/register_user_input.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, Optional
+from typing import Any, Dict, Optional, Tuple
 
 import pydantic
 
@@ -14,6 +14,7 @@ class RegisterArithmeticInfo(HashablePydanticBaseModel):
     size: pydantic.PositiveInt
     is_signed: bool = pydantic.Field(default=False)
     fraction_places: pydantic.NonNegativeInt = pydantic.Field(default=0)
+    bypass_bounds_validation: bool = pydantic.Field(default=False)
     bounds: PydanticFloatTuple = pydantic.Field(default=None)
 
     @pydantic.root_validator(pre=True)
@@ -22,32 +23,39 @@ class RegisterArithmeticInfo(HashablePydanticBaseModel):
             values.pop("name")
         return values
 
+    @staticmethod
+    def get_maximal_bounds(
+        *, size: int, is_signed: bool, fraction_places: int
+    ) -> Tuple[float, float]:
+        lb = 0 if not is_signed else -(2 ** (size - 1))
+        ub = 2**size - 1 if not is_signed else 2 ** (size - 1) - 1
+        fraction_factor = float(2**-fraction_places)
+        return (lb * fraction_factor, ub * fraction_factor)
+
     @pydantic.validator("bounds", always=True)
     def _validate_bounds(
         cls, bounds: Optional[PydanticFloatTuple], values: Dict[str, Any]
     ) -> PydanticFloatTuple:
-        if bounds is not None:
-            if min(bounds) < 0:
-                assert values.get("is_signed")
-            fraction_places = values.get("fraction_places")
-            if not isinstance(fraction_places, int):
-                raise ClassiqValueError(
-                    "RegisterUserInput must have an integer fraction_places"
-                )
-            return number_utils.limit_fraction_places(
-                min(bounds), machine_precision=fraction_places
-            ), number_utils.limit_fraction_places(
-                max(bounds), machine_precision=fraction_places
-            )
-
         size = values.get("size")
+        is_signed = values.get("is_signed", False)
+        fraction_places = values.get("fraction_places", 0)
         if not isinstance(size, int):
-            raise ClassiqValueError("RegisterUserInput must have an integer size")
-        is_signed: bool = values.get("is_signed", False)
-        lb = 0 if not is_signed else -(2 ** (size - 1))
-        ub = 2**size - 1 if not is_signed else 2 ** (size - 1) - 1
-        fraction_factor = float(2 ** -values.get("fraction_places", 0))
-        return (lb * fraction_factor, ub * fraction_factor)
+            raise ClassiqValueError("RegisterArithmeticInfo must have an integer size")
+
+        maximal_bounds = cls.get_maximal_bounds(
+            size=size, is_signed=is_signed, fraction_places=fraction_places
+        )
+        if bounds is None:
+            return maximal_bounds
+
+        trimmed_bounds = (
+            number_utils.limit_fraction_places(min(bounds), fraction_places),
+            number_utils.limit_fraction_places(max(bounds), fraction_places),
+        )
+        if not values.get("bypass_bounds_validation", False):
+            assert min(trimmed_bounds) >= min(maximal_bounds), "Illegal bound min"
+            assert max(trimmed_bounds) <= max(maximal_bounds), "Illegal bound max"
+        return trimmed_bounds
 
     def limit_fraction_places(self, machine_precision: int) -> "RegisterArithmeticInfo":
         truncated_bits: int = max(self.fraction_places - machine_precision, 0)
@@ -56,6 +64,7 @@ class RegisterArithmeticInfo(HashablePydanticBaseModel):
             is_signed=self.is_signed,
             fraction_places=self.fraction_places - truncated_bits,
             bounds=self.bounds,
+            bypass_bounds_validation=self.bypass_bounds_validation,
         )
 
     @property

classiq/interface/generator/arith/unary_ops.py

@@ -5,6 +5,7 @@ import pydantic
 from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.arith import argument_utils, number_utils
 from classiq.interface.generator.arith.arithmetic_operations import (
+    MODULO_WITH_FRACTION_PLACES_ERROR_MSG,
     ArithmeticOperationParams,
 )
 from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
@@ -74,6 +75,9 @@ class BitwiseInvert(UnaryOpParams):
 
 
 class Negation(UnaryOpParams):
+    bypass_bounds_validation: bool = pydantic.Field(
+        default=False
+    )  # True for efficient subtraction
     output_name = "negated"
 
     @staticmethod
@@ -88,11 +92,19 @@ class Negation(UnaryOpParams):
         eff_arg = self.arg.limit_fraction_places(self.machine_precision)
         is_signed = max(eff_arg.bounds) > 0 and self._include_sign
         bounds = (-max(eff_arg.bounds), -min(eff_arg.bounds))
+        if self.output_size and not self.bypass_bounds_validation:
+            if eff_arg.fraction_places:
+                raise ValueError(MODULO_WITH_FRACTION_PLACES_ERROR_MSG)
+            max_bounds = RegisterArithmeticInfo.get_maximal_bounds(
+                size=self.output_size, is_signed=False, fraction_places=0
+            )
+            bounds = number_utils.bounds_cut(bounds, max_bounds)
         return RegisterArithmeticInfo(
             size=self.output_size or self._expected_result_size(eff_arg),
             fraction_places=eff_arg.fraction_places,
             is_signed=is_signed,
-            bounds=bounds if (is_signed or min(bounds) >= 0) else None,
+            bypass_bounds_validation=self.bypass_bounds_validation,
+            bounds=bounds,
         )
 
     def zero_input_for_extension(self) -> pydantic.NonNegativeInt:

classiq/interface/generator/generated_circuit_data.py

@@ -1,4 +1,5 @@
-from typing import Dict, List, Literal, Optional, Tuple, Union
+import logging
+from typing import Any, Dict, List, Literal, Optional, Tuple, Union
 
 import pydantic
 from typing_extensions import TypeAlias
@@ -10,10 +11,10 @@ from classiq.interface.generator.synthesis_metadata.synthesis_execution_data imp
 )
 from classiq.interface.ide.visual_model import OperationParameter
 
+_logger = logging.getLogger(__name__)
 ParameterName = str
 IOQubitMapping: TypeAlias = Dict[str, Tuple[int, ...]]
 
-
 CLASSIQ_HIERARCHY_SEPARATOR: Literal["."] = "."
 
 VISUALIZATION_HIDE_LIST = [
@@ -102,6 +103,7 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
     absolute_qubits: Optional[Tuple[int, ...]]
     is_basis_gate: Optional[bool]
     parameters: List[OperationParameter] = list()
+    port_to_passed_variable_map: Dict[str, str] = pydantic.Field(default_factory=dict)
 
     @property
     def registers(self) -> List[GeneratedRegister]:
@@ -120,3 +122,46 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
         if self.generated_function is None:
             return list()
         return self.generated_function.control_states
+
+    @staticmethod
+    def create_parameters_from_dict(
+        parameters: Dict[str, str]
+    ) -> List[OperationParameter]:
+        return [
+            OperationParameter(label=key, value=value)
+            for key, value in parameters.items()
+        ]
+
+    def update(self, **kwargs: Any) -> None:
+        for key, value in kwargs.items():
+            setattr(self, key, value)
+
+    def propagate_absolute_qubits(self) -> None:
+        if self.absolute_qubits is None:
+            return
+
+        for register in self.registers:
+            register.qubit_indexes_absolute = list(
+                _get_absolute_from_relative(
+                    self.absolute_qubits, tuple(register.qubit_indexes_relative)
+                )
+            )
+
+        for child in self.children:
+            child.absolute_qubits = _get_absolute_from_relative(
+                self.absolute_qubits, child.relative_qubits
+            )
+            child.propagate_absolute_qubits()
+
+
+def _get_absolute_from_relative(
+    absolute_qubits: Tuple[int, ...], relative_qubits: Tuple[int, ...]
+) -> Tuple[int, ...]:
+    if max(relative_qubits) >= len(absolute_qubits):
+        _logger.warning(
+            "Invalid qubit computation (relative qubits: %s, absolute qubits: %s)",
+            relative_qubits,
+            absolute_qubits,
+        )
+        return tuple()
+    return tuple(absolute_qubits[relative_qubit] for relative_qubit in relative_qubits)

classiq/interface/generator/quantum_program.py

@@ -1,5 +1,5 @@
 import uuid
-from datetime import datetime
+from datetime import datetime, timezone
 from pathlib import Path
 from typing import Dict, List, Optional, Tuple, Union
 
@@ -10,6 +10,7 @@ from classiq.interface.exceptions import (
     ClassiqMissingOutputFormatError,
     ClassiqStateInitializationError,
 )
+from classiq.interface.execution.primitives import PrimitivesInput
 from classiq.interface.executor import quantum_code
 from classiq.interface.executor.quantum_instruction_set import QuantumInstructionSet
 from classiq.interface.executor.register_initialization import RegisterInitialization
@@ -50,16 +51,23 @@ def get_uuid_as_str() -> str:
     return str(uuid.uuid4())
 
 
+def _get_formatted_utc_current_time() -> str:
+    # The purpose of this method is to replicate the behavior of
+    # datetime.utcnow().isoformat(), since `utcnow` is now deprecated
+    return datetime.now(timezone.utc).isoformat().split("+")[0]
+
+
 class QuantumProgram(VersionedModel, CircuitCodeInterface):
     hardware_data: SynthesisHardwareData
     initial_values: Optional[InitialConditions]
     data: GeneratedCircuitData
     model: ExecutionModel
     transpiled_circuit: Optional[TranspiledCircuitData]
-    creation_time: str = pydantic.Field(default_factory=datetime.utcnow().isoformat)
+    creation_time: str = pydantic.Field(default_factory=_get_formatted_utc_current_time)
     synthesis_duration: Optional[SynthesisStepDurations]
     debug_info: Optional[List[FunctionDebugInfoInterface]]
     program_id: str = pydantic.Field(default_factory=get_uuid_as_str)
+    execution_primitives_input: Optional[PrimitivesInput] = pydantic.Field(default=None)
 
     def _hardware_agnostic_program_code(self) -> CodeAndSyntax:
         circuit_code = self.program_circuit.get_code_by_priority()

classiq/interface/ide/visual_model.py

@@ -1,4 +1,4 @@
-from typing import Dict, List, Optional, Tuple
+from typing import Any, Dict, List, Optional, Tuple
 
 import pydantic
 
@@ -38,6 +38,7 @@ class OperationParameter(pydantic.BaseModel):
 
 class OperationLink(pydantic.BaseModel):
     label: str
+    inner_label: Optional[str] = None
     qubits: Tuple[int, ...]
     type: str
 
@@ -47,6 +48,11 @@ class OperationLink(pydantic.BaseModel):
     def __hash__(self) -> int:
         return hash((type(self), self.label, self.qubits, self.type))
 
+    def __eq__(self, other: Any) -> bool:
+        if not isinstance(other, OperationLink):
+            return False
+        return hash(self) == hash(other)
+
 
 class OperationLinks(pydantic.BaseModel):
     inputs: List[OperationLink]

classiq/interface/interface_version.py

@@ -1 +1 @@
-INTERFACE_VERSION = "2"
+INTERFACE_VERSION = "3"

classiq/interface/model/phase_operation.py

@@ -0,0 +1,11 @@
+from typing import Literal
+
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.model.quantum_expressions.quantum_expression import (
+    QuantumExpressionOperation,
+)
+
+
+class PhaseOperation(QuantumExpressionOperation):
+    kind: Literal["PhaseOperation"]
+    theta: Expression

classiq/interface/model/statement_block.py

@@ -9,6 +9,7 @@ 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.native_function_definition import NativeFunctionDefinition
+from classiq.interface.model.phase_operation import PhaseOperation
 from classiq.interface.model.power import Power
 from classiq.interface.model.quantum_expressions.amplitude_loading_operation import (
     AmplitudeLoadingOperation,
@@ -38,6 +39,7 @@ ConcreteQuantumStatement = Annotated[
         ClassicalIf,
         Control,
         WithinApply,
+        PhaseOperation,
     ],
     Field(..., discriminator="kind"),
 ]
@@ -52,3 +54,4 @@ Invert.update_forward_refs(StatementBlock=StatementBlock)
 WithinApply.update_forward_refs(StatementBlock=StatementBlock)
 ClassicalIf.update_forward_refs(StatementBlock=StatementBlock)
 NativeFunctionDefinition.update_forward_refs(StatementBlock=StatementBlock)
+PhaseOperation.update_forward_refs(StatementBlock=StatementBlock)

classiq/interface/server/routes.py

@@ -17,9 +17,6 @@ ANALYZER_HC_TABLE_GRAPH_FULL_PATH = ANALYZER_PREFIX + ANALYZER_HC_TABLE_GRAPH
 
 ANALYZER_HC_GRAPH_NEW = "/graphs/hardware_connectivity/new"
 
-ANALYZER_OPTIONAL_DEVICES = "/graphs/available_devices"
-ANALYZER_OPTIONAL_DEVICES_FULL_PATH = ANALYZER_PREFIX + ANALYZER_OPTIONAL_DEVICES
-
 TASKS_SUFFIX = "/tasks"
 RB = "/rb"
 ANALYZER_DATA_TASK = f"{TASKS_SUFFIX}/data"

classiq/model_expansions/interpreter.py

@@ -24,6 +24,7 @@ from classiq.interface.model.inplace_binary_operation import InplaceBinaryOperat
 from classiq.interface.model.invert import Invert
 from classiq.interface.model.model import Model
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
+from classiq.interface.model.phase_operation import PhaseOperation
 from classiq.interface.model.power import Power
 from classiq.interface.model.quantum_expressions.quantum_expression import (
     QuantumAssignmentOperation,
@@ -74,6 +75,7 @@ from classiq.model_expansions.quantum_operations import (
     VariableDeclarationStatementEmitter,
     WithinApplyEmitter,
 )
+from classiq.model_expansions.quantum_operations.phase import PhaseEmitter
 from classiq.model_expansions.scope import Evaluated, QuantumSymbol, Scope
 from classiq.model_expansions.scope_initialization import (
     add_entry_point_params_to_scope,
@@ -307,6 +309,10 @@ class Interpreter:
     def emit_power(self, power: Power) -> None:
         PowerEmitter(self).emit(power)
 
+    @emit.register
+    def emit_phase(self, phase: PhaseOperation) -> None:
+        PhaseEmitter(self).emit(phase)
+
     def _expand_block(self, block: Sequence[QuantumStatement], block_name: str) -> None:
         with self._builder.block_context(block_name):
             for statement in block:

classiq/model_expansions/quantum_operations/emitter.py

@@ -131,16 +131,22 @@ class Emitter(Generic[QuantumStatementT]):
             or new_call.func_name == free.func_decl.name
         )
         parameters = {
-            arg_decl.name: FunctionDebugInfo.param_controller(value=valuated_arg.value)
-            for arg_decl, valuated_arg in zip(new_positional_arg_decls, evaluated_args)
+            arg_decl.name: FunctionDebugInfo.param_controller(value=evaluated_arg.value)
+            for arg_decl, evaluated_arg in zip(new_positional_arg_decls, evaluated_args)
             if isinstance(arg_decl, ClassicalParameterDeclaration)
         }
 
+        port_to_passed_variable_map = {
+            arg_decl.name: evaluated_arg.value.handle.name
+            for arg_decl, evaluated_arg in zip(new_positional_arg_decls, evaluated_args)
+            if isinstance(arg_decl, PortDeclaration)
+        }
         self._interpreter._model.debug_info[new_call.uuid] = FunctionDebugInfo(
             name=new_call.func_name,
             level=OperationLevel.QMOD_FUNCTION_CALL,
             parameters=parameters,
             is_allocate_or_free=is_allocate_or_free,
+            port_to_passed_variable_map=port_to_passed_variable_map,
         )
         if is_atomic:
             new_call.set_func_decl(new_declaration)

classiq/model_expansions/quantum_operations/phase.py

@@ -0,0 +1,177 @@
+from typing import TYPE_CHECKING, Dict, List, Tuple
+
+import sympy
+from sympy import sympify
+
+from classiq.interface.exceptions import ClassiqExpansionError
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.model.bind_operation import BindOperation
+from classiq.interface.model.handle_binding import HANDLE_ID_SEPARATOR, HandleBinding
+from classiq.interface.model.phase_operation import PhaseOperation
+from classiq.interface.model.quantum_function_call import QuantumFunctionCall
+from classiq.interface.model.quantum_type import (
+    QuantumBitvector,
+    QuantumNumeric,
+    QuantumScalar,
+)
+from classiq.interface.model.variable_declaration_statement import (
+    VariableDeclarationStatement,
+)
+from classiq.interface.model.within_apply_operation import WithinApply
+
+from classiq.applications.combinatorial_helpers.transformations.ising_converter import (
+    _find_sub_list_items,
+    _get_coeff_from_expr,
+    _get_vars,
+    _refine_ising_expr,
+    _to_ising_symbolic_objective_function,
+)
+from classiq.model_expansions.quantum_operations.expression_operation import (
+    ExpressionOperationEmitter,
+)
+from classiq.qmod.builtins.functions.exponentiation import suzuki_trotter
+from classiq.qmod.semantics.error_manager import ErrorManager
+
+
+class PhaseEmitter(ExpressionOperationEmitter[PhaseOperation]):
+    def emit(self, phase_op: PhaseOperation, /) -> None:
+        phase_expression = self._evaluate_op_expression(phase_op)
+        phase_op = phase_op.copy(update=dict(expression=phase_expression))
+        arrays_with_subscript = self._get_symbols_to_split(phase_op.expression)
+        if len(arrays_with_subscript) > 0:
+            self._emit_with_split(phase_op, phase_op.expression, arrays_with_subscript)
+            return
+
+        phase_op = self._evaluate_types_in_expression(phase_op, phase_op.expression)
+        if len(phase_op.var_handles) == 0:
+            ErrorManager().add_error(
+                "Cannot perform phase operation on an expression with no quantum variables."
+            )
+            return
+
+        aux_name = self._counted_name_allocator.allocate("phase_aux")
+        if len(phase_op.var_handles) > 1:
+            split_join = True
+            evolution_variable = HandleBinding(name=aux_name)
+        else:
+            split_join = False
+            evolution_variable = phase_op.var_handles[0]
+        expression = self._evaluate_op_expression(phase_op)
+        expression_evolution_function = QuantumFunctionCall(
+            function=suzuki_trotter.func_decl.name,
+            positional_args=[
+                _convert_cost_expression_to_hamiltonian(
+                    expression.expr,
+                    {
+                        var.name: self._current_scope[var.name].value.quantum_type
+                        for var in phase_op.var_handles
+                    },
+                ),
+                phase_op.theta,
+                Expression(expr="1"),
+                Expression(expr="1"),
+                evolution_variable,
+            ],
+            source_ref=phase_op.source_ref,
+        )
+        expression_evolution_function.set_func_decl(suzuki_trotter.func_decl)
+
+        if split_join:
+            self._interpreter.emit_statement(
+                VariableDeclarationStatement(
+                    name=aux_name, quantum_type=QuantumBitvector()
+                )
+            )
+            self._interpreter.emit_statement(
+                WithinApply(
+                    compute=[
+                        BindOperation(
+                            in_handles=phase_op.var_handles,
+                            out_handles=[HandleBinding(name=aux_name)],
+                        )
+                    ],
+                    action=[expression_evolution_function],
+                    source_ref=phase_op.source_ref,
+                )
+            )
+        else:
+            self._interpreter.emit_statement(
+                expression_evolution_function,
+            )
+
+
+def _get_single_bit_vars_expression(
+    expr: sympy.Expr, vars_info: Dict[str, QuantumScalar]
+) -> Tuple[sympy.Expr, List[sympy.Symbol]]:
+    bit_vars = []
+    for var_name, var_info in vars_info.items():
+        size = var_info.size_in_bits
+        var = sympy.Symbol(var_name)
+        if size == 1:
+            bits = [var]
+            is_signed = False
+            fraction_places = 0
+        else:
+            if TYPE_CHECKING:
+                assert isinstance(var_info, QuantumNumeric)
+            bits = [
+                sympy.Symbol(f"{var_name}{HANDLE_ID_SEPARATOR}{i}__split__")
+                for i in range(size)
+            ]
+            is_signed = var_info.sign_value
+            fraction_places = var_info.fraction_digits_value
+        bit_vars.extend(bits)
+        split_var = 0
+        for i, bit in enumerate(bits):
+            if is_signed and i == size - 1:  # sign bit (MSB)
+                split_var -= bit * 2 ** (size - 1 - fraction_places)
+            else:
+                split_var += bit * 2 ** (i - fraction_places)
+        expr = expr.subs(var, split_var)
+    return expr, bit_vars
+
+
+def _convert_ising_sympy_to_pauli_terms(
+    ising_expr: sympy.Expr, ordered_sympy_vars: List[sympy.Symbol]
+) -> str:
+    pauli_terms: List[str] = []
+    for expr_term in ising_expr.args:
+        expr_vars = _get_vars(expr_term)
+        z_vec = _find_sub_list_items(ordered_sympy_vars, expr_vars)
+        pauli_elements = ["I"] * len(z_vec)
+        for index, is_z_op in enumerate(z_vec):
+            if is_z_op:
+                pauli_elements[len(z_vec) - index - 1] = (
+                    "Z"  # reminder: Pauli reverses the order!
+                )
+        coeff = _get_coeff_from_expr(expr_term)
+        paulis = [f"Pauli.{pauli}" for pauli in pauli_elements]
+        pauli_terms.append(
+            # fmt: off
+                    "struct_literal("
+                    "PauliTerm,"
+                    f"pauli=[{', '.join(paulis)}],"
+                    f"coefficient={Expression(expr=str(coeff))},"
+                    ")"
+            # fmt: on,
+        )
+    return f"[{', '.join(pauli_terms)}]"
+
+
+def _convert_cost_expression_to_hamiltonian(
+    expr: str,
+    vars: Dict[str, QuantumScalar],
+) -> Expression:
+    sympy_expr = sympify(expr)
+    single_bit_vars_expression, single_bit_vars = _get_single_bit_vars_expression(
+        sympy_expr, vars
+    )
+    if not single_bit_vars_expression.is_polynomial():
+        raise ClassiqExpansionError(f"phased expression {expr!r} is not polynomial")
+
+    ising_expr = _to_ising_symbolic_objective_function(single_bit_vars_expression)
+    ising_expr = _refine_ising_expr(ising_expr)
+
+    return Expression(
+        expr=_convert_ising_sympy_to_pauli_terms(ising_expr, single_bit_vars)
+    )

classiq/qmod/builtins/operations.py

@@ -31,6 +31,7 @@ from classiq.interface.model.inplace_binary_operation import (
     InplaceBinaryOperation,
 )
 from classiq.interface.model.invert import Invert
+from classiq.interface.model.phase_operation import PhaseOperation
 from classiq.interface.model.power import Power
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.quantum_function_declaration import (
@@ -331,6 +332,18 @@ def invert(
     )
 
 
+def phase(expr: SymbolicExpr, theta: float = 1.0) -> None:
+    assert QCallable.CURRENT_EXPANDABLE is not None
+    source_ref = get_source_ref(sys._getframe(1))
+    QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
+        PhaseOperation(
+            expression=Expression(expr=str(expr)),
+            theta=Expression(expr=str(theta)),
+            source_ref=source_ref,
+        )
+    )
+
+
 def _validate_operand(stmt_block: Any) -> None:
     if stmt_block is not None:
         return
@@ -414,6 +427,7 @@ __all__ = [
     "power",
     "within_apply",
     "repeat",
+    "phase",
 ]
 
 

classiq/qmod/native/pretty_printer.py

@@ -37,6 +37,7 @@ from classiq.interface.model.inplace_binary_operation import InplaceBinaryOperat
 from classiq.interface.model.invert import Invert
 from classiq.interface.model.model import Model
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
+from classiq.interface.model.phase_operation import PhaseOperation
 from classiq.interface.model.port_declaration import (
     AnonPortDeclaration,
 )
@@ -255,6 +256,11 @@ class DSLPrettyPrinter(Visitor):
         control += f"{self._indent}}}\n"
         return control
 
+    def visit_PhaseOperation(self, op: PhaseOperation) -> str:
+        theta = f", {self.visit(op.theta)}" if op.theta else ""
+        phase = f"{self._indent}phase ({self.visit(op.expression)}{theta})\n"
+        return phase
+
     def visit_ClassicalIf(self, op: ClassicalIf) -> str:
         classical_if = f"{self._indent}if ({self.visit(op.condition)}) {{\n"
         if not op.then:

classiq/qmod/pretty_print/pretty_printer.py

@@ -39,6 +39,7 @@ from classiq.interface.model.inplace_binary_operation import InplaceBinaryOperat
 from classiq.interface.model.invert import Invert
 from classiq.interface.model.model import Model
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
+from classiq.interface.model.phase_operation import PhaseOperation
 from classiq.interface.model.port_declaration import AnonPortDeclaration
 from classiq.interface.model.power import Power
 from classiq.interface.model.quantum_expressions.amplitude_loading_operation import (
@@ -392,6 +393,11 @@ class PythonPrettyPrinter(Visitor):
         self._imports["control"] = 1
         return f"{self._indent}control({self.visit(op.expression)}, {self._visit_body(op.body)})\n"
 
+    def visit_PhaseOperation(self, op: PhaseOperation) -> str:
+        self._imports["phase"] = 1
+        theta = f", {self.visit(op.theta)}" if op.theta is not None else ""
+        return f"{self._indent}phase({self.visit(op.expression)},{theta})\n"
+
     def visit_ClassicalIf(self, op: ClassicalIf) -> str:
         self._imports["if_"] = 1
         return f"{self._indent}if_(condition={self.visit(op.condition)}, then={self._visit_body(op.then)}, else_={self._visit_body(op.else_)})\n"

{classiq-0.46.1.dist-info → classiq-0.47.0.dist-info}/METADATA

@@ -1,13 +1,13 @@
 Metadata-Version: 2.1
 Name: classiq
-Version: 0.46.1
+Version: 0.47.0
 Summary: Classiq's Python SDK for quantum computing
 Home-page: https://classiq.io
 License: Proprietary
 Keywords: quantum computing,quantum circuits,quantum algorithms,QAD,QDL
 Author: Classiq Technologies
 Author-email: support@classiq.io
-Requires-Python: >=3.8,<3.12
+Requires-Python: >=3.8,<3.13
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Education
@@ -20,6 +20,7 @@ Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Topic :: Scientific/Engineering
 Classifier: Topic :: Software Development
@@ -38,12 +39,14 @@ Requires-Dist: keyring (>=23.5.0,<24.0.0)
 Requires-Dist: matplotlib (>=3.4.3,<4.0.0)
 Requires-Dist: networkx (>=2.5.1,<3.0.0)
 Requires-Dist: numexpr (>=2.7.3,<3.0.0)
-Requires-Dist: numpy (>=1.20.1,<2.0.0)
+Requires-Dist: numpy (>=1.20.1,<2.0.0) ; python_version < "3.12"
+Requires-Dist: numpy (>=1.26.0,<2.0.0) ; python_version >= "3.12"
 Requires-Dist: packaging (>=23.2,<24.0)
 Requires-Dist: pandas (>=1.4.0,<3.0.0)
 Requires-Dist: plotly (>=5.7.0,<6.0.0)
 Requires-Dist: pydantic (>=1.9.1,<2.0.0)
-Requires-Dist: scipy (>=1.10.1,<2.0.0)
+Requires-Dist: scipy (>=1.10.0,<2.0.0) ; python_version < "3.12"
+Requires-Dist: scipy (>=1.11.0,<2.0.0) ; python_version >= "3.12"
 Requires-Dist: sympy (>=1.13.0,<2.0.0)
 Requires-Dist: tabulate (>=0.8.9,<1)
 Requires-Dist: torch (>=2.0,<3.0) ; extra == "qml"