relationalai 0.13.0.dev0__py3-none-any.whl → 0.13.2__py3-none-any.whl

relationalai/semantics/std/decimals.py

@@ -1,55 +1,62 @@
 from __future__ import annotations
-
-from ..frontend.base import Concept, NumberConcept, Expression, Variable
-
-from . import NumberValue, numbers, _deprecated_library
-
+from typing import cast
+from decimal import Decimal as PyDecimal
+from relationalai.semantics.metamodel import ir, types
+from relationalai.semantics.internal import internal as b
+from .std import _make_expr
 
 #--------------------------------------------------
 # Constructors
 #--------------------------------------------------
 
-def decimal(value: NumberValue, precision=38, scale=14) -> Variable:
-    _warning(f"numbers.number({value}, {precision}, {scale})")
-    return numbers.number(value, precision, scale)
-
-def parse_decimal(value: str, precision=38, scale=14) -> Expression:
-    _warning(f"numbers.parse_number({value}, {precision}, {scale})")
-    return numbers.parse_number(value, precision, scale)
-
-def parse(value: str, decimal: Concept) -> Expression:
-    assert isinstance(decimal, NumberConcept)
-    _warning(f"numbers.parse({value}, {decimal})")
-    return numbers.parse(value, decimal)
-
-#--------------------------------------------------
-# Decimal information
-#--------------------------------------------------
-
-def is_decimal(decimal: Concept) -> bool:
-    assert isinstance(decimal, NumberConcept)
-    _warning(f"numbers.is_number({decimal})")
-    return numbers.is_number(decimal)
-
-def precision(decimal: Concept) -> int:
-    assert isinstance(decimal, NumberConcept)
-    _warning(f"numbers.precision({decimal})")
-    return numbers.precision(decimal)
-
-def scale(decimal: Concept) -> int:
-    assert isinstance(decimal, NumberConcept)
-    _warning(f"numbers.scale({decimal})")
-    return numbers.scale(decimal)
-
-def size(decimal: Concept) -> int:
-    assert isinstance(decimal, NumberConcept)
-    _warning(f"numbers.size({decimal})")
-    return numbers.size(decimal)
-
+def decimal(value: b.Producer|int|float|PyDecimal, precision=38, scale=14) -> b.Expression:
+    """
+    Create an expression that represents a decimal with this value, precision and scale.
+    """
+    if isinstance(value, int):
+        value = PyDecimal(str(value))
+    if isinstance(value, float):
+        value = PyDecimal(str(value))
+    return b.ConceptMember(b.decimal_concept(precision, scale), value, {})
+
+def parse_decimal(value: b.Producer|str, precision=38, scale=14) -> b.Expression:
+    """
+    Create an expression that represents parsing this string value as a decimal with this
+    precision and scale.
+    """
+    return _make_expr("parse_decimal", value, b.decimal_concept(precision, scale).ref("res"))
+
+def parse(value: b.Producer|str, decimal: b.Concept) -> b.Expression:
+    """
+    Create an expression that represents parsing this string value as a decimal with the
+    precision and scale of the decimal argument.
+    """
+    return parse_decimal(value, precision(decimal), scale(decimal))
 
 #--------------------------------------------------
-# Implementation
+# Decimal information.
 #--------------------------------------------------
 
-def _warning(example: str):
-    _deprecated_library("std.decimals", "std.numbers", example)
+def is_decimal(decimal: b.Concept) -> bool:
+    return b.is_decimal(decimal)
+
+def precision(decimal: b.Concept) -> int:
+    """ Assuming the concept represents a decimal, return its precision. """
+    assert b.is_decimal(decimal)
+    typ = cast(ir.DecimalType, types.decimal_by_type_str(decimal._name))
+    return typ.precision
+
+def scale(decimal: b.Concept) -> int:
+    """ Assuming the concept represents a decimal, return its scale. """
+    assert b.is_decimal(decimal)
+    typ = cast(ir.DecimalType, types.decimal_by_type_str(decimal._name))
+    return typ.scale
+
+def size(decimal: b.Concept) -> int:
+    """
+    Assuming the concept represents a decimal, return its size, i.e. the number of bits
+    needed to represent the decimal.
+    """
+    assert b.is_decimal(decimal)
+    typ = cast(ir.DecimalType, types.decimal_by_type_str(decimal._name))
+    return types.digits_to_bits(typ.precision)

