relationalai 0.12.4__py3-none-any.whl → 0.12.6__py3-none-any.whl

relationalai/{semantics/reasoners/graph → experimental}/paths/tests/tests_two_sided_balls_repetition_multiple.py

@@ -1,6 +1,6 @@
 from relationalai.semantics import Model, Integer, define, select
-from relationalai.semantics.reasoners.graph.paths.graph import Graph
-from relationalai.semantics.reasoners.graph.paths.path_algorithms.two_sided_balls_repetition import two_balls_repetition
+from relationalai.experimental.paths.graph import Graph
+from relationalai.experimental.paths.path_algorithms.two_sided_balls_repetition import two_balls_repetition
 
 
 # Test with diamond graph

relationalai/{semantics/reasoners/graph → experimental}/paths/tests/tests_two_sided_balls_repetition_single.py

@@ -1,6 +1,6 @@
 from relationalai.semantics import Model, Integer, define, select
-from relationalai.semantics.reasoners.graph.paths.graph import Graph
-from relationalai.semantics.reasoners.graph.paths.path_algorithms.two_sided_balls_repetition import two_balls_repetition
+from relationalai.experimental.paths.graph import Graph
+from relationalai.experimental.paths.path_algorithms.two_sided_balls_repetition import two_balls_repetition
 
 
 # Test with diamond graph

relationalai/{semantics/reasoners/graph → experimental}/paths/tests/tests_two_sided_balls_upto_multiple.py

@@ -1,6 +1,6 @@
 from relationalai.semantics import Model, Integer, define, select
-from relationalai.semantics.reasoners.graph.paths.graph import Graph
-from relationalai.semantics.reasoners.graph.paths.path_algorithms.two_sided_balls_upto import two_balls_upto
+from relationalai.experimental.paths.graph import Graph
+from relationalai.experimental.paths.path_algorithms.two_sided_balls_upto import two_balls_upto
 
 
 # Test with grid graph

relationalai/{semantics/reasoners/graph → experimental}/paths/tests/tests_two_sided_balls_upto_single.py

@@ -1,6 +1,6 @@
 from relationalai.semantics import Model, Integer, define, select
-from relationalai.semantics.reasoners.graph.paths.graph import Graph
-from relationalai.semantics.reasoners.graph.paths.path_algorithms.two_sided_balls_upto import two_balls_upto
+from relationalai.experimental.paths.graph import Graph
+from relationalai.experimental.paths.path_algorithms.two_sided_balls_upto import two_balls_upto
 
 
 # Test with grid graph

relationalai/{semantics/reasoners/graph → experimental}/paths/tests/tests_usp_nsp_multiple.py

@@ -1,6 +1,6 @@
 from relationalai.semantics import Model, Integer, define, select
-from relationalai.semantics.reasoners.graph.paths.graph import Graph
-from relationalai.semantics.reasoners.graph.paths.path_algorithms.usp import compute_usp, compute_nsp
+from relationalai.experimental.paths.graph import Graph
+from relationalai.experimental.paths.path_algorithms.usp import compute_usp, compute_nsp
 
 
 # First test for usp with grid graph

relationalai/{semantics/reasoners/graph → experimental}/paths/tests/tests_usp_nsp_single.py

@@ -1,6 +1,6 @@
 from relationalai.semantics import Model, Integer, define, select
-from relationalai.semantics.reasoners.graph.paths.graph import Graph
-from relationalai.semantics.reasoners.graph.paths.path_algorithms.usp import compute_usp, compute_nsp
+from relationalai.experimental.paths.graph import Graph
+from relationalai.experimental.paths.path_algorithms.usp import compute_usp, compute_nsp
 
 
 # First test for usp with grid graph

relationalai/semantics/__init__.py

@@ -1,3 +1,7 @@
+"""
+The RelationalAI Semantics Module.
+"""
+
 # Mark this package's docstrings for inclusion
 # in automatically generated web documentation.
 __include_in_docs__ = True

relationalai/semantics/internal/annotations.py

@@ -6,3 +6,4 @@ concept_population = Relationship.builtins["concept_population"]
 function = Relationship.builtins["function"]
 from_cdc = Relationship.builtins["from_cdc"]
 track = Relationship.builtins["track"]
+recursion_config = Relationship.builtins["recursion_config"]

relationalai/semantics/internal/internal.py

@@ -3419,6 +3419,8 @@ class Compiler():
             return out
 
         elif isinstance(item, TypeRef):
+            if isinstance(item._thing, Relationship):
+                return self.to_relation(item._thing)
             concept = to_type(item)
             if not concept:
                 raise ValueError(f"Cannot find concept for {item}, {type(item)}")

relationalai/semantics/lqp/builtins.py

