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

relationalai/semantics/metamodel/builtins.py

@@ -1,210 +1,776 @@
-from __future__ import annotations
+"""
+    Elementary IR relations.
+"""
+import sys
+
+from . import ir, factory as f
+from . import types
+
 from typing import Optional
 
-from . import metamodel as mm
-
-class Relations:
-    """ Container for built-in relations in a library. """
-    def __init__(self):
-        self.data = dict[str, mm.Relation]()
-
-    def __getattr__(self, attr: str) -> mm.Relation:
-        return self.data[attr]
-
-    def __getitem__(self, attr: str) -> mm.Relation|None:
-        return self.data.get(attr)
-
-class CoreLibrary:
-    """ Declare some core types and relations as class attributes for performant access. """
-    # abstract types
-    Any: mm.ScalarType
-    AnyEntity: mm.ScalarType
-    Numeric: mm.ScalarType
-    TypeVar: mm.ScalarType
-    EntityTypeVar: mm.ScalarType
-    Number: mm.ScalarType
-    ScaledNumber: mm.ScalarType
-    # meta types
-    Field: mm.ScalarType
-    Relation: mm.ScalarType
-    Type: mm.ScalarType
-    Enum: mm.ScalarType
-    # concrete primitive types
-    Boolean: mm.ScalarType
-    String: mm.ScalarType
-    Date: mm.ScalarType
-    DateTime: mm.ScalarType
-    Float: mm.ScalarType
-    # type aliases
-    Integer: mm.NumberType
-    DefaultNumber: mm.NumberType
-    # binary operators
-    plus: mm.Relation
-    minus: mm.Relation
-    mul: mm.Relation
-    div: mm.Relation
-    trunc_div: mm.Relation
-    power: mm.Relation
-    mod: mm.Relation
-    # comparison operators
-    eq: mm.Relation
-    lt: mm.Relation
-    lte: mm.Relation
-    gt: mm.Relation
-    gte: mm.Relation
-    neq: mm.Relation
-    # typer relations
-    cast: mm.Relation
-
-    def __getitem__(self, attr: str) -> mm.Relation:
-        if attr in builtins._libraries["core"].data:
-            return builtins._libraries["core"].data[attr]
-        raise AttributeError(f"No built-in core attribute named '{attr}'.")
-
-    def __iter__(self):
-        yield from builtins._libraries["core"].data.values()
-
-class Builtins:
-    # Registered libraries by name
-    _libraries = dict[str, Relations]()
-    # Special case the core library for more performant access
-    core = CoreLibrary()
-
-    def register(self, library_name: str, relation: mm.Relation):
-        """
-            Register a built-in relation under the given library name.
-        """
-        if library_name not in self._libraries:
-            self._libraries[library_name] = Relations()
-        self._libraries[library_name].data[relation.name] = relation
-        if library_name == "core":
-            setattr(CoreLibrary, relation.name, relation)
-
-    # Dynamic access to libraries (e.g., builtins.math.abs)
-    def __getattr__(self, attr: str) -> Relations:
-        if attr in self._libraries:
-            return self._libraries[attr]
-        raise AttributeError(f"No built-in library named '{attr}'.")
-
-
-# Singleton instance of the builtins container
-builtins = Builtins()
-
-#------------------------------------------------------
-# Helpers
-#------------------------------------------------------
-def is_function(r: mm.Relation) -> bool:
-    """ True if the relation is a function (i.e., it has inputs and has a single output). """
-    if len(r.fields) <= 1:
-        return False
-    # at least 2 fields, only 1 can be output
-    output_fields = [f for f in r.fields if not f.input]
-    return len(output_fields) == 1
-
-def is_monotyped(r: mm.Relation) -> bool:
-    if len(r.fields) == 0:
-        return True
-
-    # all types must be the same
-    first = r.fields[0].type
-    if any(f.type != first for f in r.fields):
-        return False
-
-    if r.overloads:
-        # every overload must have all fields of the same type
-        for overload in r.overloads:
-            first = overload.types[0]
-            if any(f_type != first for f_type in overload.types):
-                return False
-    return True
-
-def is_placeholder(relation: mm.Relation) -> bool:
-    """ Whether this relation is an unresolved placeholder that needs to be resolved. """
-    return isinstance(relation, mm.UnresolvedRelation)
-
-def is_abstract(t: mm.Type) -> bool:
-    """ True if the type is abstract, or a collection or union containing an abstract type.
-    """
-    if isinstance(t, mm.ScalarType):
-        return t in [
-            builtins.core.Any,
-            builtins.core.AnyEntity,
-            builtins.core.Number,
-            builtins.core.ScaledNumber,
-            builtins.core.Numeric,
-            builtins.core.TypeVar,
-            builtins.core.EntityTypeVar
-        ]
-    elif isinstance(t, mm.ListType):
-        return is_abstract(t.element_type)
-    elif isinstance(t, mm.UnionType):
-        return any(is_abstract(t) for t in t.types)
-    else:
-        return False
+#
+# Relations
+#
+
+# Comparators
+def _comparator(name: str, input=True):
+    overloads = [
+        f.relation(name, [f.field("a", type, input), f.field("b", type, input)])
+        for type in [types.Bool, types.Int64, types.Int128, types.Float, types.GenericDecimal, types.String, types.Date, types.DateTime, types.Hash, types.EntityTypeVar]
+    ]
+    return f.relation(name, [f.field("a", types.Any, input), f.field("b", types.Any, input)], overloads=overloads)
 
