classiq 0.86.0__py3-none-any.whl → 0.87.0__py3-none-any.whl

classiq/model_expansions/quantum_operations/assignment_result_processor.py

@@ -27,7 +27,9 @@ from classiq.interface.model.variable_declaration_statement import (
 )
 from classiq.interface.model.within_apply_operation import WithinApply
 
-from classiq.evaluators.quantum_type_utils import copy_type_information
+from classiq.evaluators.qmod_type_inference.quantum_type_inference import (
+    inject_quantum_type_attributes_inplace,
+)
 from classiq.model_expansions.quantum_operations.arithmetic.explicit_boolean_expressions import (
     convert_assignment_bool_expression,
     validate_assignment_bool_expression,
@@ -67,30 +69,38 @@ class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
         )
         convert_assignment_bool_expression(op)
 
-        inferred_result_type = self._infer_result_type(op)
-        if inferred_result_type is None:
+        expression_type = self._infer_expression_type(op)
+        if expression_type is None:
             return False
 
-        if not isinstance(result_type, QuantumNumeric):
-            copy_type_information(
-                inferred_result_type, result_symbol.quantum_type, str(op.result_var)
-            )
+        if not result_type.is_instantiated:
+            if not inject_quantum_type_attributes_inplace(expression_type, result_type):
+                raise ClassiqExpansionError(
+                    f"Cannot assign expression of type "
+                    f"{expression_type.qmod_type_name} to variable "
+                    f"{str(result_symbol)!r} of type "
+                    f"{result_symbol.quantum_type.qmod_type_name}"
+                )
             return False
 
-        self._copy_numeric_attributes(result_type, inferred_result_type)
-        if self._same_numeric_attributes(result_type, inferred_result_type):
+        if isinstance(result_type, QuantumNumeric) and isinstance(
+            expression_type, QuantumNumeric
+        ):
+            result_type.set_bounds(expression_type.get_bounds())
+        if self._same_numeric_attributes(result_type, expression_type):
             return False
-
         self._validate_declared_attributes(
-            result_type, inferred_result_type, str(op.result_var)
+            result_type, expression_type, str(op.result_var)
         )
-        if self._replace_assignment_if_needed:
-            self._assign_to_inferred_var_and_bind(op, result_type, inferred_result_type)
-            return True
-        else:
+        if not self._replace_assignment_if_needed:
             return False
 
-    def _infer_result_type(self, op: ArithmeticOperation) -> Optional[QuantumNumeric]:
+        self._assign_to_inferred_var_and_bind(op, result_type, expression_type)
+        return True
+
+    def _infer_expression_type(
+        self, op: ArithmeticOperation
+    ) -> Optional[QuantumNumeric]:
         expr = self._evaluate_expression(op.expression)
         if len(self._get_classical_vars_in_expression(expr)):
             return None
@@ -114,96 +124,72 @@ class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
             self._machine_precision,
         )
 
-    @staticmethod
-    def _copy_numeric_attributes(
-        result_type: QuantumNumeric, inferred_result_type: QuantumNumeric
-    ) -> None:
-        if not result_type.has_size_in_bits:
-            result_type.size = Expression(expr=str(inferred_result_type.size_in_bits))
-        if not result_type.has_sign:
-            result_type.is_signed = Expression(
-                expr=str(inferred_result_type.sign_value)
-            )
-        if not result_type.has_fraction_digits:
-            result_type.fraction_digits = Expression(
-                expr=str(inferred_result_type.fraction_digits_value)
-            )
-        result_type.set_bounds(inferred_result_type.get_bounds())
-
     @staticmethod
     def _same_numeric_attributes(
-        result_type: QuantumNumeric, inferred_result_type: QuantumNumeric
+        result_type: QuantumNumeric, expression_type: QuantumNumeric
     ) -> bool:
         return (
-            result_type.size_in_bits == inferred_result_type.size_in_bits
-            and result_type.sign_value == inferred_result_type.sign_value
+            result_type.size_in_bits == expression_type.size_in_bits
+            and result_type.sign_value == expression_type.sign_value
             and result_type.fraction_digits_value
-            == inferred_result_type.fraction_digits_value
+            == expression_type.fraction_digits_value
         )
 
     @classmethod
     def _validate_declared_attributes(
-        cls, result_type: QuantumNumeric, inferred_result_type: QuantumNumeric, var: str
+        cls, result_type: QuantumNumeric, expression_type: QuantumNumeric, var: str
     ) -> None:
         result_size, result_sign, result_fractions = (
             result_type.size_in_bits,
             result_type.sign_value,
             result_type.fraction_digits_value,
         )