relationalai/semantics/std/floats.py

@@ -1,15 +1,7 @@
-from . import StringValue
-from ..frontend.base import Library, Expression, Field, Value
-from ..frontend.core import Float, String, Number
-from decimal import Decimal as PyDecimal
+from __future__ import annotations
 
-# the front-end library object
-library = Library("floats")
+from relationalai.semantics.internal import internal as b
+from .std import _make_expr
 
-_parse_float = library.Relation("parse_float", [Field.input("value", String), Field("result", Float)])
-
-def float(value: Value) -> Expression:
-    return Float(value)
-
-def parse_float(value: StringValue) -> Expression:
-    return _parse_float(value)
+def parse_float(value: b.Producer|str) -> b.Expression:
+    return _make_expr("parse_float", value, b.Float.ref("res"))

relationalai/semantics/std/integers.py

@@ -1,37 +1,22 @@
 from __future__ import annotations
 
-from ..frontend.base import Expression, Variable
-from ..frontend.core import Integer
-
-from . import StringValue, IntegerValue, numbers, _deprecated_library
-
+from relationalai.semantics.internal import internal as b
+from .std import _make_expr
 
 # Coerce a number to Int64.
-def int64(value: IntegerValue) -> Variable:
-    _warning()
-    return Integer(value)
+def int64(value: b.Producer|int) -> b.ConceptMember:
+    return b.ConceptMember(b.Int64, value, {})
 
 # Coerce a number to Int128.
-def int128(value: IntegerValue) -> Variable:
-    _warning()
-    return Integer(value)
+def int128(value: b.Producer|int) -> b.ConceptMember:
+    return b.ConceptMember(b.Int128, value, {})
 
-def parse_int64(value: StringValue) -> Expression:
-    _warning(f"numbers.parse_number({value}, , 0)")
-    return numbers.parse_number(value, 19, 0)
+def parse_int64(value: b.Producer|str) -> b.Expression:
+    return _make_expr("parse_int64", value, b.Int64.ref("res"))
 
-def parse_int128(value: StringValue) -> Expression:
-    _warning(f"numbers.parse_number({value}, 38, 0)")
-    return numbers.parse_number(value, 38, 0)
+def parse_int128(value: b.Producer|str) -> b.Expression:
+    return _make_expr("parse_int128", value, b.Int128.ref("res"))
 
 # Alias parse_int128 to parse
-def parse(value: StringValue) -> Expression:
+def parse(value: b.Producer|str) -> b.Expression:
     return parse_int128(value)
-
-
-#--------------------------------------------------
-# Implementation
-#--------------------------------------------------
-
-def _warning(msg: str|None = None):
-    _deprecated_library("std.integers", "std.numbers", msg)

relationalai/semantics/std/math.py

@@ -1,212 +1,141 @@
 from __future__ import annotations
 
