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

relationalai/{semantics/reasoners/graph → experimental}/paths/examples/basic_example.py

@@ -1,6 +1,6 @@
 from relationalai.semantics import Model, Integer, select, String, define
-from relationalai.semantics.reasoners.graph.paths.graph import Graph
-from relationalai.semantics.reasoners.graph.paths.api import path, star, match
+from relationalai.experimental.paths.graph import Graph
+from relationalai.experimental.paths.api import path, star, match
 
 # Create an automaton that matches paths with pattern: A(A*)B:
 pattern = path("A", star("A"), "B")

relationalai/{semantics/reasoners/graph → experimental}/paths/examples/paths_benchmark.py

@@ -4,8 +4,8 @@ Example usage of automaton-based pathfinding.
 
 import time
 from relationalai.semantics import Model, Integer, select, String, define
-from relationalai.semantics.reasoners.graph.paths.graph import Graph
-from relationalai.semantics.reasoners.graph.paths.api import node, path, match
+from relationalai.experimental.paths.graph import Graph
+from relationalai.experimental.paths.api import node, path, match
 
 import argparse
 

relationalai/{semantics/reasoners/graph → experimental}/paths/examples/paths_example.py

@@ -4,8 +4,8 @@ Example usage of automaton-based pathfinding.
 
 import time
 from relationalai.semantics import Model, Integer, select, String, define
-from relationalai.semantics.reasoners.graph.paths.graph import Graph
-from relationalai.semantics.reasoners.graph.paths.api import node, path, match
+from relationalai.experimental.paths.graph import Graph
+from relationalai.experimental.paths.api import node, path, match
 
 import argparse
 

relationalai/{semantics/reasoners/graph → experimental}/paths/examples/pattern_to_automaton.py

@@ -1,4 +1,4 @@
-from relationalai.semantics.reasoners.graph.paths.api import path, union
+from relationalai.experimental.paths.api import path, union
 from relationalai.semantics import Concept
 
 Node = Concept('Node')

relationalai/{semantics/reasoners/graph → experimental}/paths/path_algorithms/one_sided_ball_repetition.py

@@ -1,6 +1,6 @@
 # For builder components.
 from relationalai.semantics import Integer, define
-from relationalai.semantics.reasoners.graph.paths.graph import Graph
+from relationalai.experimental.paths.graph import Graph
 
 
 def ball_with_repetition(g:Graph, Source, max_length):

relationalai/{semantics/reasoners/graph → experimental}/paths/path_algorithms/single.py

@@ -1,8 +1,8 @@
 # For builder components.
 from relationalai.semantics import Integer, where, define, select, min
-from relationalai.semantics.reasoners.graph.paths.graph import Graph
-from relationalai.semantics.reasoners.graph.paths.path_algorithms.one_sided_ball_repetition import ball_with_repetition
-from relationalai.semantics.reasoners.graph.paths.path_algorithms.one_sided_ball_upto import ball_upto
+from relationalai.experimental.paths.graph import Graph
+from relationalai.experimental.paths.path_algorithms.one_sided_ball_repetition import ball_with_repetition
+from relationalai.experimental.paths.path_algorithms.one_sided_ball_upto import ball_upto
 
 # find a (deterministic) path from src to dst inside the given ball
 # where dst is at distance radius from src

relationalai/{semantics/reasoners/graph → experimental}/paths/path_algorithms/two_sided_balls_repetition.py

@@ -1,6 +1,6 @@
 # For builder components.
 from relationalai.semantics import Integer, define
-from relationalai.semantics.reasoners.graph.paths.graph import Graph
+from relationalai.experimental.paths.graph import Graph
 
 
 def two_balls_repetition(g:Graph, Source, Target, max_length):

relationalai/{semantics/reasoners/graph → experimental}/paths/path_algorithms/two_sided_balls_upto.py

@@ -1,7 +1,7 @@
 # For builder components.
 from relationalai.semantics import Integer, define, not_, count
-from relationalai.semantics.reasoners.graph.paths.graph import Graph
-from relationalai.semantics.reasoners.graph.paths.utilities.iterators import setup_iteration
+from relationalai.experimental.paths.graph import Graph
+from relationalai.experimental.paths.utilities.iterators import setup_iteration
 
 
 def two_balls_upto(g:Graph, Source, Target, max_length=None):