-def is_type_var(t: mm.Type) -> bool:
-    return t in [
-        builtins.core.TypeVar,
-        builtins.core.EntityTypeVar,
+gt = _comparator(">")
+gte = _comparator(">=")
+lt = _comparator("<")
+lte = _comparator("<=")
+neq = _comparator("!=")
+eq = _comparator("=", False)
+
+def is_eq(other: ir.Relation) -> bool:
+    return other == eq or other in eq.overloads
+
+# Arithmetic operators
+def _binary_op(name: str, with_string=False, result_type: Optional[ir.Type]=None):
+    overload_types = [types.Int64, types.Int128, types.Float, types.GenericDecimal]
+    if with_string:
+        overload_types.append(types.String)
+    overloads = [
+        f.relation(name, [
+            f.input_field("a", type),
+            f.input_field("b", type),
+            f.field("c", result_type if result_type is not None else type)])
+        for type in overload_types
     ]
 
-def is_concrete(t: mm.Type) -> bool:
-    return not is_abstract(t)
-
-def is_number(t: mm.Type) -> bool:
-    """ True if the type is a number type. """
-    # note that builtins.core.Number is a ScalarType that represents "any number type",
-    # whereas concrete numbers are represented by NumberType instances.
-    return isinstance(t, mm.NumberType) or t == builtins.core.Number
-
-def is_numeric(t: mm.Type) -> bool:
-    """ True if the type is numeric (Number or Float). """
-    # TODO - we could check by supertype instead, but that would be slower
-    return t == builtins.core.Numeric or t == builtins.core.Float or is_number(t)
-
-def is_primitive(t: mm.Type) -> bool:
-    """
-        True if the type is a primitive type (boolean, string, date, datetime, float, number).
-    """
-    return t in [
-        CoreLibrary.Boolean,
-        CoreLibrary.String,
-        CoreLibrary.Date,
-        CoreLibrary.DateTime,
-        CoreLibrary.Float
-    ] or is_number(t)
-
-def is_value_type(type: mm.Type):
-    """ True if the type extends a primitive type (i.e., is a value type). """
-    return isinstance(type, mm.ScalarType) and not is_primitive(type) and get_primitive_supertype(type) is not None
-
-def get_primitive_supertype(type: mm.Type) -> Optional[mm.Type]:
-    """ Search the type hierarchy for a primitive supertype. """
-    if isinstance(type, mm.ScalarType):
-        if is_primitive(type):
-            return type
-        # walk the hierarchy to find a base primitive
-        for parent in type.super_types:
-            if found := get_primitive_supertype(parent):
-                return found
-    if isinstance(type, mm.UnionType):
-        for t in type.types:
-            if found := get_primitive_supertype(t):
-                return found
-    return None
-
-def get_number_supertype(type: mm.Type) -> Optional[mm.NumberType]:
-    x = get_primitive_supertype(type)
-    if isinstance(x, mm.NumberType):
-        return x
-    return None
-
-def extends(type: mm.Type, supertype: mm.Type) -> bool:
-    """ True if `type` extends `supertype` in the type hierarchy. """
-    if type == supertype:
-        return True
-    if isinstance(type, mm.ScalarType):
-        for parent in type.super_types:
-            if extends(parent, supertype):
-                return True
-    return False
+    if with_string:
+        return f.relation(name, [f.input_field("a", types.Any), f.input_field("b", types.Any), f.field("c", types.Any)], overloads=overloads)
+    else:
+        # If strings isn't added, then we're guaranteed to only have number overloads
+        result_type = result_type if result_type is not None else types.Number
+        return f.relation(name, [f.input_field("a", types.Number), f.input_field("b", types.Number), f.field("c", result_type)], overloads=overloads)
+
+plus = _binary_op("+", with_string=True)
+minus = _binary_op("-")
+mul = _binary_op("*")
+div = f.relation(
+    "/",
+    [f.input_field("a", types.Number), f.input_field("b", types.Number), f.field("c", types.Number)],
+    overloads=[
+        f.relation("/", [f.input_field("a", types.Int64), f.input_field("b", types.Int64), f.field("c", types.Float)]),
+        f.relation("/", [f.input_field("a", types.Int128), f.input_field("b", types.Int128), f.field("c", types.Float)]),
+        f.relation("/", [f.input_field("a", types.Float), f.input_field("b", types.Float), f.field("c", types.Float)]),
+        f.relation("/", [f.input_field("a", types.GenericDecimal), f.input_field("b", types.GenericDecimal), f.field("c", types.GenericDecimal)]),
+    ],
+)
+mod = _binary_op("%")
+power = _binary_op("^")
+
+trunc_div = f.relation(
+    "//",
+    [f.input_field("a", types.Number), f.input_field("b", types.Number), f.field("c", types.Number)],
+    overloads=[
+        f.relation("//", [f.input_field("a", types.Int64), f.input_field("b", types.Int64), f.field("c", types.Int64)]),
+        f.relation("//", [f.input_field("a", types.Int128), f.input_field("b", types.Int128), f.field("c", types.Int128)]),
+    ],
+)
+
+abs = f.relation(
+    "abs",
+    [f.input_field("a", types.Number), f.field("b", types.Number)],
+    overloads=[
+        f.relation("abs", [f.input_field("a", types.Int64), f.field("b", types.Int64)]),
+        f.relation("abs", [f.input_field("a", types.Int128), f.field("b", types.Int128)]),
+        f.relation("abs", [f.input_field("a", types.Float), f.field("b", types.Float)]),
+        f.relation("abs", [f.input_field("a", types.GenericDecimal), f.field("b", types.GenericDecimal)]),
+    ],
+)
+
+natural_log = f.relation(
+    "natural_log",
+    [f.input_field("a", types.Number), f.field("b", types.Float)],
+    overloads=[
+        f.relation("natural_log", [f.input_field("a", types.Int64), f.field("b", types.Float)]),
+        f.relation("natural_log", [f.input_field("a", types.Int128), f.field("b", types.Float)]),
+        f.relation("natural_log", [f.input_field("a", types.Float), f.field("b", types.Float)]),
+        f.relation("natural_log", [f.input_field("a", types.GenericDecimal), f.field("b", types.Float)]),
+
+    ],
+)
+
+log10 = f.relation(
+    "log10",
+    [f.input_field("a", types.Number), f.field("b", types.Float)],
+    overloads=[
+        f.relation("log10", [f.input_field("a", types.Int64), f.field("b", types.Float)]),
+        f.relation("log10", [f.input_field("a", types.Int128), f.field("b", types.Float)]),
+        f.relation("log10", [f.input_field("a", types.Float), f.field("b", types.Float)]),
+        f.relation("log10", [f.input_field("a", types.GenericDecimal), f.field("b", types.Float)]),
+
+    ],
+)
+
+log = f.relation(
+    "log",
+    [f.input_field("base", types.Number), f.input_field("value", types.Number), f.field("result", types.Float)],
+    overloads=[
+        f.relation("log", [f.input_field("base", types.Int64), f.input_field("value", types.Int64), f.field("result", types.Float)]),
+        f.relation("log", [f.input_field("base", types.Int128), f.input_field("value", types.Int128), f.field("result", types.Float)]),
+        f.relation("log", [f.input_field("base", types.Float), f.input_field("value", types.Float), f.field("result", types.Float)]),
+        f.relation("log", [f.input_field("base", types.GenericDecimal), f.input_field("value", types.GenericDecimal), f.field("result", types.Float)]),
+
+    ],
+)
+
+sqrt = f.relation(
+    "sqrt",
+    [f.input_field("a", types.Number), f.field("b", types.Float)],
+    overloads=[
+        f.relation("sqrt", [f.input_field("a", types.Int64), f.field("b", types.Float)]),
+        f.relation("sqrt", [f.input_field("a", types.Int128), f.field("b", types.Float)]),
+        f.relation("sqrt", [f.input_field("a", types.Float), f.field("b", types.Float)]),
+        f.relation("sqrt", [f.input_field("a", types.GenericDecimal), f.field("b", types.Float)]),
+    ],
+)
+
+maximum = f.relation(
+    "maximum",
+    [f.input_field("a", types.Number), f.input_field("b", types.Number), f.field("c", types.Number)],
+    overloads=[
+        f.relation("maximum", [f.input_field("a", types.Int64), f.input_field("b", types.Int64), f.field("c", types.Int64)]),
+        f.relation("maximum", [f.input_field("a", types.Int128), f.input_field("b", types.Int128), f.field("c", types.Int128)]),
+        f.relation("maximum", [f.input_field("a", types.Float), f.input_field("b", types.Float), f.field("c", types.Float)]),
+        f.relation("maximum", [f.input_field("a", types.GenericDecimal), f.input_field("b", types.GenericDecimal), f.field("c", types.GenericDecimal)]),
+    ],
+)
+
+minimum = f.relation(
+    "minimum",
+    [f.input_field("a", types.Number), f.input_field("b", types.Number), f.field("c", types.Number)],
+    overloads=[
+        f.relation("minimum", [f.input_field("a", types.Int64), f.input_field("b", types.Int64), f.field("c", types.Int64)]),
+        f.relation("minimum", [f.input_field("a", types.Int128), f.input_field("b", types.Int128), f.field("c", types.Int128)]),
+        f.relation("minimum", [f.input_field("a", types.Float), f.input_field("b", types.Float), f.field("c", types.Float)]),
+        f.relation("minimum", [f.input_field("a", types.GenericDecimal), f.input_field("b", types.GenericDecimal), f.field("c", types.GenericDecimal)]),
+    ],
+)
+
+ceil = f.relation(
+    "ceil",
+    [f.input_field("a", types.Number), f.field("b", types.Number)],
+    overloads=[
+        f.relation("ceil", [f.input_field("a", types.Int64), f.field("b", types.Int64)]),
+        f.relation("ceil", [f.input_field("a", types.Int128), f.field("b", types.Int128)]),
+        f.relation("ceil", [f.input_field("a", types.Float), f.field("b", types.Float)]),
+        f.relation("ceil", [f.input_field("a", types.GenericDecimal), f.field("b", types.GenericDecimal)]),
+    ],
+)
+
+floor = f.relation(
+    "floor",
+    [f.input_field("a", types.Number), f.field("b", types.Number)],
+    overloads=[
+        f.relation("floor", [f.input_field("a", types.Int64), f.field("b", types.Int64)]),
+        f.relation("floor", [f.input_field("a", types.Int128), f.field("b", types.Int128)]),
+        f.relation("floor", [f.input_field("a", types.Float), f.field("b", types.Float)]),
+        f.relation("floor", [f.input_field("a", types.GenericDecimal), f.field("b", types.GenericDecimal)]),
+    ],
+)
+
+isinf = f.relation("isinf", [f.input_field("a", types.Float)])
+isnan = f.relation("isnan", [f.input_field("a", types.Float)])
+
+pow = f.relation(
+    "pow",
+    [f.input_field("a", types.Number), f.input_field("b", types.Number), f.field("c", types.Float)],
+    # Everything will be converted to float to avoid NaN results with other types
+    overloads=[
+        f.relation("pow", [f.input_field("a", types.Float), f.input_field("b", types.Float), f.field("c", types.Float)]),
+    ],
+)
+
+cbrt = f.relation(
+    "cbrt",
+    [f.input_field("a", types.Number), f.field("b", types.Float)],
+    overloads=[
+        f.relation("cbrt", [f.input_field("a", types.Int64), f.field("b", types.Float)]),
+        f.relation("cbrt", [f.input_field("a", types.Int128), f.field("b", types.Float)]),
+        f.relation("cbrt", [f.input_field("a", types.Float), f.field("b", types.Float)]),
+        f.relation("cbrt", [f.input_field("a", types.GenericDecimal), f.field("b", types.Float)])
+    ],
+)
+
+factorial = f.relation(
+    "factorial",
+    [f.input_field("a", types.Number), f.field("b", types.Number)],
+    overloads=[
+        f.relation("factorial", [f.input_field("a", types.Int64), f.field("b", types.Int64)]),
+        f.relation("factorial", [f.input_field("a", types.Int128), f.field("b", types.Int128)]),
+        f.relation("factorial", [f.input_field("a", types.UInt128), f.field("b", types.UInt128)])
+    ],
+)
+
+cos = f.relation(
+    "cos",
+    [f.input_field("a", types.Number), f.field("b", types.Float)],
+    overloads=[
+        f.relation("cos", [f.input_field("a", types.Int64), f.field("b", types.Float)]),
+        f.relation("cos", [f.input_field("a", types.Int128), f.field("b", types.Float)]),
+        f.relation("cos", [f.input_field("a", types.Float), f.field("b", types.Float)]),
+        f.relation("cos", [f.input_field("a", types.GenericDecimal), f.field("b", types.Float)])
+    ],
+)
+
+cosh = f.relation(
+    "cosh",
+    [f.input_field("a", types.Number), f.field("b", types.Float)],
+    overloads=[
+        f.relation("cosh", [f.input_field("a", types.Int64), f.field("b", types.Float)]),
+        f.relation("cosh", [f.input_field("a", types.Int128), f.field("b", types.Float)]),
+        f.relation("cosh", [f.input_field("a", types.Float), f.field("b", types.Float)]),
+        f.relation("cosh", [f.input_field("a", types.GenericDecimal), f.field("b", types.Float)])
+    ],
+)
+
+acos = f.relation(
+    "acos",
+    [f.input_field("a", types.Number), f.field("b", types.Float)],
+    overloads=[
+        f.relation("acos", [f.input_field("a", types.Int64), f.field("b", types.Float)]),
+        f.relation("acos", [f.input_field("a", types.Int128), f.field("b", types.Float)]),
+        f.relation("acos", [f.input_field("a", types.Float), f.field("b", types.Float)]),
+        f.relation("acos", [f.input_field("a", types.GenericDecimal), f.field("b", types.Float)])
+    ],
+)
+
+acosh = f.relation(
+    "acosh",
+    [f.input_field("a", types.Number), f.field("b", types.Float)],
+    overloads=[
+        f.relation("acosh", [f.input_field("a", types.Int64), f.field("b", types.Float)]),
+        f.relation("acosh", [f.input_field("a", types.Int128), f.field("b", types.Float)]),
+        f.relation("acosh", [f.input_field("a", types.Float), f.field("b", types.Float)]),
+        f.relation("acosh", [f.input_field("a", types.GenericDecimal), f.field("b", types.Float)])
+    ],
+)
+
+sin = f.relation(
+    "sin",
+    [f.input_field("a", types.Number), f.field("b", types.Float)],
+    overloads=[
+        f.relation("sin", [f.input_field("a", types.Int64), f.field("b", types.Float)]),
+        f.relation("sin", [f.input_field("a", types.Int128), f.field("b", types.Float)]),
+        f.relation("sin", [f.input_field("a", types.Float), f.field("b", types.Float)]),
+        f.relation("sin", [f.input_field("a", types.GenericDecimal), f.field("b", types.Float)])
+    ],
+)
+
+sinh = f.relation(
+    "sinh",
+    [f.input_field("a", types.Number), f.field("b", types.Float)],
+    overloads=[
+        f.relation("sinh", [f.input_field("a", types.Int64), f.field("b", types.Float)]),
+        f.relation("sinh", [f.input_field("a", types.Int128), f.field("b", types.Float)]),
+        f.relation("sinh", [f.input_field("a", types.Float), f.field("b", types.Float)]),
+        f.relation("sinh", [f.input_field("a", types.GenericDecimal), f.field("b", types.Float)])
+    ],
+)
+
+asin = f.relation(
+    "asin",
+    [f.input_field("a", types.Number), f.field("b", types.Float)],
+    overloads=[
+        f.relation("asin", [f.input_field("a", types.Int64), f.field("b", types.Float)]),
+        f.relation("asin", [f.input_field("a", types.Int128), f.field("b", types.Float)]),
+        f.relation("asin", [f.input_field("a", types.Float), f.field("b", types.Float)]),
+        f.relation("asin", [f.input_field("a", types.GenericDecimal), f.field("b", types.Float)])
+    ],
+)
+
+asinh = f.relation(
+    "asinh",
+    [f.input_field("a", types.Number), f.field("b", types.Float)],
+    overloads=[
+        f.relation("asinh", [f.input_field("a", types.Int64), f.field("b", types.Float)]),
+        f.relation("asinh", [f.input_field("a", types.Int128), f.field("b", types.Float)]),
+        f.relation("asinh", [f.input_field("a", types.Float), f.field("b", types.Float)]),
+        f.relation("asinh", [f.input_field("a", types.GenericDecimal), f.field("b", types.Float)])
+    ],
+)
+
+tan = f.relation(
+    "tan",
+    [f.input_field("a", types.Number), f.field("b", types.Float)],
+    overloads=[
+        f.relation("tan", [f.input_field("a", types.Int64), f.field("b", types.Float)]),
+        f.relation("tan", [f.input_field("a", types.Int128), f.field("b", types.Float)]),
+        f.relation("tan", [f.input_field("a", types.Float), f.field("b", types.Float)]),
+        f.relation("tan", [f.input_field("a", types.GenericDecimal), f.field("b", types.Float)])
+    ],
+)
+
+tanh = f.relation(
+    "tanh",
+    [f.input_field("a", types.Number), f.field("b", types.Float)],
+    overloads=[
+        f.relation("tanh", [f.input_field("a", types.Int64), f.field("b", types.Float)]),
+        f.relation("tanh", [f.input_field("a", types.Int128), f.field("b", types.Float)]),
+        f.relation("tanh", [f.input_field("a", types.Float), f.field("b", types.Float)]),
+        f.relation("tanh", [f.input_field("a", types.GenericDecimal), f.field("b", types.Float)])
+    ],
+)
+
+atan = f.relation(
+    "atan",
+    [f.input_field("a", types.Number), f.field("b", types.Float)],
+    overloads=[
+        f.relation("atan", [f.input_field("a", types.Int64), f.field("b", types.Float)]),
+        f.relation("atan", [f.input_field("a", types.Int128), f.field("b", types.Float)]),
+        f.relation("atan", [f.input_field("a", types.Float), f.field("b", types.Float)]),
+        f.relation("atan", [f.input_field("a", types.GenericDecimal), f.field("b", types.Float)])
+    ],
+)
+
+atanh = f.relation(
+    "atanh",
+    [f.input_field("a", types.Number), f.field("b", types.Float)],
+    overloads=[
+        f.relation("atanh", [f.input_field("a", types.Int64), f.field("b", types.Float)]),
+        f.relation("atanh", [f.input_field("a", types.Int128), f.field("b", types.Float)]),
+        f.relation("atanh", [f.input_field("a", types.Float), f.field("b", types.Float)]),
+        f.relation("atanh", [f.input_field("a", types.GenericDecimal), f.field("b", types.Float)])
+    ],
+)
+cot = f.relation(
+    "cot",
+    [f.input_field("a", types.Number), f.field("b", types.Float)],
+    # Everything will be converted to float to avoid NaN results with other types
+    overloads=[
+        f.relation("cot", [f.input_field("a", types.Float), f.field("b", types.Float)])
+    ],
+)
+
+acot = f.relation(
+    "acot",
+    [f.input_field("a", types.Number), f.field("b", types.Float)],
+    # Everything will be converted to float to avoid NaN results with other types
+    overloads=[
+        f.relation("acot", [f.input_field("a", types.Float), f.field("b", types.Float)])
+    ],
+)
+
+exp = f.relation(
+    "exp",
+    [f.input_field("a", types.Number), f.field("b", types.Float)],
+    overloads=[
+        f.relation("exp", [f.input_field("a", types.Int64), f.field("b", types.Float)]),
+        f.relation("exp", [f.input_field("a", types.Int128), f.field("b", types.Float)]),
+        f.relation("exp", [f.input_field("a", types.Float), f.field("b", types.Float)]),
+        f.relation("exp", [f.input_field("a", types.GenericDecimal), f.field("b", types.Float)])
+    ],
+)
+
+erf = f.relation(
+    "erf",
+    [f.input_field("a", types.Number), f.field("b", types.Float)],
+    overloads=[
+        # Everything will be converted to float to avoid NaN results with other types
+        f.relation("erf", [f.input_field("a", types.Float), f.field("b", types.Float)]),
+    ],
+)
+
+erfinv = f.relation(
+    "erfinv",
+    [f.input_field("a", types.Number), f.field("b", types.Float)],
+    overloads=[
+        # Everything will be converted to float to avoid NaN results with other types
+        f.relation("erfinv", [f.input_field("a", types.Float), f.field("b", types.Float)]),
+    ],
+)
+
+
+# Strings
+concat = f.relation("concat", [f.input_field("a", types.String), f.input_field("b", types.String), f.field("c", types.String)])
+num_chars = f.relation("num_chars", [f.input_field("a", types.String), f.field("b", types.Int64)])
+starts_with = f.relation("starts_with", [f.input_field("a", types.String), f.input_field("b", types.String)])
+ends_with = f.relation("ends_with", [f.input_field("a", types.String), f.input_field("b", types.String)])
+contains = f.relation("contains", [f.input_field("a", types.String), f.input_field("b", types.String)])
+substring = f.relation("substring", [f.input_field("a", types.String), f.input_field("b", types.Int64), f.input_field("c", types.Int64), f.field("d", types.String)])
+like_match = f.relation("like_match", [f.input_field("a", types.String), f.field("b", types.String)])
+lower = f.relation("lower", [f.input_field("a", types.String), f.field("b", types.String)])
+upper = f.relation("upper", [f.input_field("a", types.String), f.field("b", types.String)])
+strip = f.relation("strip", [f.input_field("a", types.String), f.field("b", types.String)])
+levenshtein = f.relation("levenshtein", [f.input_field("a", types.String), f.input_field("b", types.String), f.field("c", types.Int64)])
+join = f.relation("join", [f.input_field("a", types.AnyList), f.input_field("b", types.String), f.field("c", types.String)])
+replace = f.relation("replace", [f.input_field("a", types.String), f.input_field("b", types.String), f.input_field("c", types.String), f.field("d", types.String)])
+split = f.relation("split", [f.input_field("a", types.String), f.input_field("b", types.String), f.field("c", types.Int64), f.field("d", types.String)])
+# should be a separate builtin. SQL emitter compiles it differently
+split_part = f.relation("split_part", [f.input_field("a", types.String), f.input_field("b", types.String), f.field("c", types.Int64), f.field("d", types.String)])
+
+# regex
+regex_match = f.relation("regex_match", [f.input_field("a", types.String), f.input_field("b", types.String)])
+regex_match_all = f.relation("regex_match_all", [f.input_field("a", types.String), f.input_field("b", types.String), f.input_field("c", types.Int64),  f.field("d", types.String)])
+capture_group_by_index = f.relation("capture_group_by_index", [f.input_field("a", types.String), f.input_field("b", types.String), f.input_field("c", types.Int64), f.input_field("d", types.Int64), f.field("e", types.String)])
+capture_group_by_name = f.relation("capture_group_by_name", [f.input_field("a", types.String), f.input_field("b", types.String), f.input_field("c", types.Int64), f.input_field("d", types.String), f.field("e", types.String)])
+escape_regex_metachars = f.relation("escape_regex_metachars", [f.input_field("a", types.String), f.field("b", types.String)])
+
+# Dates
+date_format = f.relation("date_format", [f.input_field("a", types.Date), f.input_field("b", types.String), f.field("c", types.String)])
+datetime_format = f.relation("datetime_format", [f.input_field("a", types.DateTime), f.input_field("b", types.String), f.input_field("c", types.String), f.field("d", types.String)])
+date_year = f.relation("date_year", [f.input_field("a", types.Date), f.field("b", types.Int64)])
+date_quarter = f.relation("date_quarter", [f.input_field("a", types.Date), f.field("b", types.Int64)])
+date_month = f.relation("date_month", [f.input_field("a", types.Date), f.field("b", types.Int64)])
+date_week = f.relation("date_week", [f.input_field("a", types.Date), f.field("b", types.Int64)])
+date_day = f.relation("date_day", [f.input_field("a", types.Date), f.field("b", types.Int64)])
+date_dayofyear = f.relation("date_dayofyear", [f.input_field("a", types.Date), f.field("b", types.Int64)])
+date_weekday = f.relation("date_weekday", [f.input_field("a", types.Date), f.field("b", types.Int64)])
+date_add = f.relation("date_add", [f.input_field("a", types.Date), f.input_field("b", types.Int64), f.field("c", types.Date)])
+dates_period_days = f.relation("dates_period_days", [f.input_field("a", types.Date), f.input_field("b", types.Date), f.field("c", types.Int64)])
+datetimes_period_milliseconds = f.relation("datetimes_period_milliseconds", [f.input_field("a", types.DateTime), f.input_field("b", types.DateTime), f.field("c", types.Int64)])
+date_subtract = f.relation("date_subtract", [f.input_field("a", types.Date), f.input_field("b", types.Int64), f.field("c", types.Date)])
+datetime_now = f.relation("datetime_now", [f.field("a", types.DateTime)])
+datetime_add = f.relation("datetime_add", [f.input_field("a", types.DateTime), f.input_field("b", types.Int64), f.field("c", types.DateTime)])
+datetime_subtract = f.relation("datetime_subtract", [f.input_field("a", types.DateTime), f.input_field("b", types.Int64), f.field("c", types.DateTime)])
+datetime_year = f.relation("datetime_year", [f.input_field("a", types.DateTime), f.input_field("b", types.String), f.field("c", types.Int64)])
+datetime_quarter = f.relation("datetime_quarter", [f.input_field("a", types.DateTime), f.input_field("b", types.String), f.field("c", types.Int64)])
+datetime_month = f.relation("datetime_month", [f.input_field("a", types.DateTime), f.input_field("b", types.String), f.field("c", types.Int64)])
+datetime_week = f.relation("datetime_week", [f.input_field("a", types.DateTime), f.input_field("b", types.String), f.field("c", types.Int64)])
+datetime_day = f.relation("datetime_day", [f.input_field("a", types.DateTime), f.input_field("b", types.String), f.field("c", types.Int64)])
+datetime_dayofyear = f.relation("datetime_dayofyear", [f.input_field("a", types.DateTime), f.input_field("b", types.String), f.field("c", types.Int64)])
+datetime_hour = f.relation("datetime_hour", [f.input_field("a", types.DateTime), f.input_field("b", types.String), f.field("c", types.Int64)])
+datetime_minute = f.relation("datetime_minute", [f.input_field("a", types.DateTime), f.input_field("b", types.String), f.field("c", types.Int64)])
+datetime_second = f.relation("datetime_second", [f.input_field("a", types.DateTime), f.field("c", types.Int64)])
+datetime_weekday = f.relation("datetime_weekday", [f.input_field("a", types.DateTime), f.input_field("b", types.String), f.field("c", types.Int64)])
+
+# Other
+range = f.relation(
+    "range",
+    [f.input_field("start", types.Number), f.input_field("stop", types.Number), f.input_field("step", types.Number), f.field("result", types.Number)],
+    overloads=[
+        f.relation("range", [f.input_field("start", types.Int64), f.input_field("stop", types.Int64), f.input_field("step", types.Int64), f.field("result", types.Int64)]),
+        f.relation("range", [f.input_field("start", types.Int128), f.input_field("stop", types.Int128), f.input_field("step", types.Int128), f.field("result", types.Int128)]),
+    ],
+)
+
+hash = f.relation("hash", [f.input_field("args", types.AnyList), f.field("hash", types.Hash)])
+
+uuid_to_string = f.relation("uuid_to_string", [f.input_field("a", types.Hash), f.field("b", types.String)])
+parse_uuid = f.relation("parse_uuid", [f.input_field("a", types.String), f.field("b", types.Hash)])
+
+# Raw source code to be attached to the transaction, when the backend understands this language
+raw_source = f.relation("raw_source", [f.input_field("lang", types.String), f.input_field("source", types.String)])
+
+unique = f.relation("unique", [f.input_field("args", types.AnyList)])
+exclusive = f.relation("exclusive", [f.input_field("args", types.AnyList)])
+anyof = f.relation("anyof", [f.input_field("args", types.AnyList)])
+
+#
+# Annotations
+#
+
+# indicates a relation is external to the system and, thus, backends should not rename or
+# otherwise modify it
+external = f.relation("external", [])
+external_annotation = f.annotation(external, [])
+
+# indicates an output is meant to be exported
+export = f.relation("export", [])
+export_annotation = f.annotation(export, [])
+
+# indicates this relation is a concept population
+concept_population = f.relation("concept_population", [])
+concept_relation_annotation = f.annotation(concept_population, [])
+
+# indicates this relation came in from CDC and will need to be shredded in Rel
+from_cdc = f.relation("from_cdc", [])
+from_cdc_annotation = f.annotation(from_cdc, [])
+
+# indicates an = lookup that is from a cast operation for value types
+from_cast = f.relation("from_cast", [])
+from_cast_annotation = f.annotation(from_cast, [])
+
+# indicates the original keys of an output (before they were replaced by a compound key)
+output_keys = f.relation("output_keys", [])
+output_keys_annotation = f.annotation(output_keys, [])
+
+# indicates this relation has a functional dependency
+function = f.relation("function", [f.input_field("code", types.Symbol)])
+function_checked_annotation = f.annotation(function, [f.lit("checked")])
+function_annotation = f.annotation(function, [])
+function_ranked = f.relation("function", [f.input_field("code", types.Symbol), f.input_field("rank", types.Int64)])
+def function_ranked_checked_annotation(k:int) -> ir.Annotation:
+    return f.annotation(function_ranked, [f.lit("checked"), f.lit(k)])
+def function_ranked_annotation(k:int) -> ir.Annotation:
+    return f.annotation(function_ranked, [f.lit(k)])
+
+# Indicates this relation should be tracked in telemetry. Supported for Relationships and Concepts.
+# `RAI_BackIR.with_relation_tracking` produces log messages at the start and end of each
+# SCC evaluation, if any declarations bear the `track` annotation.
+track = f.relation("track", [
+    # BackIR evaluation expects 2 parameters on the track annotation: the tracking
+    # library name and tracking relation name, which appear as log metadata fields.
+    f.input_field("library", types.Symbol),
+    f.input_field("relation", types.Symbol)
+])
+track_annotation = f.annotation(track, [])
+
+# Enables config used by raicode/src/Recursion. Supported for Relationships and queries.
+recursion_config = f.relation("recursion_config", [
+    f.input_field("config_key", types.Symbol),
+    f.input_field("config_value", types.Int64)
+])
+recursion_config_annotation = f.annotation(recursion_config, [])
+
+# All ir nodes marked by this annotation will be removed from the final metamodel before compilation.
+# Specifically it happens in `Flatten` pass when rewrites for `require` happen
+discharged = f.relation("discharged", [])
+discharged_annotation = f.annotation(discharged, [])
+
+# Require nodes with this annotation will be kept in the final metamodel to be emitted as
+# constraint declarations (LQP)
+declare_constraint = f.relation("declare_constraint", [])
+declare_constraint_annotation = f.annotation(declare_constraint, [])
+
+#
+# Aggregations
+#
+def aggregation(name: str, params: list[ir.Field], overload_types: Optional[list[tuple[ir.Type, ...]]] = None):
+    """Defines an aggregation, which is a Relation whose first 2 fields are a projection
+    and a group, followed by the params."""
+    fields = params
+    overloads = []
+    if overload_types:
+        param_sets = []
+        for ts in overload_types:
+            param_sets.append([ir.Field(param.name, t, param.input) for param, t in zip(params, ts)])
+        overloads = [
+            aggregation(name, typed_params, overload_types=None)
+            for typed_params in param_sets
+        ]
+    return f.relation(name, fields, overloads=overloads)
+
+# concat = aggregation("concat", [
+#     f.input_field("sep", types.String),
+#     f.input_field("over", types.StringSet),
+#     f.field("result", types.String)
+# ])
+# note that count does not need "over" because it counts the projection
+count = aggregation("count", [
+    f.field("result", types.Int128)
+])
+stats = aggregation("stats", [
+    f.input_field("over", types.Number),
+    f.field("std_dev", types.Number),
+    f.field("mean", types.Number),
+    f.field("median", types.Number),
+])
+sum = aggregation("sum", [
+    f.input_field("over", types.Number),
+    f.field("result", types.Number)
+], overload_types=[
+    (types.Int64, types.Int64),
+    (types.Int128, types.Int128),
+    (types.Float, types.Float),
+    (types.GenericDecimal, types.GenericDecimal),
+])
+avg = aggregation("avg", [
+    f.input_field("over", types.Number),
+    f.field("result", types.Number)
+], overload_types=[
+    (types.Int64, types.Float), # nb. Float because Int / Int is Float
+    (types.Int128, types.Float), # nb. Float because Int / Int is Float
+    (types.Float, types.Float),
+    (types.GenericDecimal, types.GenericDecimal),
+])
+max = aggregation("max", [
+    f.input_field("over", types.Any),
+    f.field("result", types.Any)
+], overload_types=[
+    (types.Int64, types.Int64),
+    (types.Int128, types.Int128),
+    (types.Float, types.Float),
+    (types.GenericDecimal, types.GenericDecimal),
+    (types.String, types.String),
+    (types.Date, types.Date),
+    (types.DateTime, types.DateTime),
+    (types.EntityTypeVar, types.EntityTypeVar),
+])
+min = aggregation("min", [
+    f.input_field("over", types.Any),
+    f.field("result", types.Any)
+], overload_types=[
+    (types.Int64, types.Int64),
+    (types.Int128, types.Int128),
+    (types.Float, types.Float),
+    (types.GenericDecimal, types.GenericDecimal),
+    (types.String, types.String),
+    (types.Date, types.Date),
+    (types.DateTime, types.DateTime),
+    (types.EntityTypeVar, types.EntityTypeVar),
+])
+
+
+#
+# Pragmas
+#
+rule_reasoner_sem_vo = f.relation("rule_reasoner_sem_vo", [f.input_field("args", types.AnyList)])
+rule_reasoner_phys_vo = f.relation("rule_reasoner_phys_vo", [f.input_field("args", types.AnyList)])
+
+
+# TODO: these are Rel specific, should be moved from here
+# Conversions
+string = f.relation("string", [f.input_field("a", types.Any), f.field("b", types.String)])
+parse_date = f.relation("parse_date", [f.input_field("a", types.String), f.input_field("b", types.String), f.field("c", types.Date)])
+parse_datetime = f.relation("parse_datetime", [f.input_field("a", types.String), f.input_field("b", types.String), f.field("c", types.DateTime)])
+parse_decimal = f.relation("parse_decimal", [f.input_field("a", types.String), f.field("b", types.GenericDecimal)])
+parse_int64 = f.relation("parse_int64", [f.input_field("a", types.String), f.field("b", types.Int64)])
+parse_int128 = f.relation("parse_int128", [f.input_field("a", types.String), f.field("b", types.Int128)])
+parse_float = f.relation("parse_float", [f.input_field("a", types.String), f.field("b", types.Float)])
+
+nanosecond = f.relation("nanosecond", [f.input_field("a", types.Int64), f.field("b", types.Int64)])
+microsecond = f.relation("microsecond", [f.input_field("a", types.Int64), f.field("b", types.Int64)])
+millisecond = f.relation("millisecond", [f.input_field("a", types.Int64), f.field("b", types.Int64)])
+second = f.relation("second", [f.input_field("a", types.Int64), f.field("b", types.Int64)])
+minute = f.relation("minute", [f.input_field("a", types.Int64), f.field("b", types.Int64)])
+hour = f.relation("hour", [f.input_field("a", types.Int64), f.field("b", types.Int64)])
+day = f.relation("day", [f.input_field("a", types.Int64), f.field("b", types.Int64)])
+week = f.relation("week", [f.input_field("a", types.Int64), f.field("b", types.Int64)])
+month = f.relation("month", [f.input_field("a", types.Int64), f.field("b", types.Int64)])
+year = f.relation("year", [f.input_field("a", types.Int64), f.field("b", types.Int64)])
+
+cast = f.relation(
+    "cast",
+    [
+        f.input_field("to_type", types.Any),
+        f.input_field("source",  types.Any),
+        f.field("target",        types.Any)
+    ],
+    annos=[from_cast_annotation]
+)
+
+# Date construction with less overhead
+construct_date = f.relation("construct_date", [f.input_field("year", types.Int64), f.input_field("month", types.Int64), f.input_field("day", types.Int64), f.field("date", types.Date)])
+construct_date_from_datetime = f.relation("construct_date_from_datetime", [f.input_field("datetime", types.DateTime), f.input_field("timezone", types.String), f.field("date", types.Date)])
+construct_datetime_ms_tz = f.relation("construct_datetime_ms_tz", [f.input_field("year", types.Int64), f.input_field("month", types.Int64), f.input_field("day", types.Int64), f.input_field("hour", types.Int64), f.input_field("minute", types.Int64), f.input_field("second", types.Int64), f.input_field("milliseconds", types.Int64), f.input_field("timezone", types.String), f.field("datetime", types.DateTime)])
+
+# Solver helpers
+rel_primitive_solverlib_fo_appl = f.relation("rel_primitive_solverlib_fo_appl", [
+    f.input_field("op", types.Int64),
+    f.input_field("args", types.AnyList),
+    f.field("result", types.String),
+])
+rel_primitive_solverlib_ho_appl = aggregation("rel_primitive_solverlib_ho_appl", [
+    f.input_field("over", types.Any),
+    f.field("op", types.Int64),
+    f.field("result", types.String),
+])
+implies = f.relation("implies", [f.input_field("a", types.Bool), f.input_field("b", types.Bool)])
+all_different = aggregation("all_different", [f.input_field("over", types.Any)])
+special_ordered_set_type_2 = aggregation("special_ordered_set_type_2", [f.input_field("rank", types.Any)])
+
+# graph primitive algorithm helpers
+infomap = aggregation("infomap", [
+    f.input_field("weights", types.AnyList),
+    f.input_field("node_count", types.Any),
+    f.input_field("edge_count", types.Any),
+    f.input_field("teleportation_rate", types.Float),
+    f.input_field("visit_rate_tolerance", types.Float),
+    f.input_field("level_tolerance", types.Float),
+    f.input_field("sweep_tolerance", types.Float),
+    f.input_field("max_levels", types.Int64),
+    f.input_field("max_sweeps", types.Int64),
+    f.input_field("randomization_seed", types.Int64),
+    f.field("termination_info", types.String),
+    f.field("node_index", types.Int64),
+    f.field("community", types.Int64)
+])
+
+louvain = aggregation("louvain", [
+    f.input_field("weights", types.AnyList),
+    f.input_field("node_count", types.Any),
+    f.input_field("edge_count", types.Any),
+    f.input_field("level_tolerance", types.Float),
+    f.input_field("sweep_tolerance", types.Float),
+    f.input_field("max_levels", types.Int64),
+    f.input_field("max_sweeps", types.Int64),
+    f.input_field("randomization_seed", types.Int64),
+    f.field("termination_info", types.String),
+    f.field("node_index", types.Int64),
+    f.field("community", types.Int64)
+])
+
+label_propagation = aggregation("label_propagation", [
+    f.input_field("weights", types.AnyList),
+    f.input_field("node_count", types.Any),
+    f.input_field("edge_count", types.Any),
+    f.input_field("max_sweeps", types.Int64),
+    f.input_field("randomization_seed", types.Int64),
+    f.field("termination_info", types.String),
+    f.field("node_index", types.Int64),
+    f.field("community", types.Int64)
+])
+
+#
+# Public access to built-in relations
+#
+
+def is_builtin(r: ir.Relation):
+    return r in builtin_relations or r in builtin_overloads
+
+def is_annotation(r: ir.Relation):
+    return r in builtin_annotations
+
+def is_pragma(r: ir.Relation):
+    return r in pragma_builtins
+
+def _compute_builtin_relations() -> list[ir.Relation]:
+    module = sys.modules[__name__]
+    relations = []
+    for name in dir(module):
+        builtin = getattr(module, name)
+        if isinstance(builtin, ir.Relation) and builtin not in builtin_annotations:
+            relations.append(builtin)
+    return relations
+
+def _compute_builtin_overloads() -> list[ir.Relation]:
+    module = sys.modules[__name__]
+    overloads = []
+    for name in dir(module):
+        builtin = getattr(module, name)
+        if isinstance(builtin, ir.Relation) and builtin not in builtin_annotations:
+            if builtin.overloads:
+                for overload in builtin.overloads:
+                    if overload not in builtin_annotations:
+                        overloads.append(overload)
+    return overloads
+
+# manually maintain the list of relations that are actually annotations
+builtin_annotations = [external, export, concept_population, from_cdc, from_cast, track, recursion_config]
+builtin_annotations_by_name = dict((r.name, r) for r in builtin_annotations)
+
+builtin_relations = _compute_builtin_relations()
+builtin_overloads = _compute_builtin_overloads()
+builtin_relations_by_name = dict((r.name, r) for r in builtin_relations)
+
+string_binary_builtins = [num_chars, starts_with, ends_with, contains, like_match, lower, upper, strip, regex_match]
+
+date_builtins = [date_year, date_quarter, date_month, date_week, date_day, date_dayofyear, date_add, date_subtract,
+                 dates_period_days, datetime_add, datetime_subtract, datetimes_period_milliseconds, datetime_year,
+                 datetime_quarter, datetime_month, datetime_week, datetime_day, datetime_dayofyear, datetime_hour,
+                 datetime_minute, datetime_second, date_weekday, datetime_weekday]
+
+date_periods = [year, month, week, day, hour, minute, second, millisecond, microsecond, nanosecond]
+
+math_unary_builtins = [abs, *abs.overloads, sqrt, *sqrt.overloads,
+                       natural_log, *natural_log.overloads, log10, *log10.overloads,
+                       cbrt, *cbrt.overloads, factorial, *factorial.overloads, cos, *cos.overloads,
+                       cosh, *cosh.overloads, acos, *acos.overloads, acosh, *acosh.overloads, sin, *sin.overloads,
+                       sinh, *sinh.overloads, asin, *asin.overloads, asinh, *asinh.overloads, tan, *tan.overloads,
+                       tanh, *tanh.overloads, atan, *atan.overloads, atanh, *atanh.overloads, *ceil.overloads,
+                       cot, *cot.overloads, acot, *acot.overloads, floor, *floor.overloads, exp, *exp.overloads,
+                       erf, *erf.overloads, erfinv, *erfinv.overloads]
+
+math_builtins = [*math_unary_builtins, maximum, *maximum.overloads, minimum, *minimum.overloads, mod, *mod.overloads,
+                 pow, *pow.overloads, power, *power.overloads, log, *log.overloads, trunc_div, *trunc_div.overloads]
+
+pragma_builtins = [rule_reasoner_sem_vo, rule_reasoner_phys_vo]