Merge branch 'main' into openqasm-circuitbinding

Author: speller26

CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## v1.119.1 (2026-06-10)
+
+### Bug Fixes and Other Changes
+
+ * support division in FreeParameterExpression string constructor
+
+## v1.119.0 (2026-06-09)
+
+### Features
+
+ * support math functions in FreeParameterExpression
+
 ## v1.118.0 (2026-06-04)
 
 ### Deprecations and Removals

src/braket/_sdk/_version.py

@@ -15,4 +15,4 @@
 Version number (major.minor.patch[-label])
 """
 
-__version__ = "1.118.1.dev0"
+__version__ = "1.119.2.dev0"

src/braket/parametric/__init__.py

@@ -14,10 +14,24 @@
 """You can define a circuit with gates that depend on free parameters and specify
 the values of these parameters when submitting the circuit as a quantum task.
 This module provides FreeParameter for defining symbolic parameters,
-FreeParameterExpression for mathematical expressions, and Parameterizable
-interface for parameter binding.
+FreeParameterExpression for mathematical expressions, math helper functions,
+and Parameterizable interface for parameter binding.
 """
 
 from braket.parametric.free_parameter import FreeParameter  # noqa: F401
 from braket.parametric.free_parameter_expression import FreeParameterExpression  # noqa: F401
+from braket.parametric.functions import (
+    arccos,  # noqa: F401
+    arcsin,  # noqa: F401
+    arctan,  # noqa: F401
+    ceiling,  # noqa: F401
+    cos,  # noqa: F401
+    exp,  # noqa: F401
+    floor,  # noqa: F401
+    log,  # noqa: F401
+    mod,  # noqa: F401
+    sin,  # noqa: F401
+    sqrt,  # noqa: F401
+    tan,  # noqa: F401
+)
 from braket.parametric.parameterizable import Parameterizable  # noqa: F401

src/braket/parametric/free_parameter_expression.py

@@ -17,11 +17,39 @@
 import operator
 from functools import reduce
 from numbers import Number
-from typing import Any
+from typing import Any, ClassVar
 
 import sympy
 from oqpy.base import OQPyExpression
 from oqpy.classical_types import FloatVar
+from sympy.printing.str import StrPrinter
+
+
+class _OpenQASMExpressionPrinter(StrPrinter):
+    _FN_MAP: ClassVar[dict[type, str]] = {
+        sympy.sin: "sin",
+        sympy.cos: "cos",
+        sympy.tan: "tan",
+        sympy.asin: "arcsin",
+        sympy.acos: "arccos",
+        sympy.atan: "arctan",
+        sympy.exp: "exp",
+        sympy.log: "log",
+        sympy.Mod: "mod",
+        sympy.ceiling: "ceiling",
+        sympy.floor: "floor",
+    }
+
+    def _print_Function(self, expr: sympy.Function) -> str:
+        function_name = self._FN_MAP.get(expr.func)
+        if function_name is None:
+            raise ValueError(f"No OpenQASM 3 equivalent for {expr.func.__name__}")
+        args = ", ".join(self._print(arg) for arg in expr.args)
+        return f"{function_name}({args})"
+
+
+def _openqasm_doprint(expression: Number | sympy.Expr) -> str:
+    return _OpenQASMExpressionPrinter().doprint(expression)
 
 
 class FreeParameterExpression:
@@ -31,6 +59,8 @@ class FreeParameterExpression:
     FreeParametersExpressions can hold FreeParameters that can later be
     swapped out for a number. Circuits or PulseSequences with FreeParameters
     present will NOT run. Values must be substituted prior to execution.
+    String representations of supported SymPy functions use OpenQASM-compatible
+    names.
     """
 
     def __init__(self, expression: FreeParameterExpression | Number | sympy.Expr | str):
@@ -54,6 +84,7 @@ def __init__(self, expression: FreeParameterExpression | Number | sympy.Expr | s
             ast.Add: self.__add__,
             ast.Sub: self.__sub__,
             ast.Mult: self.__mul__,
+            ast.Div: self.__truediv__,
             ast.Pow: self.__pow__,
             ast.USub: self.__neg__,
         }
@@ -177,9 +208,17 @@ def __repr__(self) -> str:
         """The representation of the :class:'FreeParameterExpression'.
 
         Returns:
-            str: The expression of the class:'FreeParameterExpression' to represent the class.
+            str: The OpenQASM-compatible string for the expression.
+        """
+        return str(self)
+
+    def __str__(self) -> str:
+        """The string representation of the :class:'FreeParameterExpression'.
+
+        Returns:
+            str: The OpenQASM-compatible string for the expression.
         """