-from . import NumberValue, FloatValue, _get_number_value
-from ..frontend.base import Library, Expression, Field
-from ..frontend.core import Numeric, Number, Integer, Float, make_overloads, minus, mul, div, power
-
-# the front-end library object
-library = Library("math")
-
-# ------------------------------
-# Basics
-# ------------------------------
-_abs = library.Relation("abs", [Field.input("value", Numeric), Field("result", Numeric)], overloads=make_overloads([Number, Float], 2))
-_ceil = library.Relation("ceil", [Field.input("value", Numeric), Field("result", Numeric)], overloads=make_overloads([Number, Float], 2))
-_clip = library.Relation("clip", [Field.input("value", Numeric), Field.input("lower", Numeric), Field.input("upper", Numeric), Field("result", Numeric)], overloads=make_overloads([Number, Float], 4))
-_factorial = library.Relation("factorial", [Field.input("value", Integer), Field("result", Integer)])
-_floor = library.Relation("floor", [Field.input("value", Numeric), Field("result", Numeric)], overloads=make_overloads([Number, Float], 2))
-_isclose = library.Relation("isclose", [Field.input("tolerance", Numeric), Field.input("x", Numeric), Field.input("y", Numeric)], overloads=make_overloads([Number, Float], 3))
-_sign = library.Relation("sign", [Field.input("x", Numeric), Field("result", Integer)], overloads=[[Number, Integer], [Float, Integer]])
-_trunc_divide = library.Relation("trunc_divide", [Field.input("numerator", Number), Field.input("denominator", Number), Field("result", Number)])
-_maximum = library.Relation("maximum", [Field.input("left", Numeric), Field.input("right", Numeric), Field("result", Numeric)], overloads=make_overloads([Number, Float], 3))
-_minimum = library.Relation("minimum", [Field.input("left", Numeric), Field.input("right", Numeric), Field("result", Numeric)], overloads=make_overloads([Number, Float], 3))
-_isinf = library.Relation("isinf", [Field.input("value", Float)])
-_isnan = library.Relation("isnan", [Field.input("value", Float)])
-
-def abs(value: NumberValue) -> Expression:
-    return _abs(value)
-
-def ceil(value: NumberValue) -> Expression:
-    return _ceil(value)
-
-def clip(value: NumberValue, lower: NumberValue, upper: NumberValue) -> Expression:
-    # CLIP = CLAMP(v,min,max) = LEAST(max,GREATEST(min,v))
-    return _clip(lower, upper, value)
-
-def factorial(value: NumberValue) -> Expression:
-    v = _get_number_value(value)
-    if v is not None and v < 0:
-        raise ValueError("Cannot take the factorial of a negative number")
-    return _factorial(value)
-
-def floor(value: NumberValue) -> Expression:
-    return _floor(value)
-
-def isclose(x: NumberValue, y: NumberValue, tolerance: NumberValue = 1e-9) -> Expression:
-    # APPROX_EQUAL = ABS(x - y) < tolerance
-    return _isclose(tolerance, x, y)
-
-def sign(x: NumberValue) -> Expression:
-    return _sign(x)
-
-def trunc_divide(numerator: NumberValue, denominator: NumberValue) -> Expression:
-    return _trunc_divide(numerator, denominator)
-
-def maximum(left: NumberValue, right: NumberValue) -> Expression:
-    # GREATEST
-    return _maximum(left, right)
-
-def minimum(left: NumberValue, right: NumberValue) -> Expression:
-    # LEAST
-    return _minimum(left, right)
-
-def isinf(value: FloatValue) -> Expression:
-    return _isinf(value)
-
-def isnan(value: FloatValue) -> Expression:
-    return _isnan(value)
-
-# -------------------------------
-# Power and Logarithmic Functions
-# -------------------------------
-
-_cbrt = library.Relation("cbrt", [Field.input("value", Numeric), Field("result", Float)], overloads=[[Number, Float], [Float, Float]])
-_sqrt = library.Relation("sqrt", [Field.input("value", Numeric), Field("result", Float)], overloads=[[Number, Float], [Float, Float]])
-_exp = library.Relation("exp", [Field.input("value", Numeric), Field("result", Float)], overloads=[[Number, Float], [Float, Float]])
-_power = library.Relation("power", [Field.input("base", Numeric), Field.input("exponent", Numeric), Field("result", Float)],
-                          overloads=[
-                              #[Number, Number, Float], # v0 and engines are not handling this correctly
-                              [Float, Float, Float]])
-_log = library.Relation("log", [Field.input("base", Numeric), Field.input("value", Numeric), Field("result", Float)], overloads=[[Number, Number, Float], [Float, Float, Float]])
-_natural_log = library.Relation("natural_log", [Field.input("value", Numeric), Field("result", Float)], overloads=[[Number, Float], [Float, Float]])
-
-def cbrt(value: NumberValue) -> Expression:
-    return _cbrt(value)
-
-def sqrt(value: NumberValue) -> Expression:
-    v = _get_number_value(value)
-    if v is not None and v < 0:
-        raise ValueError("Cannot take the square root of a negative number")
-    return _sqrt(value)
-
-def exp(value: NumberValue) -> Expression:
-    return _exp(value)
-
-def pow(base: NumberValue, exponent: NumberValue) -> Expression:
-    return _power(base, exponent)
-
-def natural_log(value: NumberValue) -> Expression:
-    return _natural_log(value)
-
-def log(x: NumberValue, base: NumberValue | None = None) -> Expression:
-    v = _get_number_value(x)
-    if v is not None and v <= 0:
-        raise ValueError("Cannot take the logarithm of a non-positive number")
+from relationalai.semantics.internal import internal as b
+from .std import _Number, _make_expr
+from math import pi
+
+def abs(value: _Number) -> b.Expression:
+    return _make_expr("abs", value, b.Number.ref("res"))
+
+def natural_log(value: _Number) -> b.Expression:
+    return _make_expr("natural_log", value, b.Number.ref("res"))
+
+def log(value: _Number, base: _Number | None = None) -> b.Expression:
     if base is None:
