classiq 0.79.1__py3-none-any.whl → 0.80.0__py3-none-any.whl

classiq/model_expansions/quantum_operations/call_emitter.py

@@ -30,6 +30,7 @@ from classiq.interface.generator.functions.port_declaration import (
 )
 from classiq.interface.generator.functions.type_qualifier import TypeQualifier
 from classiq.interface.helpers.backward_compatibility import zip_strict
+from classiq.interface.helpers.text_utils import are, readable_list, s
 from classiq.interface.model.classical_parameter_declaration import (
     ClassicalParameterDeclaration,
 )
@@ -82,7 +83,6 @@ from classiq.model_expansions.transformers.type_qualifier_inference import (
     TypeQualifierInference,
 )
 from classiq.model_expansions.transformers.var_splitter import VarSplitter
-from classiq.model_expansions.utils.text_utils import are, readable_list, s
 from classiq.qmod.pretty_print.expression_to_python import transform_expression
 from classiq.qmod.semantics.validation.signature_validation import (
     validate_function_signature,

classiq/model_expansions/scope.py

@@ -22,6 +22,7 @@ from classiq.interface.generator.expressions.proxies.classical.qmod_struct_insta
     QmodStructInstance,
 )
 from classiq.interface.generator.functions.type_name import TypeName
+from classiq.interface.helpers.text_utils import readable_list, s
 from classiq.interface.model.handle_binding import (
     FieldHandleBinding,
     GeneralHandle,
@@ -41,8 +42,6 @@ from classiq.interface.model.quantum_type import (
     QuantumType,
 )
 
-from classiq.model_expansions.utils.text_utils import readable_list, s
-
 if TYPE_CHECKING:
     from classiq.model_expansions.closure import FunctionClosure
 

classiq/open_library/functions/__init__.py

@@ -107,6 +107,8 @@ __all__ = [
     "phase_oracle",
     "prepare_bell_state",
     "prepare_complex_amplitudes",
+    "prepare_dicke_state",
+    "prepare_dicke_state_unary_input",
     "prepare_exponential_state",
     "prepare_ghz_state",
     "prepare_int",

classiq/open_library/functions/state_preparation.py

@@ -6,7 +6,10 @@ import sympy
 
 from classiq.interface.exceptions import ClassiqDeprecationWarning
 
-from classiq.open_library.functions.utility_functions import hadamard_transform
+from classiq.open_library.functions.utility_functions import (
+    apply_to_all,
+    hadamard_transform,
+)
 from classiq.qmod.builtins.functions import (
     CX,
     IDENTITY,
@@ -16,11 +19,19 @@ from classiq.qmod.builtins.functions import (
     X,
     inplace_prepare_amplitudes,
 )
-from classiq.qmod.builtins.operations import allocate, control, if_, inplace_add, repeat
+from classiq.qmod.builtins.operations import (
+    allocate,
+    control,
+    if_,
+    inplace_add,
+    repeat,
+    within_apply,
+)
 from classiq.qmod.cparam import CArray, CBool, CInt, CReal
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_variable import Output, QArray, QBit, QNum
 from classiq.qmod.symbolic import (
+    acos,
     asin,
     atan,
     exp,
@@ -375,7 +386,7 @@ def inplace_prepare_complex_amplitudes(
 @qfunc
 def prepare_complex_amplitudes(
     magnitudes: CArray[CReal],
-    phases: CArray[CReal],
+    phases: list[float],
     out: Output[QArray[QBit, Literal["log(get_field(magnitudes, 'len'), 2)"]]],
 ) -> None:
     """
@@ -391,3 +402,79 @@ def prepare_complex_amplitudes(
     """
     allocate(out)
     inplace_prepare_complex_amplitudes(magnitudes, phases, out)
+
+
+@qfunc
+def _dicke_split_cycle_shift(k: int, qvar: QArray[QBit]) -> None:
+    """
+    internal function, assumes the input is in the form |11..100..0> with up to k ones.
+    transforms the state to: sqrt(1/n)*|11..100..0> + sqrt((n-1)/n)*|01..110..0>.
+    """
+    for i in range(k):
+        within_apply(
+            lambda i=i: CX(qvar[i + 1], qvar[0]),  # type: ignore[misc]
+            lambda i=i: (  # type: ignore[misc]
+                control(
+                    qvar[0],
+                    lambda i=i: RY(2 * acos(sqrt((i + 1) / qvar.len)), qvar[i + 1]),  # type: ignore[misc]
+                )
+                if i == 0
+                else control(
+                    qvar[0] & qvar[i],
+                    lambda i=i: RY(2 * acos(sqrt((i + 1) / qvar.len)), qvar[i + 1]),  # type: ignore[misc]
+                )
+            ),
+        )
+
+
+@qfunc
+def prepare_dicke_state_unary_input(max_k: int, qvar: QArray[QBit]) -> None:
+    """
+    assumes the input is encoded in qvar in unary encoding. should work for every value
+    smaller than max_k
+    """
+    """
+    [Qmod Classiq-library function]
+
+    Prepares a Dicke state with a variable number of excitations based on an unary-encoded input.
+
+    The Dicke state is defined to be:
+    $$
+    \\mathrm{Dicke}(n, k) = \frac{1}{\\sqrt{\binom{n}{k}}} \\sum_{x \\in \\{0,1\\}^n,\\, |x| = k} |x\rangle
+    $$
+
+    The input register `qvar` is expected to already be initialized in a unary encoding:
+    the value k is represented by a string of k ones followed by zeros, e.g., k = 3 -> |11100...0>.
+    The function generates a Dicke state with k excitations over a new quantum register,
+    where 0 <= k < max_k.
+
+    Args:
+        max_k: The maximum number of allowed excitations (upper bound for k).
+        qvar: Unary-encoded quantum input register of length >= max_k. Must be pre-initialized.
+    """
+    if qvar.len > max(1, max_k):
+        _dicke_split_cycle_shift(max_k, qvar)
+        prepare_dicke_state_unary_input(qmin(max_k, qvar.len - 2), qvar[1 : qvar.len])
+
+
+@qfunc
+def prepare_dicke_state(k: int, qvar: QArray[QBit]) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Prepares a Dicke state with k excitations over the provided quantum register.
+
+    A Dicke state of n qubits with k excitations is an equal superposition of all basis states
+    with exactly k qubits in the |1> state and (n - k) qubits in the |0? state.
+    For example, Dicke(2, 1) = (|01> + |10>) / sqrt(2). In the general case it is define to be:
+    $$
+    \\mathrm{Dicke}(n, k) = \frac{1}{\\sqrt{\binom{n}{k}}} \\sum_{x \\in \\{0,1\\}^n,\\, |x| = k} |x\rangle
+    $$
+
+    Args:
+        k: The number of excitations (i.e., number of qubits in state |1>).
+        qvar: The quantum register (array of qubits) to initialize. Must be uninitialized and have length >= k.
+    """
+    if k > 0:
+        apply_to_all(X, qvar[0:k])
+        prepare_dicke_state_unary_input(k, qvar)

classiq/qmod/builtins/classical_execution_primitives.py

@@ -1,8 +1,9 @@
-from typing import Final, Optional, Union
+from typing import Final, Optional
 
 from classiq.interface.applications.iqae.iqae_result import IQAEResult
 from classiq.interface.exceptions import ClassiqError
 from classiq.interface.executor.execution_preferences import QaeWithQpeEstimationMethod
+from classiq.interface.executor.quantum_program_params import ExecutionParams
 from classiq.interface.executor.result import (
     EstimationResult,
     EstimationResults,
@@ -15,8 +16,6 @@ from classiq.interface.generator.functions.qmod_python_interface import QmodPySt
 from classiq.applications.qsvm.qsvm import Data, Labels
 from classiq.qmod.builtins.enums import Optimizer
 
-ExecutionParams = dict[str, Union[float, int, list[int], list[float]]]
-
 _CALL_IN_QFUNC_ERROR = (
     'Cannot call "{}" in a quantum context. "{}" is a classical execution primitive.'
 )
@@ -104,7 +103,6 @@ def molecule_ground_state_solution_post_process(  # type: ignore[return]
 
 
 __all__ = [
-    "ExecutionParams",
     "batch_estimate",
     "batch_sample",
     "estimate",

classiq/qmod/builtins/functions/__init__.py

@@ -55,6 +55,7 @@ CORE_LIB_DECLS = [
         prepare_amplitudes_approx,
         unitary,
         add,
+        add_inplace_right,
         modular_add,
         integer_xor,
         modular_add_constant,
@@ -69,6 +70,7 @@ CORE_LIB_DECLS = [
         inplace_prepare_amplitudes_approx,
         single_pauli_exponent,
         commuting_paulis_exponent,
+        sparse_suzuki_trotter,
         suzuki_trotter,
         qdrift,
         exponentiation_with_depth_constraint,
@@ -109,6 +111,7 @@ __all__ = [  # noqa: RUF022
     "Y",
     "Z",
     "add",
+    "add_inplace_right",
     "apply",
     "bloch_sphere_feature_map",
     "exponentiation_with_depth_constraint",

classiq/qmod/builtins/functions/arithmetic.py

@@ -2,7 +2,7 @@ from typing import Literal
 
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_parameter import CArray, CBool, CReal
-from classiq.qmod.qmod_variable import Const, Output, QArray, QBit, QFree, QNum
+from classiq.qmod.qmod_variable import Const, Input, Output, QArray, QBit, QFree, QNum
 
 
 @qfunc(external=True)
@@ -42,6 +42,26 @@ def add(
     pass
 
 
+@qfunc(external=True)
+def add_inplace_right(
+    left: Const[QNum],
+    right: QFree[Input[QNum]],
+    result: QFree[
+        Output[
+            QNum[
+                Literal["result_size"],
+                Literal["result_is_signed"],
+                Literal["result_fraction_places"],
+            ]
+        ]
+    ],
+    result_size: CReal,
+    result_is_signed: CBool,
+    result_fraction_places: CReal,
+) -> None:
+    pass
+
+
 @qfunc(external=True)
 def modular_add(left: Const[QArray[QBit]], right: QFree[QArray[QBit]]) -> None:
     pass

classiq/qmod/builtins/functions/exponentiation.py

@@ -3,6 +3,7 @@ from typing import Literal
 from classiq.qmod.builtins.enums import Pauli
 from classiq.qmod.builtins.structs import (
     PauliTerm,
+    SparsePauliOp,
 )
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_parameter import CArray, CInt, CReal
@@ -79,6 +80,29 @@ def suzuki_trotter(
     pass
 
 
+@qfunc(external=True)
+def sparse_suzuki_trotter(
+    pauli_operator: SparsePauliOp,
+    evolution_coefficient: CReal,
+    order: CInt,
+    repetitions: CInt,
+    qbv: QArray[QBit, Literal["get_field(pauli_operator, 'num_qubits')"]],
+) -> None:
+    """
+    Applies the Suzuki-Trotter decomposition to a sparse Pauli operator. For more details,
+    See about Suzuki-Trotter decomposition in `suzuki_trotter` `qfunc`.
+
+     Args:
+         pauli_operator: The Pauli operator to be exponentiated, in sparse representation (See: SparsePauliOp).
+         evolution_coefficient: A global evolution coefficient multiplying the Pauli operator.
+         order: The order of the Suzuki-Trotter decomposition.
+         repetitions: The number of repetitions of the Suzuki-Trotter decomposition.
+         qbv: The target quantum variable of the exponentiation.
+    """
+
+    pass
+
+
 @qfunc(external=True)
 def qdrift(
     pauli_operator: CArray[PauliTerm],

classiq/qmod/builtins/operations.py

@@ -63,6 +63,16 @@ def allocate(out: Output[QVar]) -> None:
     pass
 
 
+@overload
+def allocate(
+    num_qubits: Union[int, SymbolicExpr],
+    is_signed: Union[bool, SymbolicExpr],
+    fraction_digits: Union[int, SymbolicExpr],
+    out: Output[QVar],
+) -> None:
+    pass
+
+
 @suppress_return_value
 def allocate(*args: Any, **kwargs: Any) -> None:
     """
@@ -73,34 +83,54 @@ def allocate(*args: Any, **kwargs: Any) -> None:
     $$
 
     If 'num_qubits' is not specified, it will be inferred according to the type of 'out'.
+    In case the quantum variable is of type `QNum`, its numeric attributes can be specified as
+    well.
 
     Args:
         num_qubits: The number of qubits to allocate (positive integer, optional).
         out: The quantum variable that will receive the allocated qubits. Must be uninitialized before allocation.
+        is_signed: The sign of the allocated variable, valid only for `QNum` (boolean, optional).
+        fraction_digits: The number of fraction digits in the allocated variable, valid only for `QNum` (positive integer, optional).
 
     Notes:
-        1. If the output variable has been declared with a specific number of qubits, the number of qubits allocated must match the declared number.
+        1. If the output variable has been declared with a specific number of qubits or numeric attributes, the passed values must match the declared values.
         2. The synthesis engine automatically handles the allocation, either by drawing new qubits from the available pool or by reusing existing ones.
     """
     assert QCallable.CURRENT_EXPANDABLE is not None
     source_ref = get_source_ref(sys._getframe(1))
     if len(args) == 0:
         size = kwargs.get("num_qubits", None)
+        is_signed = kwargs.get("is_signed", None)
+        fraction_digits = kwargs.get("fraction_digits", None)
         target = kwargs["out"]
     elif len(args) == 1:
         if "out" in kwargs:
             size = args[0]
+            is_signed = kwargs.get("is_signed", None)
+            fraction_digits = kwargs.get("fraction_digits", None)
             target = kwargs["out"]
         else:
             size = None
+            is_signed = None
+            fraction_digits = None
             target = args[0]
-    else:
+    elif len(args) == 2:
         size, target = args
+        is_signed = kwargs.get("is_signed", None)
+        fraction_digits = kwargs.get("fraction_digits", None)
+    else:
+        size, is_signed, fraction_digits, target = args
     if isinstance(size, QConstant):
         size.add_to_model()
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
         Allocate(
             size=None if size is None else Expression(expr=str(size)),
+            is_signed=None if is_signed is None else Expression(expr=str(is_signed)),
+            fraction_digits=(
+                None
+                if fraction_digits is None
+                else Expression(expr=str(fraction_digits))
+            ),
             target=target.get_handle_binding(),
             source_ref=source_ref,
         )

classiq/qmod/builtins/structs.py

@@ -10,7 +10,7 @@ from classiq.qmod.python_classical_type import PythonClassicalType
 @dataclass
 class PauliTerm:
     """
-    A term in a Hamiltonian, represented as a product of Pauli operators.
+    A term in a Hamiltonian, represented as a product of single-qubit Pauli matrices.
 
     Attributes:
         pauli (CArray[Pauli]): The list of the chosen Pauli operators in the term, corresponds to a product of them.
@@ -21,6 +21,49 @@ class PauliTerm:
     coefficient: CReal
 
 
+@dataclass
+class IndexedPauli:
+    """
+    A single-qubit Pauli matrix on a specific qubit given by its index.
+
+    Attributes:
+        pauli (Pauli): The Pauli operator.
+        index (CInt): The index of the qubit being operated on.
+    """
+
+    pauli: Pauli
+    index: CInt
+
+
+@dataclass
+class SparsePauliTerm:
+    """
+    A term in the Hamiltonian, represented as a sparse product of single-qubit Pauli
+    matrices.
+
+       Attributes:
+           paulis (CArray[IndexedPauli]): The list of chosen sparse Pauli operators in the term corresponds to a product of them. (See IndexedPauli)
+           coefficient (CReal): The coefficient of the term (floating number).
+    """
+
+    paulis: CArray[IndexedPauli]
+    coefficient: CReal
+
+
+@dataclass
+class SparsePauliOp:
+    """
+    Represents a collection of sparse Pauli operators.
+
+    Attributes:
+        paulis (CArray[SparsePauliTerm]): The list of chosen sparse Pauli operators in the term, corresponds to a product of them. (See: SparsePauliTerm)
+        num_qubits (CInt): The number of qubits in the Hamiltonian.
+    """
+
+    paulis: CArray[SparsePauliTerm]
+    num_qubits: CInt
+
+
 @dataclass
 class Position:
     x: CReal
@@ -139,6 +182,7 @@ __all__ = [
     "FinanceFunction",
     "FockHamiltonianProblem",
     "GaussianModel",
+    "IndexedPauli",
     "LadderOp",
     "LadderTerm",
     "LogNormalModel",
@@ -148,4 +192,6 @@ __all__ = [
     "Position",
     "QSVMFeatureMapPauli",
     "QsvmResult",
+    "SparsePauliOp",
+    "SparsePauliTerm",
 ]

classiq/qmod/native/pretty_printer.py

@@ -250,7 +250,10 @@ class DSLPrettyPrinter(ModelVisitor):
         return f"{self.visit(ctlist.element_type)}[]"
 
     def visit_ClassicalArray(self, ctarray: ClassicalArray) -> str:
-        return f"{self.visit(ctarray.element_type)}[{ctarray.size}]"
+        element_type = self.visit(ctarray.element_type)
+        if ctarray.length is not None:
+            return f"{element_type}[{self.visit(ctarray.length)}]"
+        return f"{element_type}[]"
 
     def visit_ClassicalTuple(self, classical_tuple: ClassicalTuple) -> str:
         raw_type = classical_tuple.get_raw_type()
@@ -288,11 +291,17 @@ class DSLPrettyPrinter(ModelVisitor):
         return f"{self.visit_QuantumFunctionDeclaration(func_def)} {{\n{body}}}\n"
 
     def visit_Allocate(self, allocate: Allocate) -> str:
-        if allocate.size is not None:
-            size = f"{self.visit(allocate.size)}, "
-        else:
-            size = ""
-        return f"{self._indent}allocate({size}{self.visit(allocate.target)});\n"
+        params = ", ".join(
+            self.visit(param)
+            for param in [
+                allocate.size,
+                allocate.is_signed,
+                allocate.fraction_digits,
+                allocate.target,
+            ]
+            if param is not None
+        )
+        return f"{self._indent}allocate({params});\n"
 
     def visit_QuantumFunctionCall(self, func_call: QuantumFunctionCall) -> str:
         positional_args = ", ".join(

classiq/qmod/pretty_print/pretty_printer.py

@@ -344,7 +344,10 @@ class PythonPrettyPrinter(ModelVisitor):
 
     def visit_ClassicalArray(self, ctarray: ClassicalArray) -> str:
         self._imports["CArray"] = 1
-        return f"CArray[{self.visit(ctarray.element_type)}, {ctarray.size}]"
+        element_type = self.visit(ctarray.element_type)
+        if ctarray.length is not None:
+            return f"CArray[{element_type}, {_add_quotes(self.visit(ctarray.length))}]"
+        return f"CArray[{element_type}]"
 
     def visit_ClassicalTuple(self, classical_tuple: ClassicalTuple) -> str:
         raw_type = classical_tuple.get_raw_type()
@@ -434,11 +437,17 @@ class PythonPrettyPrinter(ModelVisitor):
 
     def visit_Allocate(self, allocate: Allocate) -> str:
         self._imports["allocate"] = 1
-        if allocate.size is not None:
-            size = f"{self.visit(allocate.size)}, "
-        else:
-            size = ""
-        return f"{self._indent}allocate({size}{self.visit(allocate.target)})\n"
+        params = ", ".join(
+            self.visit(param)
+            for param in [
+                allocate.size,
+                allocate.is_signed,
+                allocate.fraction_digits,
+                allocate.target,
+            ]
+            if param is not None
+        )
+        return f"{self._indent}allocate({params})\n"
 
     def visit_Control(self, op: Control) -> str:
         self._imports["control"] = 1

classiq/qmod/python_classical_type.py

@@ -11,10 +11,10 @@ from typing import (
 )
 
 from classiq.interface.exceptions import ClassiqValueError
+from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.classical_type import (
     Bool,
     ClassicalArray,
-    ClassicalList,
     Integer,
     Real,
 )
@@ -47,15 +47,15 @@ class PythonClassicalType:
         elif get_origin(py_type) is list:
             element_type = self.convert(get_args(py_type)[0])
             if element_type is not None:
-                return ClassicalList(element_type=element_type).set_generative()
+                return ClassicalArray(element_type=element_type).set_generative()
         elif get_origin(py_type) is CArray:
             array_args = version_portable_get_args(py_type)
             if len(array_args) == 1:
-                return ClassicalList(element_type=self.convert(array_args[0]))
+                return ClassicalArray(element_type=self.convert(array_args[0]))
             elif len(array_args) == 2:
                 return ClassicalArray(
                     element_type=self.convert(array_args[0]),
-                    size=get_type_hint_expr(array_args[1]),
+                    length=Expression(expr=get_type_hint_expr(array_args[1])),
                 )
             raise ClassiqValueError(CARRAY_ERROR_MESSAGE)
         elif inspect.isclass(py_type) and dataclasses.is_dataclass(py_type):

classiq/qmod/qmod_parameter.py

@@ -167,7 +167,11 @@ def get_qmod_type(ctype: ClassicalType) -> type:
     elif isinstance(ctype, ClassicalList):
         return CArray[get_qmod_type(ctype.element_type)]  # type: ignore[misc]
     elif isinstance(ctype, ClassicalArray):
-        return CArray[get_qmod_type(ctype.element_type), ctype.size]  # type: ignore[misc]
+        if ctype.length is None:
+            return CArray[get_qmod_type(ctype.element_type)]  # type: ignore[misc]
+        if ctype.has_length and isinstance(ctype.length.value.value, int):
+            return CArray[get_qmod_type(ctype.element_type), ctype.length.value.value]  # type: ignore[misc]
+        return CArray[get_qmod_type(ctype.element_type), ctype.length.expr]  # type: ignore[misc]
     elif isinstance(ctype, ClassicalTuple):
         raw_type = ctype.get_raw_type()
         if isinstance(raw_type, ClassicalTuple):

classiq/qmod/semantics/validation/main_validation.py

@@ -37,6 +37,11 @@ def _validate_main_classical_param_type(
             f"specify array length",
         )
     if isinstance(param, ClassicalArray):
+        if param.length is None:
+            raise ClassiqExpansionError(
+                f"Classical array parameter {param_name!r} of function 'main' must "
+                f"specify array length",
+            )
         _validate_main_classical_param_type(param.element_type, param_name)
 
 

classiq/quantum_program.py

@@ -0,0 +1,69 @@
+from typing import Optional
+
+from classiq.interface.executor.quantum_program_params import (
+    ParameterAssignmentsParams,
+    TranspilationParams,
+)
+from classiq.interface.generator.model.preferences.preferences import Preferences
+from classiq.interface.generator.quantum_program import (
+    QuantumProgram,
+)
+
+from classiq._internals import async_utils
+from classiq._internals.api_wrapper import ApiWrapper
+from classiq.qmod.builtins.classical_execution_primitives import ExecutionParams
+
+
+async def transpile_async(params: TranspilationParams) -> QuantumProgram:
+    return await ApiWrapper.call_transpilation_task(params)
+
+
+def transpile(
+    quantum_program: QuantumProgram, preferences: Optional[Preferences] = None
+) -> QuantumProgram:
+    """
+    Transpiles a quantum program.
+
+    Args:
+        quantum_program: The quantum program to transpile. This is the result of the synthesize method.
+        preferences: The transpilation preferences.
+
+    Returns:
+        QuantumProgram: The result of the transpilation (Optional).
+    """
+    if preferences is None:
+        preferences = Preferences()
+    return async_utils.run(
+        transpile_async(
+            TranspilationParams(
+                quantum_program=quantum_program, preferences=preferences
+            )
+        )
+    )
+
+
+async def assign_parameters_async(params: ParameterAssignmentsParams) -> QuantumProgram:
+    return await ApiWrapper.call_assign_parameters_task(params)
+
+
+def assign_parameters(
+    quantum_program: QuantumProgram, parameters: ExecutionParams
+) -> QuantumProgram:
+    """
+    Assign parameters to a parametric quantum program.
+
+    Args:
+        quantum_program: The quantum program to be assigned. This is the result of the synthesize method.
+        parameters: The parameter assignments.
+
+    Returns:
+        QuantumProgram: The quantum program after assigning parameters.
+    """
+
+    return async_utils.run(
+        assign_parameters_async(
+            ParameterAssignmentsParams(
+                quantum_program=quantum_program, parameters=parameters
+            )
+        )
+    )

{classiq-0.79.1.dist-info → classiq-0.80.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: classiq
-Version: 0.79.1
+Version: 0.80.0
 Summary: Classiq's Python SDK for quantum computing
 License: Proprietary
 Keywords: quantum computing,quantum circuits,quantum algorithms,QAD,QDL