-        return repr(self.expression)
+        return _openqasm_doprint(self.expression)
 
     def _to_oqpy_expression(self) -> OQPyExpression:
         """Transforms into an OQPyExpression.

src/braket/parametric/functions.py

@@ -0,0 +1,196 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+"""Math helper functions for free parameter expressions.
+
+These helpers let you build symbolic OpenQASM math expressions without importing
+SymPy or touching the internal expression attribute.
+
+Examples:
+    >>> from braket.circuits import Circuit
+    >>> from braket.parametric import FreeParameter, arcsin
+    >>> alpha = FreeParameter("alpha")
+    >>> circuit = Circuit().rx(0, arcsin(alpha))
+    >>> source = circuit.to_ir("OPENQASM").source
+    >>> "rx(arcsin(alpha)) q[0];" in source
+    True
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from numbers import Number
+
+import sympy
+
+from braket.parametric.free_parameter_expression import FreeParameterExpression
+
+
+def _expression(value: FreeParameterExpression | Number) -> Number | sympy.Expr:
+    return value.expression if isinstance(value, FreeParameterExpression) else value
+
+
+def _wrap(
+    function: Callable[..., Number | sympy.Expr],
+    *args: FreeParameterExpression | Number,
+) -> FreeParameterExpression:
+    sympy_args = [_expression(arg) for arg in args]
+    return FreeParameterExpression(function(*sympy_args))
+
+
+def sin(x: FreeParameterExpression | Number) -> FreeParameterExpression:
+    """Returns the sine of a free parameter expression.
+
+    Args:
+        x (FreeParameterExpression | Number): The expression.
+
+    Returns:
+        FreeParameterExpression: The symbolic sine expression.
+    """
+    return _wrap(sympy.sin, x)
+
+
+def cos(x: FreeParameterExpression | Number) -> FreeParameterExpression:
+    """Returns the cosine of a free parameter expression.
+
+    Args:
+        x (FreeParameterExpression | Number): The expression.
+
+    Returns:
+        FreeParameterExpression: The symbolic cosine expression.
+    """
+    return _wrap(sympy.cos, x)
+
+
+def tan(x: FreeParameterExpression | Number) -> FreeParameterExpression:
+    """Returns the tangent of a free parameter expression.
+
+    Args:
+        x (FreeParameterExpression | Number): The expression.
+
+    Returns:
+        FreeParameterExpression: The symbolic tangent expression.
+    """
+    return _wrap(sympy.tan, x)
+
+
+def arcsin(x: FreeParameterExpression | Number) -> FreeParameterExpression:
+    """Returns the arcsine (inverse sine) of a free parameter expression.
+
+    Args:
+        x (FreeParameterExpression | Number): The expression.
+
+    Returns:
+        FreeParameterExpression: The symbolic arcsine expression.
+    """
+    return _wrap(sympy.asin, x)
+
+
+def arccos(x: FreeParameterExpression | Number) -> FreeParameterExpression:
+    """Returns the arccosine (inverse cosine) of a free parameter expression.
+
+    Args:
+        x (FreeParameterExpression | Number): The expression.
+
+    Returns:
+        FreeParameterExpression: The symbolic arccosine expression.
+    """
+    return _wrap(sympy.acos, x)
+
+
+def arctan(x: FreeParameterExpression | Number) -> FreeParameterExpression:
+    """Returns the arctangent (inverse tangent) of a free parameter expression.
+
+    Args:
+        x (FreeParameterExpression | Number): The expression.
+
+    Returns:
+        FreeParameterExpression: The symbolic arctangent expression.
+    """
+    return _wrap(sympy.atan, x)
+
+
+def exp(x: FreeParameterExpression | Number) -> FreeParameterExpression:
+    """Returns the exponential of a free parameter expression.
+
+    Args:
+        x (FreeParameterExpression | Number): The expression.
+
+    Returns:
+        FreeParameterExpression: The symbolic exponential expression.
+    """
+    return _wrap(sympy.exp, x)
+
+
+def log(x: FreeParameterExpression | Number) -> FreeParameterExpression:
+    """Returns the natural logarithm of a free parameter expression.
+
+    Args:
+        x (FreeParameterExpression | Number): The expression.
+
+    Returns:
+        FreeParameterExpression: The symbolic natural logarithm expression.
+    """
+    return _wrap(sympy.log, x)
+
+
+def sqrt(x: FreeParameterExpression | Number) -> FreeParameterExpression:
+    """Returns the square root of a free parameter expression.
+
+    Args:
+        x (FreeParameterExpression | Number): The expression.
+
+    Returns:
+        FreeParameterExpression: The symbolic square root expression.
+    """
+    return _wrap(sympy.sqrt, x)
+
+
+def mod(
+    x: FreeParameterExpression | Number,
+    m: FreeParameterExpression | Number,
+) -> FreeParameterExpression:
+    """Returns the remainder of a free parameter expression divided by ``m``.
+
+    Args:
+        x (FreeParameterExpression | Number): The dividend expression.
+        m (FreeParameterExpression | Number): The divisor expression.
+
+    Returns:
+        FreeParameterExpression: The symbolic modulo expression.
+    """
+    return _wrap(sympy.Mod, x, m)
+
+
+def ceiling(x: FreeParameterExpression | Number) -> FreeParameterExpression:
+    """Returns the ceiling of a free parameter expression.
+
+    Args:
+        x (FreeParameterExpression | Number): The expression.
+
+    Returns:
+        FreeParameterExpression: The symbolic ceiling expression.
+    """
+    return _wrap(sympy.ceiling, x)
+
+
+def floor(x: FreeParameterExpression | Number) -> FreeParameterExpression:
+    """Returns the floor of a free parameter expression.
+
+    Args:
+        x (FreeParameterExpression | Number): The expression.
+
+    Returns:
+        FreeParameterExpression: The symbolic floor expression.
+    """
+    return _wrap(sympy.floor, x)