-        return natural_log(x)
-    return _log(base, x)
+        return _make_expr("natural_log", value, b.Number.ref("res"))
+    return _make_expr("log", base, value, b.Number.ref("res"))
+
+def log2(value: _Number) -> b.Expression:
+    return _make_expr("log", 2, value, b.Number.ref("res"))
+
+def log10(value: _Number) -> b.Expression:
+    return _make_expr("log10", value, b.Number.ref("res"))
+
+def sqrt(value: _Number) -> b.Expression:
+    return _make_expr("sqrt", value, b.Float.ref("res"))
+
+def maximum(left: _Number, right: _Number) -> b.Expression:
+    return _make_expr("maximum", left, right, b.Number.ref("res"))
+
+def minimum(left: _Number, right: _Number) -> b.Expression:
+    return _make_expr("minimum", left, right, b.Number.ref("res"))
+
+def isinf(value: _Number) -> b.Expression:
+    return _make_expr("isinf", value)
+
+def isnan(value: _Number) -> b.Expression:
+    return _make_expr("isnan", value)
+
+def ceil(value: _Number) -> b.Expression:
+    return _make_expr("ceil", value, b.Number.ref("res"))
+
+def floor(value: _Number) -> b.Expression:
+    return _make_expr("floor", value, b.Number.ref("res"))
+
+def pow(base: _Number, exponent: _Number) -> b.Expression:
+    return _make_expr("pow", base, exponent, b.Float.ref("res"))
 
-def log2(value: NumberValue) -> Expression:
-    return log(value, 2)
+def cbrt(value: _Number) -> b.Expression:
+    return _make_expr("cbrt", value, b.Float.ref("res"))
 
-def log10(value: NumberValue) -> Expression:
-    return log(value, 10)
+def factorial(value: _Number) -> b.Expression:
+    return _make_expr("factorial", value, b.Number.ref("res"))
 
+def cos(value: _Number) -> b.Expression:
+    return _make_expr("cos", value, b.Float.ref("res"))
 
+def cosh(value: _Number) -> b.Expression:
+    return _make_expr("cosh", value, b.Float.ref("res"))
 
-# ------------------------------
-# Trigonometry
-# ------------------------------
+def acos(value: _Number) -> b.Expression:
+    return _make_expr("acos", value, b.Float.ref("res"))
 
-_degrees = library.Relation("degrees", [Field.input("radians", Numeric), Field("result", Float)], overloads=[[Number, Float], [Float, Float]])
-_radians = library.Relation("radians", [Field.input("degrees", Numeric), Field("result", Float)], overloads=[[Number, Float], [Float, Float]])
-_cos = library.Relation("cos", [Field.input("value", Numeric), Field("result", Float)], overloads=[[Number, Float], [Float, Float]])
-_sin = library.Relation("sin", [Field.input("value", Numeric), Field("result", Float)], overloads=[[Number, Float], [Float, Float]])
-_tan = library.Relation("tan", [Field.input("value", Numeric), Field("result", Float)], overloads=[[Number, Float], [Float, Float]])
-_cot = library.Relation("cot", [Field.input("value", Numeric), Field("result", Float)], overloads=[[Number, Float], [Float, Float]])
-_acos = library.Relation("acos", [Field.input("value", Numeric), Field("result", Float)], overloads=[[Number, Float], [Float, Float]])
-_asin = library.Relation("asin", [Field.input("value", Numeric), Field("result", Float)], overloads=[[Number, Float], [Float, Float]])
-_atan = library.Relation("atan", [Field.input("value", Numeric), Field("result", Float)], overloads=[[Number, Float], [Float, Float]])
-_acot = library.Relation("acot", [Field.input("value", Numeric), Field("result", Float)], overloads=[[Number, Float], [Float, Float]])
-_cosh = library.Relation("cosh", [Field.input("value", Numeric), Field("result", Float)], overloads=[[Number, Float], [Float, Float]])
-_sinh = library.Relation("sinh", [Field.input("value", Numeric), Field("result", Float)], overloads=[[Number, Float], [Float, Float]])
-_tanh = library.Relation("tanh", [Field.input("value", Numeric), Field("result", Float)], overloads=[[Number, Float], [Float, Float]])
-_acosh = library.Relation("acosh", [Field.input("value", Numeric), Field("result", Float)], overloads=[[Number, Float], [Float, Float]])
-_asinh = library.Relation("asinh", [Field.input("value", Numeric), Field("result", Float)], overloads=[[Number, Float], [Float, Float]])
-_atanh = library.Relation("atanh", [Field.input("value", Numeric), Field("result", Float)], overloads=[[Number, Float], [Float, Float]])
+def acosh(value: _Number) -> b.Expression:
+    return _make_expr("acosh", value, b.Float.ref("res"))
 