relationalai/{semantics/reasoners/graph → experimental}/paths/path_algorithms/usp-old.py

@@ -1,8 +1,8 @@
 # For builder components.
 from relationalai.semantics import Integer, define, max, sum, not_
-from relationalai.semantics.reasoners.graph.paths.graph import Graph
-from relationalai.semantics.reasoners.graph.paths.path_algorithms.one_sided_ball_upto import ball_upto
-from relationalai.semantics.reasoners.graph.paths.path_algorithms.one_sided_ball_repetition import ball_with_repetition
+from relationalai.experimental.paths.graph import Graph
+from relationalai.experimental.paths.path_algorithms.one_sided_ball_upto import ball_upto
+from relationalai.experimental.paths.path_algorithms.one_sided_ball_repetition import ball_with_repetition
 
 
 def compute_usp(g: Graph, Source, Target, max_length = None):

relationalai/{semantics/reasoners/graph → experimental}/paths/path_algorithms/usp-tuple.py

@@ -1,8 +1,8 @@
 # For builder components.
 from relationalai.semantics import Model, Integer, define, max, sum, select, not_
-from relationalai.semantics.reasoners.graph.paths.graph import Graph
-from relationalai.semantics.reasoners.graph.paths.path_algorithms.one_sided_ball_upto import ball_upto
-from relationalai.semantics.reasoners.graph.paths.path_algorithms.one_sided_ball_repetition import ball_with_repetition
+from relationalai.experimental.paths.graph import Graph
+from relationalai.experimental.paths.path_algorithms.one_sided_ball_upto import ball_upto
+from relationalai.experimental.paths.path_algorithms.one_sided_ball_repetition import ball_with_repetition
 
 
 def compute_usp(g: Graph, Source, Target, max_length = None):

relationalai/{semantics/reasoners/graph → experimental}/paths/path_algorithms/usp.py

@@ -1,8 +1,8 @@
 # For builder components.
 from relationalai.semantics import Integer, define, sum, not_
-from relationalai.semantics.reasoners.graph.paths.graph import Graph
-from relationalai.semantics.reasoners.graph.paths.path_algorithms.one_sided_ball_upto import ball_upto
-from relationalai.semantics.reasoners.graph.paths.path_algorithms.one_sided_ball_repetition import ball_with_repetition
+from relationalai.experimental.paths.graph import Graph
+from relationalai.experimental.paths.path_algorithms.one_sided_ball_upto import ball_upto
+from relationalai.experimental.paths.path_algorithms.one_sided_ball_repetition import ball_with_repetition
 
 
 def compute_usp(g: Graph, Source, Target, max_length=None):

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

@@ -1,6 +1,6 @@
 from relationalai.semantics import Model, Integer, define, select, count
-from relationalai.semantics.reasoners.graph.paths.graph import Graph
-from relationalai.semantics.reasoners.graph.paths.path_algorithms.find_paths import find_shortest_paths
+from relationalai.experimental.paths.graph import Graph
+from relationalai.experimental.paths.path_algorithms.find_paths import find_shortest_paths
 
 
 # First test with grid graph

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

@@ -1,6 +1,6 @@
 from relationalai.semantics import Model, Integer, define, select, count
-from relationalai.semantics.reasoners.graph.paths.graph import Graph
-from relationalai.semantics.reasoners.graph.paths.path_algorithms.find_paths import find_shortest_paths
+from relationalai.experimental.paths.graph import Graph
+from relationalai.experimental.paths.path_algorithms.find_paths import find_shortest_paths
 
 
 # First test with grid graph

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

@@ -1,6 +1,6 @@
 from relationalai.semantics import Model, Integer, define, select, count
-from relationalai.semantics.reasoners.graph.paths.graph import Graph
-from relationalai.semantics.reasoners.graph.paths.path_algorithms.find_paths import find_shortest_paths
+from relationalai.experimental.paths.graph import Graph
+from relationalai.experimental.paths.path_algorithms.find_paths import find_shortest_paths
 
 
 # First test with grid graph

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

@@ -1,6 +1,6 @@
 from relationalai.semantics import Model, Integer, define, select, count