-        inferred_size, inferred_sign, inferred_fractions = (
-            inferred_result_type.size_in_bits,
-            inferred_result_type.sign_value,
-            inferred_result_type.fraction_digits_value,
+        expression_size, expression_sign, expression_fractions = (
+            expression_type.size_in_bits,
+            expression_type.sign_value,
+            expression_type.fraction_digits_value,
         )
         result_integers = result_size - result_fractions
-        inferred_integers = inferred_size - inferred_fractions
+        expression_integers = expression_size - expression_fractions
 
         if (
-            (result_integers < inferred_integers)
-            or (result_fractions < inferred_fractions)
-            or (not result_sign and inferred_sign)
+            (result_integers < expression_integers)
+            or (result_fractions < expression_fractions)
+            or (not result_sign and expression_sign)
             or (
                 result_sign
-                and not inferred_sign
-                and result_integers == inferred_integers
+                and not expression_sign
+                and result_integers == expression_integers
             )
         ):
             if (
                 not result_sign
                 and result_fractions == 0
-                and not inferred_sign
-                and inferred_fractions == 0
+                and not expression_sign
+                and expression_fractions == 0
             ):
                 result_size_str = f"size {result_size}"
-                inferred_size_str = f"size {inferred_size}"
+                expression_size_str = f"size {expression_size}"
                 hint = f"Hint: increase the size in the declaration of {var!r} or omit it to enable automatic inference."
             else:
                 result_size_str = f"size {result_size}, {'signed' if result_sign else 'unsigned'}, and {result_fractions} fraction digits"
-                inferred_size_str = f"size {inferred_size}, {'signed' if inferred_sign else 'unsigned'}, and {inferred_fractions} fraction digits"
+                expression_size_str = f"size {expression_size}, {'signed' if expression_sign else 'unsigned'}, and {expression_fractions} fraction digits"
                 hint = f"Hint: omit the numeric attributes from the declaration of {var!r} to enable automatic inference."
             raise ClassiqExpansionError(
-                f"Cannot assign an expression with inferred {inferred_size_str} to variable {var!r} with declared {result_size_str}. {hint}"
+                f"Cannot assign an expression with inferred {expression_size_str} to variable {var!r} with declared {result_size_str}. {hint}"
             )
 
-    @staticmethod
-    def _craft_size_string(size: int, is_signed: bool, fraction_digits: int) -> str:
-        extra = (
-            f", with {fraction_digits} fraction digits" if fraction_digits > 0 else ""
-        )
-        return f"{size} ({'signed' if is_signed else 'unsigned'}{extra})"
-
     def _assign_to_inferred_var_and_bind(
         self,
         op: ArithmeticOperation,
         result_type: QuantumNumeric,
-        inferred_result_type: QuantumNumeric,
+        expression_type: QuantumNumeric,
     ) -> None:
         stmts: StatementBlock = []
         handles: list[HandleBinding] = []
 
         extra_fraction_digits = (
-            result_type.fraction_digits_value
-            - inferred_result_type.fraction_digits_value
+            result_type.fraction_digits_value - expression_type.fraction_digits_value
         )
         if extra_fraction_digits > 0:
             handles.append(
@@ -216,7 +202,7 @@ class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
         inferred_result_handle = HandleBinding(name=inferred_result_name)
         stmts.append(
             VariableDeclarationStatement(
-                name=inferred_result_name, qmod_type=inferred_result_type
+                name=inferred_result_name, qmod_type=expression_type
             )
         )
         handles.append(inferred_result_handle)
@@ -228,8 +214,7 @@ class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
             result_type.size_in_bits - result_type.fraction_digits_value
         )
         inferred_result_integer_size = (
-            inferred_result_type.size_in_bits
-            - inferred_result_type.fraction_digits_value
+            expression_type.size_in_bits - expression_type.fraction_digits_value
         )
         extra_integers = result_integer_size - inferred_result_integer_size
         if extra_integers > 0:
@@ -239,17 +224,13 @@ class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
 
         stmts.append(BindOperation(in_handles=handles, out_handles=[op.result_var]))
 
-        if (
-            result_type.sign_value
-            and inferred_result_type.sign_value
-            and extra_integers > 0
-        ):
+        if result_type.sign_value and expression_type.sign_value and extra_integers > 0:
             sign_idx = result_type.size_in_bits - extra_integers - 1
             self._sign_extension(
                 op.result_var, sign_idx, result_type.size_in_bits, stmts
             )
 
-        if (inferred_bounds := inferred_result_type.get_bounds()) is not None:
+        if (inferred_bounds := expression_type.get_bounds()) is not None:
             lower_bound = Expression(expr=str(inferred_bounds[0]))
             upper_bound = Expression(expr=str(inferred_bounds[1]))
         else:

classiq/model_expansions/quantum_operations/bind.py

@@ -5,14 +5,17 @@ from classiq.interface.exceptions import (
     ClassiqExpansionError,
     ClassiqInternalExpansionError,
 )
+from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.model.bind_operation import BindOperation
-from classiq.interface.model.quantum_type import QuantumNumeric
+from classiq.interface.model.quantum_type import QuantumBitvector, QuantumNumeric
 
 from classiq.evaluators.parameter_types import (
     evaluate_types_in_quantum_symbols,
 )
+from classiq.evaluators.qmod_type_inference.quantum_type_inference import (
+    inject_quantum_type_attributes_inplace,
+)
 from classiq.evaluators.quantum_type_utils import (
-    set_size,
     validate_bind_targets,
 )
 from classiq.model_expansions.quantum_operations.emitter import Emitter
@@ -134,11 +137,16 @@ class BindEmitter(Emitter[BindOperation]):
             if output.quantum_type.has_size_in_bits
         )
         if len(unsized_outputs) == 1:
-            set_size(
-                unsized_outputs[0].quantum_type,
-                input_size - output_size,
-                str(unsized_outputs[0].handle),
-            )
+            unsized_type = unsized_outputs[0].quantum_type
+            new_size = input_size - output_size
+            if not inject_quantum_type_attributes_inplace(
+                QuantumBitvector(length=Expression(expr=str(new_size))), unsized_type
+            ):
+                raise ClassiqExpansionError(
+                    f"Cannot bind {new_size} qubits to variable "
+                    f"{str(unsized_outputs[0])!r} of type "
+                    f"{unsized_type.qmod_type_name}"
+                )
         elif input_size != output_size:
             raise ClassiqExpansionError(
                 f"The total size for the input and output of the bind operation must be the same. The in size is {input_size} and the out size is {output_size}"

classiq/model_expansions/quantum_operations/call_emitter.py

@@ -1,7 +1,6 @@
 from collections.abc import Sequence
 from itertools import chain, combinations
 from typing import (
-    TYPE_CHECKING,
     Any,
     Generic,
     Optional,
@@ -80,18 +79,15 @@ from classiq.model_expansions.scope import (
     QuantumVariable,
     Scope,
 )
+from classiq.model_expansions.transformers.model_renamer import ModelRenamer
 from classiq.model_expansions.transformers.type_modifier_inference import (
     TypeModifierValidation,
 )
-from classiq.model_expansions.transformers.var_splitter import VarSplitter
 from classiq.qmod.pretty_print.expression_to_python import transform_expression
 from classiq.qmod.semantics.validation.signature_validation import (
     validate_function_signature,
 )
 
-if TYPE_CHECKING:
-    from classiq.model_expansions.interpreters.base_interpreter import BaseInterpreter
-
 
 def _validate_cloning(evaluated_args: list[Evaluated]) -> None:
     handles = chain.from_iterable(
@@ -145,11 +141,7 @@ def _validate_gen_args(
             )
 
 
-class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSplitter):
-    def __init__(self, interpreter: "BaseInterpreter") -> None:
-        Emitter.__init__(self, interpreter)
-        VarSplitter.__init__(self, interpreter._builder.current_scope)
-
+class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], ModelRenamer):
     @staticmethod
     def _should_wrap(body: Sequence[QuantumStatement]) -> bool:
         # This protects shadowing of captured variables (i.e, bad user code) by wrapping the body in a function

classiq/model_expansions/quantum_operations/classical_var_emitter.py