-def degrees(radians: NumberValue) -> Expression:
-    return _degrees(radians)
+def sin(value: _Number) -> b.Expression:
+    return _make_expr("sin", value, b.Float.ref("res"))
 
-def radians(degrees: NumberValue) -> Expression:
-    return _radians(degrees)
+def sinh(value: _Number) -> b.Expression:
+    return _make_expr("sinh", value, b.Float.ref("res"))
 
-def cos(value: NumberValue) -> Expression:
-    return _cos(value)
+def asin(value: _Number) -> b.Expression:
+    return _make_expr("asin", value, b.Float.ref("res"))
 
-def sin(value: NumberValue) -> Expression:
-    return _sin(value)
+def asinh(value: _Number) -> b.Expression:
+    return _make_expr("asinh", value, b.Float.ref("res"))
 
-def tan(value: NumberValue) -> Expression:
-    return _tan(value)
+def tan(value: _Number) -> b.Expression:
+    return _make_expr("tan", value, b.Float.ref("res"))
 
-def cot(value: NumberValue) -> Expression:
-    return _cot(value)
+def tanh(value: _Number) -> b.Expression:
+    return _make_expr("tanh", value, b.Float.ref("res"))
 
-def acos(value: NumberValue) -> Expression:
-    return _acos(value)
+def atan(value: _Number) -> b.Expression:
+    return _make_expr("atan", value, b.Float.ref("res"))
 
-def asin(value: NumberValue) -> Expression:
-    return _asin(value)
+def atanh(value: _Number) -> b.Expression:
+    return _make_expr("atanh", value, b.Float.ref("res"))
 
-def atan(value: NumberValue) -> Expression:
-    return _atan(value)
+def cot(value: _Number) -> b.Expression:
+    return _make_expr("cot", value, b.Float.ref("res"))
 
-def acot(value: NumberValue) -> Expression:
-    return _acot(value)
+def acot(value: _Number) -> b.Expression:
+    return _make_expr("acot", value, b.Float.ref("res"))
 
-def cosh(value: NumberValue) -> Expression:
-    return _cosh(value)
+def degrees(value: _Number) -> b.Expression:
+    divisor = pi / 180.0
+    return _make_expr("/", value, divisor, b.Float.ref("res"))
 
-def sinh(value: NumberValue) -> Expression:
-    return _sinh(value)
+def radians(value: _Number) -> b.Expression:
+    divisor = 180.0 / pi
+    return _make_expr("/", value, divisor, b.Float.ref("res"))
 
-def tanh(value: NumberValue) -> Expression:
-    return _tanh(value)
+def exp(value: _Number) -> b.Expression:
+    return _make_expr("exp", value, b.Float.ref("res"))
 
-def acosh(value: NumberValue) -> Expression:
-    v = _get_number_value(value)
-    if v is not None and v < 1:
-        raise ValueError("acosh expects a value greater than or equal to 1.")
-    return _acosh(value)
+def erf(value: _Number) -> b.Expression:
+    return _make_expr("erf", value, b.Float.ref("res"))
 
-def asinh(value: NumberValue) -> Expression:
-    return _asinh(value)
+def erfinv(value: _Number) -> b.Expression:
+    return _make_expr("erfinv", value, b.Float.ref("res"))
 
