classiq 0.102.0__py3-none-any.whl → 0.104.0__py3-none-any.whl

classiq/applications/chemistry/op_utils.py

@@ -74,6 +74,38 @@ def qubit_op_to_qmod(
     )
 
 
+def qmod_to_qubit_op(operator: SparsePauliOp) -> QubitOperator:
+    """
+    Transforms Qmod's SparsePauliOp data structure to OpenFermion's QubitOperator data structure.
+
+    Args:
+        operator (SparsePauliOp): The operator to be transformed
+
+    Returns:
+        QubitOperator: The operator in OpenFermion's data structure
+    """
+
+    # Initiating the QubitOperator as the 0 operator
+    qo = QubitOperator()
+    for sparse_pauli_term in operator.terms:
+        # loop over all the IndexedPaulis
+        coeff = sparse_pauli_term.coefficient
+        if sparse_pauli_term.paulis:
+            qo.terms[
+                tuple(
+                    [
+                        (p.index, p.pauli.name)
+                        for p in sparse_pauli_term.paulis  # type: ignore[attr-defined]
+                        if p.pauli is not Pauli.I
+                    ]
+                )
+            ] = coeff
+        # Operator is the identity
+        else:
+            qo.terms[()] = coeff
+    return qo
+
+
 _PAULIS_TO_XZ = {"I": (0, 0), "X": (1, 0), "Z": (0, 1), "Y": (1, 1)}
 _XZ_TO_PAULIS = {(0, 0): "I", (1, 0): "X", (0, 1): "Z", (1, 1): "Y"}
 

classiq/evaluators/qmod_annotated_expression.py

@@ -207,7 +207,7 @@ class QmodAnnotatedExpression:
             node = id(node)
         return node in self._quantum_subscripts
 
-    def get_quantum_subcript(
+    def get_quantum_subscript(
         self, node: ast.AST | QmodExprNodeId
     ) -> QuantumSubscriptAnnotation:
         if isinstance(node, ast.AST):

classiq/evaluators/qmod_expression_visitors/qmod_expression_evaluator.py

@@ -77,7 +77,6 @@ class QmodExpressionEvaluator(ast.NodeVisitor):
         self,
         expr_val: QmodAnnotatedExpression,
         *,
-        treat_qnum_as_float: bool = False,
         machine_precision: int = DEFAULT_MACHINE_PRECISION,
         classical_struct_declarations: Sequence[StructDeclaration] | None = None,
         enum_declarations: Sequence[EnumDeclaration] | None = None,
@@ -88,7 +87,6 @@ class QmodExpressionEvaluator(ast.NodeVisitor):
         scope: Mapping[str, Any] | None = None,
     ) -> None:
         self._expr_val = expr_val
-        self._treat_qnum_as_float = treat_qnum_as_float
         self._machine_precision = machine_precision
         self._classical_struct_decls = nameables_to_dict(
             classical_struct_declarations or []
@@ -114,9 +112,7 @@ class QmodExpressionEvaluator(ast.NodeVisitor):
 
     def visit_BinOp(self, node: ast.BinOp) -> None:
         super().generic_visit(node)
-        eval_binary_op(
-            self._expr_val, node, self._treat_qnum_as_float, self._machine_precision
-        )
+        eval_binary_op(self._expr_val, node, self._machine_precision)
 
     def visit_UnaryOp(self, node: ast.UnaryOp) -> None:
         super().generic_visit(node)
@@ -164,7 +160,6 @@ class QmodExpressionEvaluator(ast.NodeVisitor):
                 self._expr_val,
                 node,
                 func_name,
-                self._treat_qnum_as_float,
                 self._machine_precision,
             )
             return