test/unit_tests/braket/devices/test_local_simulator.py

@@ -20,23 +20,26 @@
 from unittest.mock import Mock, patch
 
 import pytest
+import sympy
 from pydantic.v1 import create_model  # This is temporary for defining properties below
 
 import braket.ir as ir
 from braket.ahs.analog_hamiltonian_simulation import AnalogHamiltonianSimulation
 from braket.ahs.atom_arrangement import AtomArrangement
 from braket.ahs.hamiltonian import Hamiltonian
 from braket.annealing import Problem, ProblemType
-from braket.circuits import Circuit, FreeParameter, Gate, Noise
+from braket.circuits import Circuit, FreeParameter, FreeParameterExpression, Gate, Noise
 from braket.circuits.noise_model import GateCriteria, NoiseModel, NoiseModelInstruction
 from braket.circuits.serialization import IRType, SerializableProgram
+from braket.default_simulator import StateVectorSimulator
 from braket.device_schema import DeviceActionType, DeviceCapabilities
 from braket.device_schema.openqasm_device_action_properties import (
     OpenQASMDeviceActionProperties,
 )
 from braket.devices import LocalSimulator, local_simulator
 from braket.ir.openqasm import Program
 from braket.ir.openqasm.program_set_v1 import ProgramSet as OpenQASMProgramSet
+from braket.parametric import cos, sin
 from braket.program_sets import ProgramSet
 from braket.program_sets.circuit_binding import CircuitBinding
 from braket.simulator import BraketSimulator
@@ -689,6 +692,30 @@ def test_run_program_model_inputs():
     assert task.result() == GateModelQuantumTaskResult.from_object(GATE_MODEL_RESULT)
 
 
+def test_local_simulator_runs_sympy_inverse_trig_free_parameter_expression():
+    alpha = FreeParameter("alpha")
+    expr = FreeParameterExpression(sympy.asin(alpha.expression))
+    circuit = Circuit().rx(0, expr).measure(0)
+
+    assert "arcsin(alpha)" in circuit.to_ir("OPENQASM").source
+
+    device = LocalSimulator(StateVectorSimulator())
+    result = device.run(circuit, inputs={"alpha": 0.5}, shots=10).result()
+
+    assert sum(result.measurement_counts.values()) == 10
+
+
+def test_local_simulator_runs_parametric_math_helper_expression():
+    alpha = FreeParameter("alpha")
+    expr = sin(alpha / 2) ** 2 + cos(alpha / 2) ** 2
+    circuit = Circuit().rx(0, expr).measure(0)
+
+    device = LocalSimulator(StateVectorSimulator())
+    result = device.run(circuit, inputs={"alpha": math.pi}, shots=10).result()
+
+    assert sum(result.measurement_counts.values()) == 10
+
+
 def test_run_jaqcd_only_raises():
     dummy = DummyJaqcdSimulator()
     sim = LocalSimulator(dummy)