-def atanh(value: NumberValue) -> Expression:
-    v = _get_number_value(value)
-    if v is not None and (v <= -1 or v >= 1):
-        raise ValueError("atanh expects a value between -1 and 1, exclusive.")
-    return _atanh(value)
+def haversine(x1: _Number, y1: _Number, x2: _Number, y2: _Number, r: _Number) -> b.Expression:
+    # 2 * r * asin[sqrt[sin[(x2 - x1)/2] ^ 2 + cos[x1] * cos[x2] * sin[(y2 - y1) / 2] ^ 2]]
+    # sin[(x2 - x1)/2] ^ 2
+    x_diff = _make_expr("-", x2, x1, b.Float.ref("x_diff"))
+    x_diff2 = _make_expr("/", x_diff, 2.0, b.Float.ref("x_diff2"))
+    sin_x_diff = _make_expr("sin", x_diff2, b.Float.ref("sin_x_diff"))
+    sin_x_pow = _make_expr("pow", sin_x_diff, 2.0, b.Float.ref("sin_x_pow"))
 
-# ------------------------------
-# Special Functions
-# ------------------------------
-_erf = library.Relation("erf", [Field.input("value", Numeric), Field("result", Float)], overloads=[[Number, Float], [Float, Float]])
-_erfinv = library.Relation("erfinv", [Field.input("value", Numeric), Field("result", Float)], overloads=[[Number, Float], [Float, Float]])
+    # cos[x1] * cos[x2]
+    cos_x1 = _make_expr("cos", x1, b.Float.ref("cos_x1"))
+    cos_x2 = _make_expr("cos", x2, b.Float.ref("cos_x2"))
+    cos_x1_x2 = _make_expr("*", cos_x1, cos_x2, b.Float.ref("cos_x1_x2"))
 
-def erf(value: NumberValue) -> Expression:
-    return _erf(value)
+    # sin[(y2 - y1) / 2] ^ 2
+    y_diff = _make_expr("-", y2, y1, b.Float.ref("y_diff"))
+    y_diff2 = _make_expr("/", y_diff, 2.0, b.Float.ref("y_diff2"))
+    sin_y_diff = _make_expr("sin", y_diff2, b.Float.ref("sin_y_diff"))
+    sin_y_pow = _make_expr("pow", sin_y_diff, 2.0, b.Float.ref("sin_y_pow"))
 
-def erfinv(value: NumberValue) -> Expression:
-    v = _get_number_value(value)
-    if v is not None and (v < -1 or v > 1):
-        raise ValueError("erfinv expects a value between -1 and 1, inclusive.")
-    return _erfinv(value)
+    # cos[x1] * cos[x2] * sin[(y2 - y1) / 2] ^ 2
+    prod = _make_expr("*", cos_x1_x2, sin_y_pow, b.Float.ref("prod"))
+    # sin[(x2 - x1)/2] ^ 2 + cos[x1] * cos[x2] * sin[(y2 - y1) / 2] ^ 2
+    prod_sum = _make_expr("+", sin_x_pow, prod, b.Float.ref("prod_sum"))
 
-def haversine(lat1: NumberValue, lon1: NumberValue, lat2: NumberValue, lon2: NumberValue, radius: NumberValue = 1.0) -> Expression:
-    # 2 * r * asin[sqrt[sin[(lat2 - lat1)/2] ^ 2 + cos[lat1] * cos[lat2] * sin[(lon2 - lon1) / 2] ^ 2]]
-    return mul(2, radius, _asin(_sqrt(
-        power(_sin(div(minus(lat2, lat1), 2)), 2) +
-        mul(_cos(lat1), _cos(lat2), power(_sin(div(minus(lon2, lon1), 2)), 2))
-    )))
+    sqrt_val = _make_expr("sqrt", prod_sum, b.Float.ref("sqrt_val"))
+    asin_val = _make_expr("asin", sqrt_val, b.Float.ref("asin_val"))
+    haversine_r = _make_expr("*", r, asin_val, b.Float.ref("haversine_r"))
+    haversine_final = _make_expr("*", haversine_r, 2.0, b.Float.ref("haversine_final"))
+    return haversine_final

relationalai/semantics/std/pragmas.py

@@ -0,0 +1,11 @@
+from __future__ import annotations
+from typing import Any
+
+from relationalai.semantics.internal import internal as b
+from .std import _make_expr
+
+def rule_reasoner_semantic_variable_order(*args: Any) -> Any:
+    return _make_expr("rule_reasoner_sem_vo", b.TupleArg(args))
+
+def rule_reasoner_physical_variable_order(*args: Any) -> Any:
+    return _make_expr("rule_reasoner_phys_vo", b.TupleArg(args))