-from relationalai.semantics.reasoners.graph.paths.graph import Graph
-from relationalai.semantics.reasoners.graph.paths.path_algorithms.find_paths import find_walks
+from relationalai.experimental.paths.graph import Graph
+from relationalai.experimental.paths.path_algorithms.find_paths import find_walks
 
 
 # First test with grid graph

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

@@ -1,6 +1,6 @@
 from relationalai.semantics import Model, Integer, define, select, count
-from relationalai.semantics.reasoners.graph.paths.graph import Graph
-from relationalai.semantics.reasoners.graph.paths.path_algorithms.find_paths import find_walks
+from relationalai.experimental.paths.graph import Graph
+from relationalai.experimental.paths.path_algorithms.find_paths import find_walks
 
 
 # First test with grid graph

relationalai/{semantics/reasoners/graph → experimental}/paths/tests/tests_one_sided_ball_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.one_sided_ball_repetition import ball_with_repetition
+from relationalai.experimental.paths.graph import Graph
+from relationalai.experimental.paths.path_algorithms.one_sided_ball_repetition import ball_with_repetition
 
 
 # Test with grid graph

relationalai/{semantics/reasoners/graph → experimental}/paths/tests/tests_one_sided_ball_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.one_sided_ball_repetition import ball_with_repetition
+from relationalai.experimental.paths.graph import Graph
+from relationalai.experimental.paths.path_algorithms.one_sided_ball_repetition import ball_with_repetition
 
 
 # Test with grid graph

relationalai/{semantics/reasoners/graph → experimental}/paths/tests/tests_one_sided_ball_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.one_sided_ball_upto import ball_upto
+from relationalai.experimental.paths.graph import Graph
+from relationalai.experimental.paths.path_algorithms.one_sided_ball_upto import ball_upto
 
 
 # First test with grid graph and multiple source and target nodes

relationalai/{semantics/reasoners/graph → experimental}/paths/tests/tests_one_sided_ball_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.one_sided_ball_upto import ball_upto
+from relationalai.experimental.paths.graph import Graph
+from relationalai.experimental.paths.path_algorithms.one_sided_ball_upto import ball_upto
 
 
 # First test with grid graph

relationalai/{semantics/reasoners/graph → experimental}/paths/tests/tests_single_paths.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.single import single_shortest_path
+from relationalai.experimental.paths.graph import Graph
+from relationalai.experimental.paths.path_algorithms.single import single_shortest_path
 
 
 model = Model("test_single_paths", dry_run=False)

relationalai/{semantics/reasoners/graph → experimental}/paths/tests/tests_single_walks.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.single import single_walk
+from relationalai.experimental.paths.graph import Graph
+from relationalai.experimental.paths.path_algorithms.single import single_walk
 
 
 model = Model("test_single_paths", dry_run=False)

relationalai/{semantics/reasoners/graph → experimental}/paths/tests/tests_single_walks_undirected.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.single import single_walk
+from relationalai.experimental.paths.graph import Graph
+from relationalai.experimental.paths.path_algorithms.single import single_walk
 
 
 model = Model("test_single_paths", dry_run=False)

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/internal/snowflake.py

@@ -264,12 +264,11 @@ class Table():
         else:
             me = self._rel._field_refs[0]
             b.where(self).define(concept(me))
-        # if there are no keys all the fields must be properties
-        rel_func = b.Relationship if keys else b.Property
+        # All the fields are treated as properties
         for field in self._rel._fields[1:]:
             field_name = sanitize_identifier(field.name.lower())
             if field_name not in key_dict:
-                r = rel_func(
+                r = b.Property(
                     f"{{{concept}}} has {{{field_name}:{field.type_str}}}",
                     parent=concept,
                     short_name=field_name,

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/executor.py

@@ -56,7 +56,15 @@ class LQPExecutor(e.Executor):
                 resource_class = rai.clients.snowflake.Resources
                 if self.config.get("use_direct_access", USE_DIRECT_ACCESS):
                     resource_class = rai.clients.snowflake.DirectAccessResources
-                self._resources = resource_class(dry_run=self.dry_run, config=self.config, generation=rai.Generation.QB, connection=self.connection)
+                # NOTE: language="lqp" is not strictly required for LQP execution, but it
+                # will significantly improve performance.
+                self._resources = resource_class(
+                    dry_run=self.dry_run,
+                    config=self.config,
+                    generation=rai.Generation.QB,
+                    connection=self.connection,
+                    language="lqp",
+                )
                 if not self.dry_run:
                     self.engine = self._resources.get_default_engine_name()
                     if not self.keep_model:
@@ -88,13 +96,12 @@ class LQPExecutor(e.Executor):
         assert self.engine is not None
 
         with debugging.span("poll_use_index", sources=sources, model=model, engine=engine_name):
-            resources.poll_use_index(
+            resources.maybe_poll_use_index(
                 app_name=app_name,
                 sources=sources,
                 model=model,
                 engine_name=self.engine,
                 engine_size=engine_size,
-                language="lqp",
                 program_span_id=program_span_id,
             )
 
@@ -280,6 +287,8 @@ class LQPExecutor(e.Executor):
         """Construct an epoch that defines a number of built-in definitions used by the
         emitter."""
         with debugging.span("compile_intrinsics") as span:
+            span["compile_type"] = "intrinsics"
+
             debug_info = lqp_ir.DebugInfo(id_to_orig_name={}, meta=None)
             intrinsics_fragment = lqp_ir.Fragment(
                 id = lqp_ir.FragmentId(id=b"__pyrel_lqp_intrinsics", meta=None),
@@ -290,7 +299,7 @@ class LQPExecutor(e.Executor):
                 meta = None,
             )
 
-            span["compile_type"] = "intrinsics"
+
             span["lqp"] = lqp_print.to_string(intrinsics_fragment, {"print_names": True, "print_debug": False, "print_csv_filename": False})
 
             return lqp_ir.Epoch(
@@ -327,13 +336,14 @@ class LQPExecutor(e.Executor):
         model_txn = None
         if self._last_model != model:
             with debugging.span("compile", metamodel=model) as install_span:
+                install_span["compile_type"] = "model"
                 _, model_txn = self.compiler.compile(model, {"fragment_id": b"model"})
                 model_txn = txn_with_configure(model_txn, configure)
-                install_span["compile_type"] = "model"
                 install_span["lqp"] = lqp_print.to_string(model_txn, {"print_names": True, "print_debug": False, "print_csv_filename": False})
                 self._last_model = model
 
         with debugging.span("compile", metamodel=task) as compile_span:
+            compile_span["compile_type"] = "query"
             query = f.compute_model(f.logical([task]))
             options = {
                 "wide_outputs": self.wide_outputs,
@@ -342,7 +352,6 @@ class LQPExecutor(e.Executor):
             result, final_model = self.compiler.compile_inner(query, options)
             export_info, query_txn = result
             query_txn = txn_with_configure(query_txn, configure)
-            compile_span["compile_type"] = "query"
             compile_span["lqp"] = lqp_print.to_string(query_txn, {"print_names": True, "print_debug": False, "print_csv_filename": False})
 
         # Merge the epochs into a single transactions. Long term the query bits should all
@@ -356,14 +365,10 @@ class LQPExecutor(e.Executor):
             epochs.append(model_txn.epochs[0])
 
         query_txn_epoch = query_txn.epochs[0]
-
         epochs.append(query_txn_epoch)
-
         epochs.append(self._compile_undefine_query(query_txn_epoch))
 
         txn = lqp_ir.Transaction(epochs=epochs, configure=configure, meta=None)
-
-        # Revalidate now that we've joined all the epochs.
         validate_lqp(txn)
 
         txn_proto = convert_transaction(txn)

relationalai/semantics/lqp/model2lqp.py

@@ -62,7 +62,6 @@ def to_lqp(model: ir.Model, fragment_name: bytes, ctx: TranslationCtx) -> tuple[
         meta=None,
     )
 
-    lqp.validate_lqp(txn)
     return (export_info, txn)
 
 def _effect_bindings(effect: Union[ir.Output, ir.Update]) -> list[ir.Value]:
@@ -254,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)
@@ -274,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]
 
@@ -341,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)
@@ -462,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),
@@ -543,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 = []
@@ -668,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 = {