@@ -256,7 +251,6 @@ class QmodExpressionEvaluator(ast.NodeVisitor):
 def evaluate_qmod_expression(
     expr: str,
     *,
-    treat_qnum_as_float: bool = False,
     machine_precision: int = DEFAULT_MACHINE_PRECISION,
     classical_struct_declarations: Sequence[StructDeclaration] | None = None,
     enum_declarations: Sequence[EnumDeclaration] | None = None,
@@ -270,7 +264,6 @@ def evaluate_qmod_expression(
     expr_value = QmodAnnotatedExpression(expr_ast)
     QmodExpressionEvaluator(
         expr_value,
-        treat_qnum_as_float=treat_qnum_as_float,
         machine_precision=machine_precision,
         classical_struct_declarations=classical_struct_declarations,
         enum_declarations=enum_declarations,

classiq/evaluators/qmod_expression_visitors/qmod_expression_simplifier.py

@@ -122,7 +122,7 @@ class _InverseVarMaskTransformer(OutOfPlaceNodeTransformer):
 
 class _SympyCompatibilityTransformer(OutOfPlaceNodeTransformer):
     def visit_BoolOp(self, node: ast.BoolOp) -> ast.Call:
-        if len(node.values) != 2:
+        if len(node.values) < 2:
             raise ClassiqInternalExpansionError
         node = cast(ast.BoolOp, self.generic_visit(node))
         if isinstance(node.op, ast.Or):

classiq/evaluators/qmod_node_evaluators/attribute_evaluation.py

@@ -107,7 +107,7 @@ def _eval_type_attribute(
     if isinstance(subject_type, QuantumNumeric):
         if attr == "is_signed":
             expr_val.set_type(node, Bool())
-            if subject_type.has_sign:
+            if subject_type.has_constant_sign:
                 expr_val.set_value(node, subject_type.sign_value)
                 _remove_quantum_var(expr_val, subject)
             elif subject_type.has_size_in_bits:
@@ -120,7 +120,7 @@ def _eval_type_attribute(
             return
         if attr == "fraction_digits":
             expr_val.set_type(node, Integer())
-            if subject_type.has_fraction_digits:
+            if subject_type.has_constant_fraction_digits:
                 expr_val.set_value(node, subject_type.fraction_digits_value)
                 _remove_quantum_var(expr_val, subject)
             elif subject_type.has_size_in_bits:

classiq/evaluators/qmod_node_evaluators/binary_op_evaluation.py

@@ -50,7 +50,6 @@ def _validate_binary_op(
     op: ast.AST,
     left_type: QmodType,
     right_type: QmodType,
-    treat_qnum_as_float: bool,
 ) -> None:
     if not _binary_op_allowed(left_type, right_type, op):
         raise ClassiqExpansionError(
@@ -76,20 +75,19 @@ def _validate_binary_op(
             f"Binary operation {type(op).__name__!r} is not supported"
         )
 
-    if not treat_qnum_as_float:
-        if isinstance(op, ast.FloorDiv) and (
-            not is_classical_type(left_type) or not is_classical_type(right_type)
-        ):
-            raise ClassiqExpansionError(
-                f"{type(op).__name__!r} with quantum variables is not supported"
-            )
+    if isinstance(op, ast.FloorDiv) and (
+        not is_classical_type(left_type) or not is_classical_type(right_type)
+    ):
+        raise ClassiqExpansionError(
+            f"{type(op).__name__!r} with quantum variables is not supported"
+        )
 
-        if not is_classical_type(right_type) and isinstance(
-            op, (ast.Div, ast.Mod, ast.Pow, ast.LShift, ast.RShift)
-        ):
-            raise ClassiqExpansionError(
-                f"Right-hand side of binary operation {type(op).__name__!r} must be classical numeric value"
-            )
+    if not is_classical_type(right_type) and isinstance(
+        op, (ast.Div, ast.Mod, ast.Pow, ast.LShift, ast.RShift)
+    ):
+        raise ClassiqExpansionError(
+            f"Right-hand side of binary operation {type(op).__name__!r} must be classical numeric value"
+        )
 
 
 def _infer_binary_op_type(
@@ -98,7 +96,6 @@ def _infer_binary_op_type(
     left_type: QmodType,
     right_type: QmodType,
     machine_precision: int,
-    treat_qnum_as_float: bool,
 ) -> QmodType:
     op = node.op
 
@@ -113,19 +110,13 @@ def _infer_binary_op_type(
             return Integer()
         return Real()
 
-    left_attrs = get_numeric_attrs(
-        expr_val, node.left, left_type, machine_precision, treat_qnum_as_float
-    )
-    right_attrs = get_numeric_attrs(
-        expr_val, node.right, right_type, machine_precision, treat_qnum_as_float
-    )
+    left_attrs = get_numeric_attrs(expr_val, node.left, left_type, machine_precision)
+    right_attrs = get_numeric_attrs(expr_val, node.right, right_type, machine_precision)
 
     if left_attrs is None or right_attrs is None:
         return QuantumNumeric()
 
-    right_value = get_classical_value_for_arithmetic(
-        expr_val, node.right, right_type, treat_qnum_as_float
-    )
+    right_value = get_classical_value_for_arithmetic(expr_val, node.right, right_type)
 
     if isinstance(op, ast.Add):
         result_attrs = compute_result_attrs_add(
@@ -157,14 +148,14 @@ def _infer_binary_op_type(
         return QuantumNumeric()
 
     elif isinstance(op, ast.Mod):
-        if right_value is None or treat_qnum_as_float:
+        if right_value is None:
             return QuantumNumeric()
         result_attrs = compute_result_attrs_modulo(
             left_attrs, right_attrs, machine_precision
         )
 
     elif isinstance(op, ast.Pow):
-        if right_value is None or treat_qnum_as_float:
+        if right_value is None:
             return QuantumNumeric()
         result_attrs = compute_result_attrs_power(
             left_attrs, right_attrs, machine_precision
@@ -252,7 +243,6 @@ def _eval_binary_op_constant(
 def eval_binary_op(
     expr_val: QmodAnnotatedExpression,
     node: ast.BinOp,
-    treat_qnum_as_float: bool,
     machine_precision: int,
 ) -> None:
     left = node.left
@@ -261,7 +251,7 @@ def eval_binary_op(
 
     left_type = expr_val.get_type(left)
     right_type = expr_val.get_type(right)
-    _validate_binary_op(op, left_type, right_type, treat_qnum_as_float)
+    _validate_binary_op(op, left_type, right_type)
 
     inferred_type = _infer_binary_op_type(
         expr_val,
@@ -269,7 +259,6 @@ def eval_binary_op(
         left_type,
         right_type,
         machine_precision,
-        treat_qnum_as_float,
     )
     expr_val.set_type(node, inferred_type)
 

classiq/evaluators/qmod_node_evaluators/min_max_evaluation.py

@@ -31,7 +31,6 @@ def _infer_min_max_op_type(
     node: ast.Call,
     func_name: str,
     args_types: list[QmodType],
-    treat_qnum_as_float: bool,
     machine_precision: int,
 ) -> QmodType:
     if all(is_classical_type(arg_type) for arg_type in args_types):
@@ -41,9 +40,7 @@ def _infer_min_max_op_type(
 
     args_attrs: list[NumericAttributes] = []
     for arg, arg_type in zip(node.args, args_types):
-        attrs = get_numeric_attrs(
-            expr_val, arg, arg_type, machine_precision, treat_qnum_as_float
-        )
+        attrs = get_numeric_attrs(expr_val, arg, arg_type, machine_precision)
         if attrs is None:
             return QuantumNumeric()
         args_attrs.append(attrs)
@@ -62,7 +59,6 @@ def eval_min_max_op(
     expr_val: QmodAnnotatedExpression,
     node: ast.Call,
     func_name: str,
-    treat_qnum_as_float: bool,
     machine_precision: int,
 ) -> None:
     if len(node.args) < 1:
@@ -79,7 +75,6 @@ def eval_min_max_op(
         node,
         func_name,
         args_types,
-        treat_qnum_as_float,
         machine_precision,
     )
     expr_val.set_type(node, inferred_type)

classiq/evaluators/qmod_node_evaluators/numeric_attrs_utils.py

@@ -21,14 +21,11 @@ def get_numeric_attrs(
     node: ast.AST,
     qmod_type: QmodType,
     machine_precision: int,
-    treat_qnum_as_float: bool,
 ) -> NumericAttributes | None:
     if isinstance(qmod_type, Bool):
         return NumericAttributes.from_bounds(0, 1, 0, machine_precision)
     if is_classical_type(qmod_type):
-        value = get_classical_value_for_arithmetic(
-            expr_val, node, qmod_type, treat_qnum_as_float
-        )
+        value = get_classical_value_for_arithmetic(expr_val, node, qmod_type)
         if value is None:
             return None
         return NumericAttributes.from_constant(value, machine_precision)
@@ -44,7 +41,6 @@ def get_classical_value_for_arithmetic(
     expr_val: QmodAnnotatedExpression,
     node: ast.AST,
     qmod_type: QmodType,
-    treat_qnum_as_float: bool,
 ) -> float | None:
     if not is_classical_type(qmod_type):
         return None
@@ -55,8 +51,6 @@ def get_classical_value_for_arithmetic(
     if isinstance(value, sympy.Basic):
         value = get_sympy_val(value)
     if not isinstance(value, (int, float)):
-        if treat_qnum_as_float and isinstance(value, complex):
-            return None
         raise ClassiqExpansionError(
             "Arithmetic of quantum variables and non-real values is not supported"
         )

classiq/evaluators/qmod_type_inference/quantum_type_comparison.py

@@ -0,0 +1,52 @@
+from classiq.interface.exceptions import (
+    ClassiqInternalExpansionError,
+)
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.functions.type_name import TypeName
+from classiq.interface.model.quantum_type import (
+    QuantumBit,
+    QuantumBitvector,
+    QuantumNumeric,
+    QuantumType,
+)
+
+
+def _compare_expressions(expr1: Expression | None, expr2: Expression | None) -> bool:
+    if expr1 is None:
+        return expr2 is None
+    if expr2 is None:
+        return False
+    return expr1.expr == expr2.expr
+
+
+def compare_quantum_types(type_1: QuantumType, type_2: QuantumType) -> bool:
+    for qmod_type in (type_1, type_2):
+        if isinstance(qmod_type, TypeName) and not qmod_type.has_fields:
+            raise ClassiqInternalExpansionError("Quantum struct expected")
+    if isinstance(type_1, QuantumBit):
+        return isinstance(type_2, QuantumBit)
+    if isinstance(type_1, QuantumNumeric):
+        return (
+            isinstance(type_2, QuantumNumeric)
+            and _compare_expressions(type_1.size, type_2.size)
+            and _compare_expressions(type_1.is_signed, type_2.is_signed)
+            and _compare_expressions(type_1.fraction_digits, type_2.fraction_digits)
+        )
+    if isinstance(type_1, QuantumBitvector):
+        return (
+            isinstance(type_2, QuantumBitvector)
+            and _compare_expressions(type_1.length, type_2.length)
+            and compare_quantum_types(type_1.element_type, type_2.element_type)
+        )
+    if isinstance(type_1, TypeName):
+        return (
+            isinstance(type_2, TypeName)
+            and type_1.name == type_2.name
+            and all(
+                compare_quantum_types(field_type_1, field_type_2)
+                for field_type_1, field_type_2 in zip(
+                    type_1.fields.values(), type_2.fields.values(), strict=True
+                )
+            )
+        )
+    raise ClassiqInternalExpansionError(f"Unexpected type {type(type_1).__name__}")

classiq/execution/execution_session.py

@@ -365,7 +365,7 @@ class ExecutionSession:
              A list of tuples, each containing the estimated cost and the corresponding parameters for that iteration. `cost` is a float, and `parameters` is a dictionary matching the execution parameter format.
 
         See Also:
-            The [Classiq Tutorial](https://docs.classiq.io/latest/getting-started/classiq_tutorial/execution_tutorial_part2/) has examples on using this method in variational quantum algorithms.
+            The [Execution Tutorial](https://docs.classiq.io/latest/getting-started/classiq_tutorial/execution_tutorial_part2/) has examples on using this method in variational quantum algorithms.
             More information about [Hamiltonians](https://docs.classiq.io/latest/qmod-reference/language-reference/classical-types/#hamiltonians).
         """
         _hamiltonian_deprecation_warning(cost_function)

classiq/execution/functions/__init__.py

@@ -0,0 +1,3 @@
+from classiq.execution.functions.sample import _new_sample
+
+__all__ = ["_new_sample"]

classiq/execution/functions/_logging.py

@@ -0,0 +1,19 @@
+import logging
+
+_logger = logging.getLogger(__name__)
+
+
+def _setup_logging() -> None:
+    if _logger.handlers:
+        return
+
+    handler = logging.StreamHandler()
+    formatter = logging.Formatter("%(message)s")
+    handler.setFormatter(formatter)
+    _logger.addHandler(handler)
+    _logger.setLevel(logging.INFO)
+
+    _logger.propagate = False
+
+
+_setup_logging()

classiq/execution/functions/constants.py

@@ -0,0 +1,9 @@
+from enum import auto, unique
+
+from classiq.interface.enum_utils import StrEnum
+
+
+@unique
+class Verbosity(StrEnum):
+    QUIET = auto()
+    INFO = auto()

classiq/execution/functions/parse_provider_backend.py

@@ -0,0 +1,90 @@
+from classiq.interface.hardware import Provider
+
+_PROVIDER_BACKEND_SEPARATOR = "/"
+
+_PROVIDER_TO_CANONICAL_NAME: dict[Provider, str] = {
+    Provider.IBM_QUANTUM: "ibm",
+    Provider.AZURE_QUANTUM: "azure",
+    Provider.AMAZON_BRAKET: "braket",
+    Provider.IONQ: "ionq",
+    Provider.CLASSIQ: "classiq",
+    Provider.GOOGLE: "google",
+    Provider.ALICE_AND_BOB: "alice&bob",
+    Provider.OQC: "oqc",
+    Provider.INTEL: "intel",
+    Provider.AQT: "aqt",
+    Provider.CINECA: "cineca",
+    Provider.SOFTBANK: "softbank",
+}
+
+_CANONICAL_NAMES_TO_PROVIDER: dict[str, Provider] = {
+    name: provider for provider, name in _PROVIDER_TO_CANONICAL_NAME.items()
+}
+
+
+def _error_suggested_provider(provider_name: str) -> Provider | None:
+    """
+    In the case that receive an incorrect provider name, return a possible suggestion.
+    """
+    provider_name = provider_name.strip().lower()
+    for canonical_name in _CANONICAL_NAMES_TO_PROVIDER:
+        if canonical_name in provider_name:
+            return _CANONICAL_NAMES_TO_PROVIDER[canonical_name]
+    # Special cases
+    if "gcp" in provider_name:
+        return Provider.GOOGLE
+    if "microsoft" in provider_name:
+        return Provider.AZURE_QUANTUM
+    if "amazon" in provider_name or "aws" in provider_name:
+        return Provider.AMAZON_BRAKET
+    if "oxford" in provider_name:
+        return Provider.OQC
+    if "alice" in provider_name or "bob" in provider_name:
+        return Provider.ALICE_AND_BOB
+    if "alpine" in provider_name:
+        return Provider.AQT
+
+    return None
+
+
+def _parse_provider_backend(spec: str) -> tuple[Provider, str]:
+    """
+    Parse a backend specification into (provider, backend). Provider is case-insensitive.
+    Backend must NOT contain the separator. If provider is not specified, it defaults to
+    Classiq.
+    """
+    if not spec.strip():
+        raise ValueError("Backend specification must be a non-empty string")
+
+    spec = spec.strip()
+
+    if _PROVIDER_BACKEND_SEPARATOR not in spec:
+        return Provider.CLASSIQ, spec
+
+    provider_raw, backend = spec.split(_PROVIDER_BACKEND_SEPARATOR, 1)
+
+    if _PROVIDER_BACKEND_SEPARATOR in backend:
+        raise ValueError(
+            f"Backend name must not contain '{_PROVIDER_BACKEND_SEPARATOR}': '{backend}'"
+        )
+
+    provider_key = provider_raw.strip().lower()
+    backend = backend.strip()
+
+    if not provider_key:
+        raise ValueError("Provider name cannot be empty")
+    if not backend:
+        raise ValueError("Backend name cannot be empty")
+
+    try:
+        provider = _CANONICAL_NAMES_TO_PROVIDER[provider_key]
+    except KeyError:
+        error_message = f"Unrecognized provider '{provider_raw}'."
+        suggested_provider = _error_suggested_provider(provider_key)
+        if suggested_provider is not None:
+            error_message += (
+                f" Did you mean '{_PROVIDER_TO_CANONICAL_NAME[suggested_provider]}'?"
+            )
+        raise ValueError(error_message) from None
+
+    return provider, backend