@@ -1,3 +1,6 @@
+import re
+
+from classiq.interface.model.handle_binding import HandleBinding
 from classiq.interface.model.quantum_expressions.arithmetic_operation import (
     ArithmeticOperation,
 )
@@ -12,5 +15,8 @@ class ClassicalVarEmitter(Emitter[ArithmeticOperation]):
         if not isinstance(result_symbol, ClassicalSymbol):
             return False
         op._classical_assignment = True
+        match = re.search(r"measure\((.*?)\)", op.expression.expr)
+        if match is not None:
+            op.set_var_handles([HandleBinding(name=match.group(1))])
         self.emit_statement(op)
         return True

classiq/open_library/functions/__init__.py

@@ -8,6 +8,7 @@ from .discrete_sine_cosine_transform import _qct_d_operator, _qct_pi_operator
 from .grover import *
 from .grover import _cond_phase_flip
 from .hea import *
+from .lcu import *
 from .linear_pauli_rotation import *
 from .linear_pauli_rotation import _single_pauli
 from .lookup_table import span_lookup_table
@@ -100,6 +101,8 @@ __all__ = [
     "inplace_c_modular_multiply",
     "inplace_prepare_complex_amplitudes",
     "inplace_prepare_int",
+    "lcu",
+    "lcu_pauli",
     "linear_pauli_rotations",
     "modular_exp",
     "modular_increment",

classiq/open_library/functions/lcu.py

@@ -0,0 +1,117 @@
+from typing import Literal
+
+import numpy as np
+
+from classiq.open_library.functions.state_preparation import (
+    _load_phases,
+)
+from classiq.open_library.functions.utility_functions import switch
+from classiq.qmod.builtins.functions import IDENTITY, X, Y, Z, inplace_prepare_state
+from classiq.qmod.builtins.operations import (
+    control,
+    repeat,
+    within_apply,
+)
+from classiq.qmod.builtins.structs import IndexedPauli, SparsePauliOp
+from classiq.qmod.cparam import CArray
+from classiq.qmod.qfunc import qfunc
+from classiq.qmod.qmod_variable import QArray, QBit, QNum
+from classiq.qmod.quantum_callable import QCallableList
+
+
+@qfunc
+def apply_pauli_term(pauli_string: CArray[IndexedPauli], x: QArray[QBit]) -> None:
+    repeat(
+        count=pauli_string.len,
+        iteration=lambda i: switch(
+            pauli_string[i].pauli,
+            [
+                lambda: IDENTITY(x[pauli_string[i].index]),
+                lambda: X(x[pauli_string[i].index]),
+                lambda: Y(x[pauli_string[i].index]),
+                lambda: Z(x[pauli_string[i].index]),
+            ],
+        ),
+    )
+
+
+@qfunc
+def lcu(
+    coefficients: list[float],
+    unitaries: QCallableList,
+    block: QNum[Literal["max(ceiling(log(coefficients.len, 2)), 1)"]],
+) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Implements a general linear combination of unitaries (LCU) procedure. The algorithm prepares a superposition
+    over the `unitaries` according to `magnitudes`, and then conditionally applies each unitary controlled by the `block`.
+
+    The operation is of the form:
+
+    $$\\sum_j \\alpha_j U_j$$
+
+    where $U_j$ is a unitary operation applied to `data`.
+
+    Args:
+        coefficients: L1-normalized array of  $\\{ \\alpha_j \\}$ of the LCU coefficients.
+        unitaries: A list of quantum callable functions to be applied conditionally.
+        block: Quantum variable that holds the superposition index used for conditional application of each unitary.
+    """
+    coefficients = coefficients + [0] * (
+        2**block.size - len(coefficients)  # type:ignore[operator]
+    )
+    magnitudes = [np.abs(c) for c in coefficients]
+    magnitudes = (np.array(magnitudes) / np.sum(magnitudes)).tolist()
+    phases = [np.angle(complex(c)) for c in coefficients]
+
+    within_apply(
+        lambda: inplace_prepare_state(magnitudes, 0, block),
+        lambda: [
+            repeat(
+                count=unitaries.len,
+                iteration=lambda i: control(block == i, lambda: unitaries[i]()),
+            ),
+            # TODO: replace to sparse constant phase
+            _load_phases(phases, block),
+        ],
+    )
+
+
+@qfunc
+def lcu_pauli(
+    operator: SparsePauliOp,
+    data: QArray[QBit, Literal["operator.num_qubits"]],
+    block: QNum[Literal["max(ceiling(log(operator.terms.len, 2)), 1)"]],
+) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Applies a linear combination of unitaries (LCU) where each unitary is a Pauli term,
+    represented as a tensor product of Pauli operators. The function prepares a superposition
+    over the unitaries according to the given magnitudes and phases, and applies the corresponding
+    Pauli operators conditionally.
+
+    This is useful for implementing Hamiltonian terms of the form:
+
+    $$H=\\sum_j \\alpha_j P_j$$
+
+    where $P_j$ is a tensor product of Pauli operators.
+
+    Args:
+        operator: Operator consists of pauli strings with their coefficients, represented in a sparse format.
+        data: Quantum Variable on which the Pauli operators act. Its size must match the number of qubits required by the Pauli operator.
+        block: Quantum variable that holds the superposition index used for conditional application of each term.
+    """
+    coefficients = [
+        operator.terms[i].coefficient
+        for i in range(operator.terms.len)  # type:ignore[attr-defined]
+    ]
+    lcu(
+        coefficients,
+        [
+            lambda i=i: apply_pauli_term(operator.terms[i].paulis, data)
+            for i in range(operator.terms.len)  # type:ignore[attr-defined]
+        ],
+        block,
+    )

classiq/qmod/builtins/enums.py

@@ -188,7 +188,7 @@ class Pauli(IntEnum):
         )
 
         return SparsePauliOp(
-            terms=[  # type:ignore[arg-type]
+            terms=[
                 SparsePauliTerm(
                     paulis=[  # type:ignore[arg-type]
                         IndexedPauli(pauli=self, index=index)  # type:ignore[arg-type]
@@ -196,7 +196,7 @@ class Pauli(IntEnum):
                     coefficient=1.0,  # type:ignore[arg-type]
                 )
             ],
-            num_qubits=index + 1,  # type:ignore[arg-type]
+            num_qubits=index + 1,
         )
 
 

classiq/qmod/builtins/structs.py

@@ -63,27 +63,31 @@ class SparsePauliOp:
         num_qubits (CInt): The number of qubits in the Hamiltonian.
     """
 
-    terms: CArray[SparsePauliTerm]
-    num_qubits: CInt
+    terms: list[SparsePauliTerm]
+    num_qubits: int
 
     def __mul__(self, obj: Union[float, "SparsePauliOp"]) -> "SparsePauliOp":
         if isinstance(obj, (int, float, complex)):
             return SparsePauliOp(
-                terms=[  # type:ignore[arg-type]
+                terms=[
                     SparsePauliTerm(
                         paulis=term.paulis,
-                        coefficient=obj * term.coefficient,
+                        coefficient=obj * term.coefficient,  # type:ignore[arg-type]
                     )
-                    for term in self.terms  # type:ignore[attr-defined]
+                    for term in self.terms
                 ],
                 num_qubits=self.num_qubits,
             )
-        if len(self.terms) != 1 or len(obj.terms) != 1:  # type:ignore[arg-type]
+        if len(self.terms) != 1 or len(obj.terms) != 1:
             raise ClassiqValueError("Cannot attach a pauli to multiple pauli terms")
         existing_indices = {
-            indexed_pauli.index for indexed_pauli in self.terms[0].paulis
+            indexed_pauli.index
+            for indexed_pauli in self.terms[0].paulis  # type:ignore[attr-defined]
+        }
+        added_indices = {
+            indexed_pauli.index
+            for indexed_pauli in obj.terms[0].paulis  # type:ignore[attr-defined]
         }
-        added_indices = {indexed_pauli.index for indexed_pauli in obj.terms[0].paulis}
         overlapping_indices = sorted(existing_indices.intersection(added_indices))
         if len(overlapping_indices):
             raise ClassiqValueError(
@@ -93,15 +97,15 @@ class SparsePauliOp:
                 f"already assigned"
             )
         return SparsePauliOp(
-            terms=[  # type:ignore[arg-type]
+            terms=[
                 SparsePauliTerm(
-                    paulis=self.terms[0].paulis + obj.terms[0].paulis,
-                    coefficient=self.terms[0].coefficient * obj.terms[0].coefficient,
+                    paulis=self.terms[0].paulis
+                    + obj.terms[0].paulis,  # type:ignore[arg-type]
+                    coefficient=self.terms[0].coefficient
+                    * obj.terms[0].coefficient,  # type:ignore[arg-type]
                 )
             ],
-            num_qubits=max(
-                self.num_qubits, obj.num_qubits  # type:ignore[call-overload]
-            ),
+            num_qubits=max(self.num_qubits, obj.num_qubits),
         )
 
     def __rmul__(self, obj: Union[float, "SparsePauliOp"]) -> "SparsePauliOp":
@@ -109,10 +113,21 @@ class SparsePauliOp:
 
     def __add__(self, other: "SparsePauliOp") -> "SparsePauliOp":
         return SparsePauliOp(
-            terms=self.terms + other.terms,  # type:ignore[arg-type]
-            num_qubits=max(
-                self.num_qubits, other.num_qubits  # type:ignore[call-overload]
-            ),
+            terms=self.terms + other.terms,
+            num_qubits=max(self.num_qubits, other.num_qubits),
+        )
+
+    def __sub__(self, other: "SparsePauliOp") -> "SparsePauliOp":
+        return self + -1.0 * other
+
+    def __str__(self) -> str:
+        return " + ".join(
+            (f"{term.coefficient}*" if term.coefficient != 1 else "")
+            + "*".join(
+                f"Pauli.{indexed_pauli.pauli.name}({indexed_pauli.index})"
+                for indexed_pauli in term.paulis  # type:ignore[attr-defined]
+            )
+            for term in self.terms
         )
 
 

classiq/qmod/pretty_print/expression_to_python.py

@@ -71,12 +71,7 @@ class ASTToQMODCode(ast.NodeVisitor):
         return self.indent.join(self.visit(child) for child in node.body)
 
     def visit_Attribute(self, node: ast.Attribute) -> str:
-        if not isinstance(node.value, ast.Name) or not isinstance(node.attr, str):
-            raise AssertionError("Error parsing enum attribute access")
-        if not (IDENTIFIER.match(node.value.id) and IDENTIFIER.match(node.attr)):
-            raise AssertionError("Error parsing enum attribute access")
-        self._handle_imports(node.value.id)
-        return f"{node.value.id!s}.{node.attr!s}"
+        return f"{self.visit(node.value)}.{node.attr}"
 
     def visit_Name(self, node: ast.Name) -> str:
         self._handle_imports(node.id, True)
@@ -159,9 +154,12 @@ class ASTToQMODCode(ast.NodeVisitor):
             )
             return f"{self.visit(node.args[0])}({initializer_list})"
         else:
-            return "{}({})".format(
-                func, ", ".join(self._cleaned_ast_to_code(arg) for arg in node.args)
-            )
+            args = [self._cleaned_ast_to_code(arg) for arg in node.args]
+            kwargs = [
+                f"{kwarg.arg}={self._cleaned_ast_to_code(kwarg.value)}"
+                for kwarg in node.keywords
+            ]
+            return "{}({})".format(func, ", ".join(args + kwargs))
 
     def visit_Expr(self, node: ast.Expr) -> str:
         return self._cleaned_ast_to_code(node.value)

{classiq-0.86.0.dist-info → classiq-0.87.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: classiq
-Version: 0.86.0
+Version: 0.87.0
 Summary: Classiq's Python SDK for quantum computing
 License: Proprietary
 Keywords: quantum computing,quantum circuits,quantum algorithms,QAD,QDL
@@ -30,14 +30,14 @@ Provides-Extra: analyzer-sdk
 Provides-Extra: chemistry
 Provides-Extra: qml
 Requires-Dist: ConfigArgParse (>=1.5.3,<2.0.0)
-Requires-Dist: Pyomo (>=6.5,<6.6)
+Requires-Dist: Pyomo (>=6.9,<6.10)
 Requires-Dist: black (>=24.0,<25.0)
 Requires-Dist: httpx (>=0.23.0,<1)
 Requires-Dist: ipywidgets ; extra == "analyzer-sdk"
 Requires-Dist: jupyterlab ; extra == "analyzer-sdk"
 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: networkx (>=3.2.0,<4.0.0)
 Requires-Dist: notebook ; extra == "analyzer-sdk"
 Requires-Dist: numexpr (>=2.7.3,<3.0.0)
 Requires-Dist: numpy (>=1.20.1,<2.0.0) ; python_version < "3.12"