@@ -12,4 +12,5 @@ annotations_to_emit = FrozenOrderedSet([
     adhoc.name,
     builtins.function.name,
     builtins.track.name,
+    builtins.recursion_config.name,
 ])

relationalai/semantics/lqp/model2lqp.py

@@ -253,7 +253,7 @@ def _translate_rank(ctx: TranslationCtx, rank: ir.Rank, body: lqp.Formula) -> lq
     # to convert it to Int128.
     result_var, _ = _translate_term(ctx, rank.result)
     # The primitive will return an Int64 result, so we need a var to hold the intermediary.
-    result_64_var = gen_unique_var(ctx, "result_64")
+    result_64_var = gen_unique_var(ctx, "rank_result_64")
     result_64_type = mk_type(lqp.TypeName.INT)
 
     cast = lqp.Cast(input=result_64_var, result=result_var, meta=None)
@@ -273,7 +273,7 @@ def _translate_descending_rank(ctx: TranslationCtx, limit: int, result: lqp.Var,
     result_type = mk_type(lqp.TypeName.INT)
 
     # Rename abstracted args in the body to new variable names
-    var_map = {var.name: gen_unique_var(ctx, var.name) for (var, _) in abstr_args}
+    var_map = {var.name: gen_unique_var(ctx, 't_' + var.name) for (var, _) in abstr_args}
     body = utils.rename_vars_formula(body, var_map)
     new_abstr_args = [(var_map[var.name], typ) for (var, typ) in abstr_args]
 
@@ -340,7 +340,7 @@ def _translate_ascending_rank(ctx: TranslationCtx, limit: int, result_var: lqp.V
     terms = [result_var] + [v[0] for v in abstr_args]
 
     # Rename abstracted args in the body to new variable names
-    var_map = {var.name: gen_unique_var(ctx, var.name) for (var, _) in abstr_args}
+    var_map = {var.name: gen_unique_var(ctx, 't_' + var.name) for (var, _) in abstr_args}
     body = utils.rename_vars_formula(body, var_map)
     new_abstr_args = [(var_map[var.name], typ) for (var, typ) in abstr_args]
     sort_abstr = mk_abstraction(new_abstr_args, body)
@@ -461,6 +461,7 @@ def _translate_aggregate(ctx: TranslationCtx, aggr: ir.Aggregate, body: lqp.Form
     # `input_args`` hold the types of the input arguments, but they may have been modified
     # if we're dealing with a count, so we use `abstr_args` to find the type.
     (aggr_arg, aggr_arg_type) = abstr_args[-1]
+
     # Group-bys do not need to be handled at all, since they are introduced outside already
     reduce = lqp.Reduce(
         op=lqp_operator(ctx.var_names, aggr.aggregation.name, aggr_arg.name, aggr_arg_type),
@@ -542,6 +543,12 @@ def _translate_to_atom(ctx: TranslationCtx, task: ir.Lookup) -> lqp.Formula:
 
     if task.relation == builtins.join:
         return _translate_join(ctx, task)
+    elif task.relation == builtins.infomap:
+        return _translate_infomap(ctx, task)
+    elif task.relation == builtins.louvain:
+        return _translate_louvain(ctx, task)
+    elif task.relation == builtins.label_propagation:
+        return _translate_label_propagation(ctx, task)
 
     terms = []
     term_types = []
@@ -667,6 +674,92 @@ def _extract_pyrel_error_ids(ctx: TranslationCtx, model: ir.Model) -> list[Tuple
 
     return pyrel_error_attrs
 
+# Translate a relation reference into an abstraction over its fields.
+def _translate_relation_ref(ctx: TranslationCtx, relation: ir.Relation) -> lqp.Abstraction:
+    projection = []
+    for field in relation.fields:
+        var = gen_unique_var(ctx, field.name)
+        typ = meta_type_to_lqp(field.type)
+        projection.append((var, typ))
+
+    rid = get_relation_id(ctx, relation, projection)
+    atom = lqp.Atom(name=rid, terms=[var for (var, _) in projection], meta=None)
+    return mk_abstraction(projection, atom)
+
+# Common translation logic for graph algorithms.
+# task.args[0] : normalized weight list (int64, int64, float)
+# task.args[1] : normalized node count (relation or constant int64)
+# task.args[2] : normalized edge count (relation or constant int64)
+# task.args[3:-3] : algorithm parameters (var or constant)
+# task.args[-3] : diagnostic info
+# task.args[-2] : node index
+# task.args[-1] : community ident
+def _translate_graph_common(name: str, ctx: TranslationCtx, task: ir.Lookup):
+    abstractions = []
+
+    assert isinstance(task.args[0], ir.Relation), \
+        f"Expected relation as first arg to {name}, got {task.args[0]}:{type(task.args[0])}"
+    abstractions.append(_translate_relation_ref(ctx, task.args[0]))
+
+    # Allow constant args for node and edge count
+    for arg in task.args[1:3]:
+        if isinstance(arg, ir.Relation):
+            abst = _translate_relation_ref(ctx, arg)
+            typ = abst.vars[0][1]
+            assert typ.type_name == lqp.TypeName.INT, \
+                f"Expected Int64 types for node and edge counts, got type {typ.type_name}"
+            abstractions.append(abst)
+        else:
+            var, typ, eq = binding_to_lqp_var(ctx, arg)
+            assert eq is not None, \
+                f"Expected equality formula for {name} arg {arg}:{type(arg)}"
+            abstractions.append(mk_abstraction([(var, typ)], mk_and([eq])))
+
+    for arg in task.args[3:-3]:
+        var, typ, eq = binding_to_lqp_var(ctx, arg)
+        if eq:
+            abstractions.append(mk_abstraction([(var, typ)], mk_and([eq])))
+        else:
+            print(f"Primitive graph algorithm arg without eq:\n var:{var}, typ:{typ}\n arg:{arg}:{type(arg)}")
+            abstractions.append(mk_abstraction([(var, typ)], mk_and([])))
+
+    terms = []
+    for arg in task.args[-3:]:
+        term, _ = _translate_relterm(ctx, arg)
+        terms.append(term)
+
+    return (abstractions, terms)
+
+def _translate_infomap(ctx: TranslationCtx, task: ir.Lookup) -> lqp.Formula:
+    abstractions, terms = _translate_graph_common("infomap", ctx, task)
+
+    return lqp.FFI(
+        meta=None,
+        name="rel_primitive_infomap",
+        args=abstractions,
+        terms=terms,
+    )
+
+def _translate_louvain(ctx: TranslationCtx, task: ir.Lookup) -> lqp.Formula:
+    abstractions, terms = _translate_graph_common("louvain", ctx, task)
+
+    return lqp.FFI(
+        meta=None,
+        name="rel_primitive_louvain",
+        args=abstractions,
+        terms=terms,
+    )
+
+def _translate_label_propagation(ctx: TranslationCtx, task: ir.Lookup) -> lqp.Formula:
+    abstractions, terms = _translate_graph_common("label_propagation", ctx, task)
+
+    return lqp.FFI(
+        meta=None,
+        name="rel_primitive_async_label_propagation",
+        args=abstractions,
+        terms=terms,
+    )
+
 # Hard-coded implementation of Rel's string_join
 def _translate_join(ctx: TranslationCtx, task: ir.Lookup) -> lqp.Formula:
     assert len(task.args) == 3

relationalai/semantics/lqp/primitives.py

@@ -96,6 +96,9 @@ rel_to_lqp = {
     "split": "rel_primitive_string_split",
     "split_part": "rel_primitive_string_split",
     "regex_match": "rel_primitive_regex_match",
+    "infomap": "rel_primitive_infomap",
+    "louvain": "rel_primitive_louvain",
+    "label_propagation": "rel_primitive_async_label_propagation",
 }
 
 primitive_type_reorderings = {

relationalai/semantics/metamodel/builtins.py

@@ -507,6 +507,13 @@ track = f.relation("track", [
 ])
 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", [])
@@ -648,6 +655,48 @@ rel_primitive_solverlib_ho_appl = aggregation("rel_primitive_solverlib_ho_appl",
 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)])
 
+# 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
 #
@@ -683,7 +732,7 @@ def _compute_builtin_overloads() -> list[ir.Relation]:
     return overloads
 
 # manually maintain the list of relations that are actually annotations
-builtin_annotations = [external, export, concept_population, from_cdc, from_cast, track]
+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()

relationalai/semantics/metamodel/typer/typer.py

@@ -137,6 +137,9 @@ def to_type(value: ir.Value|ir.Field) -> ir.Type:
     if isinstance(value, tuple):
         return types.AnyList
 
+    if isinstance(value, ir.Relation):
+        return types.AnyList
+
     raise TypeError(f"Cannot determine IR type for value: {value} of type {type(value).__name__}")
 
 def type_matches(actual:ir.Type, expected:ir.Type, allow_expected_parents=False) -> bool:

relationalai/semantics/reasoners/__init__.py

@@ -1,3 +1,7 @@
+"""
+The RelationalAI Semantics Reasoners Module.
+"""
+
 # Mark this package's docstrings for inclusion
 # in automatically generated web documentation,
 # by default as early access.

relationalai/semantics/reasoners/experimental/__init__.py

@@ -0,0 +1,7 @@
+"""
+Experimental reasoners and algorithms.
+
+This namespace contains experimental features that may change in future versions.
+"""
+
+__all__ = []