relationalai 0.13.5__py3-none-any.whl → 1.0.0a1__py3-none-any.whl

v0/relationalai/experimental/paths/examples/paths_example.py

@@ -0,0 +1,116 @@
+"""
+Example usage of automaton-based pathfinding.
+"""
+
+import time
+from v0.relationalai.semantics import Model, Integer, select, String, define
+from v0.relationalai.experimental.paths.graph import Graph
+from v0.relationalai.experimental.paths.api import node, path, match
+
+import argparse
+
+
+# def print_paths(path_node, path_label):
+#     # Print nodes and labels in a readable format
+#     l2 = String.ref()
+#     k = Integer.ref()
+#     m = Integer.ref()
+#     print("\nNodes and labels in the path on the original graph:")
+#     select(k, m, l2).where(
+#         path_node(k, m),
+#         path_label(k, label := String.ref()),
+#         l2 == strings.concat("-[", label, "]->")
+#     ).inspect()
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Pathfinder example script.")
+    parser.add_argument("--num_paths", type=int, default=None, help="Number of paths to find.")
+    args = parser.parse_args()
+
+    print("Number of paths to find:", args.num_paths)
+
+    # Create an automaton that matches paths with pattern: A(A*)B:
+    # pattern = path("-[A]->", star("-[A]->"), "-[B]->")
+    # edge_list = [(1, 2, "A"), (2, 3, "A"), (3, 4, "A"), (4, 5, "B"), (1, 5, "A")]
+
+    # 2 paths matching AB:
+    # pattern = path("-[A]->", "-[B]->")
+    # edge_list = [(1, 2, "A"), (2, 3, "B"), (1, 4, "A"), (4, 3, "B")]
+
+    
+
+    # pattern = path("-[A]->")
+    # edge_list = [(1, 3, "A"), (2, 3, "A")]
+
+    pattern = path("A")
+    # edge_list = [(1, 3, "A"), (2, 3, "A"), (1, 4, "A"), (2, 4, "A")]
+    edge_list = [(1, 2, "A")]
+
+
+    sources = []
+    targets = []
+
+    sources = [1]
+    targets = [2]
+
+    # pattern = path("-[A]->")
+    # edge_list = [(1, 3, "A"), (2, 3, "A"), (1, 4, "A"), (2, 4, "A")]
+
+    # sources = [1, 2]
+    # targets = [3, 4]
+    # 2 paths from 2 different source nodes:
+    # pattern = path("-[A]->")
+    # edge_list = [(1, 3, "A"), (2, 3, "A")]
+
+    # pattern = path("-[A]->")
+    # edge_list = [(1, 3, "A"), (2, 3, "A"), (1, 4, "A"), (2, 4, "A")]
+
+    timestamp = str(time.gmtime(0))
+
+    print("\nEdge list:\n", edge_list)
+
+    # Initialize the RelationalAI model
+    model = Model(f"paths_{timestamp}", use_lqp=True) # , use_lqp=True)  # strict=True  # dry_run=False  # use_direct_access=True
+    # use_lqp=True  # strict=True  # dry_run=False  # use_direct_access=True
+
+    # model.define(
+    #     RawSource("rel", "@span_no_threshold")
+    # )
+
+    graph = Graph.from_edge_list(model, edge_list)
+    Node = graph.Node
+
+    # Call the function to find the path
+
+    Source = model.Relationship(f"source6 {{{Node}}}")
+    Target = model.Relationship(f"target6 {{{Node}}}")
+
+    for src in sources:
+        define(Source(Node.new(id=src)))
+
+    for tgt in targets:
+        define(Target(Node.new(id=tgt)))
+
+    src, tgt = Node.ref(), Node.ref()
+
+    # select(graph.Node).inspect()
+
+    graph.Edge.inspect()
+    select(src).where(Source(src)).inspect()
+    select(tgt).where(Target(tgt)).inspect()
+
+    # print(f"\nFinding paths matching the automaton pattern from {src} to {dst}..."
+    # projected_paths = match(graph, pattern, Source, Target, num_paths=args.num_paths)
+
+    start = time.time()
+    projected_paths = match(graph, pattern, Source, Target)
+
+    i, k = Integer.ref(), Integer.ref()
+    node = graph.Node.ref()
+    label = String.ref()
+
+    result = select(i, k, label, node.id).where(projected_paths(i, k, label, node)).inspect()
+    end = time.time()
+
+    print(f"Time taken to find paths: {end - start} seconds")

v0/relationalai/experimental/paths/examples/pattern_to_automaton.py

@@ -0,0 +1,28 @@
+from v0.relationalai.experimental.paths.api import path, union
+from v0.relationalai.semantics import Concept
+
+Node = Concept('Node')
+OddNode = Concept('OddNode')
+EvenNode = Concept('EvenNode')
+
+# pattern = path(node(Node, lambda n: n.id > 3), star('-[A]->', '-[B]->'), Node)
+
+# pattern = path(node(Node, lambda n: n.id > 3), Node)
+
+# pattern = path(Node, '-[A]->', Node, '-[B]->', Node)
+
+# pattern = path('-[B]->', node(Node, lambda n: n.id > 3), '-[A]->')
+
+# pattern = path(OddNode, star('-[A]->', '-[B]->'), EvenNode)
+
+# pattern = path(OddNode, star('-[A]->', node(OddNode, lambda n: n.id > 3)), EvenNode)
+
+pattern = path(union("-[A]->", "-[B]->"), union("-[A]->", "-[B]->"))
+
+g = pattern.glushkov()
+a = g.automaton()
+a.reduce()
+
+print(a)
+
+

v0/relationalai/experimental/paths/find_paths_via_automaton.py

@@ -0,0 +1,85 @@
+"""
+Main functionality for finding paths through automaton.
+"""
+
+from v0.relationalai.semantics import define, where, Integer
+
+from .product_graph import create_product_graph #, find_path_in_product_graph
+# from .product_graph import project_product_graph_path_to_original_graph
+
+from .path_algorithms.find_paths import find_shortest_paths, find_walks
+
+def find_paths_via_automaton(graph, automaton, Source, Target,
+                             num_paths = None, max_length = 1000,
+                             type = "shortest"):
+    """
+    Find a path in the graph allowed by the automaton from Source nodes to Target nodes.
+
+    Args:
+        graph: The user's input graph
+        automaton: Automaton object representing the pattern to match
+        Source: Source node entities
+        Target: Target node entities
+        num_paths: Optional
+          - if specified, limit the number of paths returned
+          - if None, all paths are returned.
+
+    Returns:
+        product_graph: The product graph
+        paths: Relationship of arity 4 encoding paths in the original graph
+    """
+    model = graph.model
+    Node = graph.Node
+
+    # Create product graph:
+    product_graph = create_product_graph(graph, automaton)
+    ProductGraphNode = product_graph.Node
+
+    # automaton states:
+    init_state = 0  # assumes single initial state labeled 0 of the automaton
+
+    FinalState = model.Relationship("final_state1 {Integer}")
+    for state in automaton.get_final_states():
+        define(FinalState(state))
+
+    # FinalState.inspect()
+
+    # Product graph source and target sets:
+    ProductGraphSource = model.Relationship(f"pg_source {{{ProductGraphNode}}}")
+    ProductGraphTarget = model.Relationship(f"pg_target {{{ProductGraphNode}}}")
+
+    st = Integer.ref() # state in the automaton
+    src, tgt = Node.ref(), Node.ref()
+
+    where(Source(src)).define(
+        product_graph_src := ProductGraphNode.new(
+            state=init_state, orig_node=src
+        ),
+        ProductGraphSource(product_graph_src)
+    )
+
+    where(Target(tgt), FinalState(st)).define(
+        product_graph_dst := ProductGraphNode.new(
+            state=st, orig_node=tgt
+        ),
+        ProductGraphTarget(product_graph_dst)
+    )
+
+    # ProductGraphSource.inspect()
+    # ProductGraphTarget.inspect()
+
+    if type == "shortest":
+        # Find shortest paths in the product graph:
+        find_paths_function = find_shortest_paths
+
+    elif type == "walks":
+        find_paths_function = find_walks
+    else:
+        raise ValueError(f"Unknown type of path search: {type}")
+
+    paths = find_paths_function(
+        product_graph, ProductGraphSource, ProductGraphTarget,
+        num_paths=num_paths, max_length=max_length
+    )
+
+    return product_graph, paths

v0/relationalai/experimental/paths/graph.py

@@ -0,0 +1,185 @@
+from v0.relationalai.semantics import Integer, define, Concept, Relationship, std
+
+
+class Graph:
+    def __init__(self, model, Node:Concept, Edge:Relationship):
+        """
+        Initialize a Graph instance with Node and Edge concepts.
+        """
+        self.Node = Node
+        self.Edge = Edge
+        self.model = model
+
+
+    @classmethod
+    def from_edge_list(cls, model, edge_list):
+        """
+        Create a Graph instance from a Model.
+        The Model should have Node and Edge concepts defined.
+        """
+
+        Node = model.Concept("Node")
+
+        if len(edge_list[0]) == 2:
+            Edge = model.Relationship(f"edge4 {{{Node}}} {{{Node}}}")
+
+            for src, dst, in edge_list:
+                u = Node.new(id=src)
+                v = Node.new(id=dst)
+
+                define(u)
+                define(v)
+                define(Edge(u, v))
+        else:
+            Edge = model.Relationship(f"edge5 {{{Node}}} {{{Node}}} {{String}}")
+
+            for src, dst, label in edge_list:
+                u = Node.new(id=src)
+                v = Node.new(id=dst)
+
+                define(u)
+                define(v)
+                define(Edge(u, v, label))
+
+        return cls(model, Node, Edge)
+
+
+    @classmethod
+    def construct_grid(cls, model, side, tp = 'directed'):
+        """
+        Create a grid Graph instance from a Model. The length of the side of the grid
+        is given by the parameter `side`.
+        The Model should have Node and Edge concepts defined.
+        """
+        Node = model.Concept("Node")
+        Edge = model.Relationship(f"edge6 {{{Node}}} {{{Node}}}")
+
+        n, m = Integer.ref(), Integer.ref()
+        u, v = Node.ref(), Node.ref()
+
+        define(Node.new(row = n, col = m)).where(
+            n == std.range(1, side + 1, 1),
+            m == std.range(1, side + 1, 1)
+        )
+
+        define(Edge(u, v)).where(
+            Node(u),
+            Node(v),
+            u.row == v.row,
+            v.col == u.col + 1
+        )
+
+        define(Edge(u, v)).where(
+            Node(u),
+            Node(v),
+            u.col == v.col,
+            v.row == u.row + 1
+        )
+
+        if tp == 'undirected':
+            define(Edge(u, v)).where(Edge(v, u))
+
+        return cls(model, Node, Edge)
+
+
+    @classmethod
+    def construct_diamond(cls, model, diamonds, tp = 'directed'):
+        """
+        Create a diamond Graph instance from a Model. The number of diamonds in the graph
+        is given by the parameter `diamonds`.
+        The Model should have Node and Edge concepts defined.
+        """
+        Node = model.Concept("Node")
+        Edge = model.Relationship(f"edge7 {{{Node}}} {{{Node}}}")
+
+        n = Integer.ref()
+        u, v = Node.ref(), Node.ref()
+
+        define(Node.new(id = n)).where(
+            n == std.range(1, 3*diamonds + 2, 1)
+        )
+
+        define(Edge(u, v)).where(
+            n == std.range(1, diamonds + 1, 1),
+            Node(u),
+            Node(v),
+            u.id == 3*(n-1) + 1,
+            v.id == 3*(n-1) + 2
+        )
+
+        define(Edge(u, v)).where(
+            n == std.range(1, diamonds + 1, 1),
+            Node(u),
+            Node(v),
+            u.id == 3*(n-1) + 1,
+            v.id == 3*(n-1) + 3
+        )
+
+        define(Edge(u, v)).where(
+            n == std.range(1, diamonds + 1, 1),
+            Node(u),
+            Node(v),
+            u.id == 3*(n-1) + 2,
+            v.id == 3*n + 1
+        )
+
+        define(Edge(u, v)).where(
+            n == std.range(1, diamonds + 1, 1),
+            Node(u),
+            Node(v),
+            u.id == 3*(n-1) + 3,
+            v.id == 3*n + 1
+        )
+
+        if tp == 'undirected':
+            define(Edge(u, v)).where(Edge(v, u))
+
+        return cls(model, Node, Edge)
+
+
+    @classmethod
+    def construct_rake(cls, model, length, fan_out, tp = 'directed'):
+        """
+        Create a grid Graph instance from a Model. The length of the side of the grid
+        is given by the parameter `side`.
+        The Model should have Node and Edge concepts defined.
+        """
+        Node = model.Concept("Node")
+        Edge = model.Relationship(f"edge8 {{{Node}}} {{{Node}}}")
+
+        start, i = Integer.ref(), Integer.ref()
+        u, v = Node.ref(), Node.ref()
+
+        define(Node.new(id = i)).where(
+            i == std.range(0,  (length + 1) * (fan_out + 1), 1)
+        )
+
+        define(Edge(u, v)).where(
+            i == std.range(0, length, 1),
+            Node(u),
+            Node(v),
+            u.id == i,
+            v.id == i + 1
+        )
+
+        define(Edge(u, v)).where(
+            i == std.range(length + 1, (length + 1) * fan_out + 1, length + 1),
+            Node(u),
+            Node(v),
+            u.id == length,
+            v.id == i
+        )
+
+        define(Edge(u, v)).where(
+            start == std.range(length + 1, (length + 1) * fan_out + 2, length + 1),
+            i == std.range(start, start + length, 1),
+            Node(u),
+            Node(v),
+            u.id == i,
+            v.id == i + 1
+        )
+
+        if tp == 'undirected':
+            define(Edge(u, v)).where(Edge(v, u))
+
+        return cls(model, Node, Edge)

v0/relationalai/experimental/paths/path_algorithms/find_paths.py

@@ -0,0 +1,280 @@
+# Find shortest paths and walks in a graph
+
+from v0.relationalai.semantics import std, Integer, where, define, rank, sum, not_
+from v0.relationalai.semantics.std.integers import int64
+
+
+
+from ..graph import Graph
+from ..utilities.prefix_sum import linear_prefix_sum_with_groupby
+from .usp import compute_usp, compute_nsp_from_usp, compute_uw, compute_nw_from_uw
+
+
+
+def range_int64(start, stop, step=1):
+    """Helper for std.range with int64 arguments."""
+    return std.range(int64(start), int64(stop), int64(step))
+
+
+def find_shortest_paths(g: Graph, Source, Target, max_length=None, num_paths=None):
+    Node = g.Node
+
+    u, v, src = Node.ref(), Node.ref(), Node.ref()
+    i, val, lo, hi = Integer.ref(), Integer.ref(), Integer.ref(), Integer.ref()
+    level, n, m, path_num = Integer.ref(), Integer.ref(), Integer.ref(), Integer.ref()
+    d, r, s, tot = Integer.ref(), Integer.ref(), Integer.ref(), Integer.ref()
+
+    ord_source = g.model.Relationship(f"ord_source {{Integer}}th source node {{{Node}}}")
+    total_paths = g.model.Relationship("total_paths {Integer}")
+    int_source = g.model.Relationship(f"int_source paths from {{{Node}}} numbered {{Integer}} to {{Integer}}")
+    paths_listing = g.model.Relationship(f"paths_listing {{{Node}}} {{Integer}} {{Integer}} {{Integer}}")
+    paths = g.model.Relationship(f"paths {{{Integer}}} has {{{Integer}}}th node {{{Node}}}")
+    neighbor = g.model.Relationship(f"neighbor {{{Node}}} neighbor {{Integer}} is {{{Node}}}")
+    edge_nsp = g.model.Relationship(f"edge_nsp num shortest from {{{Node}}} through {{Integer}} neighbor {{Integer}}")
+    acc_nsp = g.model.Relationship(f"acc_nsp num shortest from {{{Node}}} neighbor from 1 to {{Integer}} is {{Integer}}")
+    nsp_interval = g.model.Relationship(f"nsp_interval {{{Node}}} {{Integer}} {{Integer}} {{Integer}}")
+    path_routing = g.model.Relationship(f"path_routing {{{Node}}} {{Integer}} {{{Node}}} {{Integer}}")
+
+    usp, Boundary = compute_usp(g, Source, Target, max_length)
+
+    where(usp(u, v), r == rank(v).per(u)).define(neighbor(u, r, v))
+
+    nsp = compute_nsp_from_usp(g, usp, Source, Target, Boundary)
+
+    define(edge_nsp(u, i, val)).where(
+        neighbor(u, i, v),
+        nsp(v, val)
+    )
+
+    acc_nsp = linear_prefix_sum_with_groupby(edge_nsp)
+
+    define(nsp_interval(u, i, lo, hi)).where(
+        i == 1,
+        lo == 1,
+        acc_nsp(u, i, hi)
+    )
+    define(nsp_interval(u, i, lo, hi)).where(
+        acc_nsp(u, i - 1, lo - 1),
+        acc_nsp(u, i, hi)
+    )
+
+    define(ord_source(r, u)).where(
+        Source(u),
+        usp(u, v),
+        r == rank(u)
+    )
+
+    define(ord_source(r, u)).where(
+        Source(u),
+        Target(u),
+        r == rank(u)
+    )
+
+    if num_paths is not None:
+        define(total_paths(num_paths))
+    else:
+        define(total_paths(sum(src, n))).where(nsp(src, n))
+
+    define(int_source(src, n, m)).where(
+        total_paths(tot),
+        ord_source(1, src),
+        n == 1,
+        nsp(src, level),
+        n <= tot,
+        tot <= level,
+        m == tot
+    )
+
+    define(int_source(src, n, m)).where(
+        total_paths(tot),
+        ord_source(1, src),
+        n == 1,
+        nsp(src, level),
+        level < tot,
+        m == level
+    )
+
+    define(int_source(src, n, m)).where(
+        total_paths(tot),
+        ord_source(d, src),
+        ord_source(d-1, u),
+        int_source(u, r, s),
+        n == s + 1,
+        nsp(src, level),
+        n <= tot,
+        tot <= s + level,
+        m == tot
+    )
+
+    define(int_source(src, n, m)).where(
+        total_paths(tot),
+        ord_source(d, src),
+        ord_source(d-1, u),
+        int_source(u, r, s),
+        n == s + 1,
+        nsp(src, level),
+        s + level < tot,
+        m == s + level
+    )
+
+    where(
+        int_source(src, n, m),
+        path_num == range_int64(n, m + 1, 1),
+        r == path_num - n + 1,
+    ).define(paths_listing(src, r, 0, path_num))
+
+    where(
+        paths_listing(u, m, level - 1, path_num),
+        path_routing(u, m, v, n)
+    ).define(paths_listing(v, n, level, path_num))
+
+    where(
+        nsp_interval(u, i, lo, hi),
+        m == range_int64(lo, hi + 1, 1),
+        neighbor(u, i, v),
+        n == m - lo + 1
+    ).define(path_routing(u, m, v, n))
+
+    define(paths(path_num, level, v)).where(
+        paths_listing(v, n, level, path_num)
+    )
+
+    return paths
+
+
+def find_walks(g: Graph, Source, Target, max_length, num_paths=None):
+    Node = g.Node
+
+    u, v, src = Node.ref(), Node.ref(), Node.ref()
+    i, val, lo, hi = Integer.ref(), Integer.ref(), Integer.ref(), Integer.ref()
+    level, n, m, path_num = Integer.ref(), Integer.ref(), Integer.ref(), Integer.ref()
+    d, r, s, tot = Integer.ref(), Integer.ref(), Integer.ref(), Integer.ref()
+
+    ord_source = g.model.Relationship(f"ord_source {{Integer}}th source node {{{Node}}}")
+    total_paths = g.model.Relationship("total_paths {Integer}")
+    int_source = g.model.Relationship(f"int_source paths from {{{Node}}} numbered {{Integer}} to {{Integer}}")
+    paths_listing = g.model.Relationship(f"paths_listing {{{Node}}} {{Integer}} {{Integer}} {{Integer}}")
+    paths = g.model.Relationship(f"paths {{{Integer}}} has {{{Integer}}}th node {{{Node}}}")
+    neighbor = g.model.Relationship(f"neighbor pair {{{Node}}} {{Integer}} neighbor {{Integer}} is {{{Node}}}")
+    edge_nsp = g.model.Relationship(f"edge_nsp num shortest from pair {{{Node}}} {{Integer}} through {{Integer}} neighbor {{Integer}}")
+    acc_nsp = g.model.Relationship(f"acc_nsp num shortest from {{{Node}}} neighbor from 1 to {{Integer}} is {{Integer}}")
+    nsp_interval = g.model.Relationship(f"nsp_interval {{{Node}}} {{Integer}} {{Integer}} {{Integer}} {{Integer}}")
+    path_routing = g.model.Relationship(f"path_routing {{{Node}}} {{Integer}} {{Integer}} {{{Node}}} {{Integer}}")
+
+    uw, Boundary = compute_uw(g, Source, Target, max_length)
+
+
+    where(uw(u, n, v), r == rank(v).per(u, n)).define(neighbor(u, n, r, v))
+
+    nw = compute_nw_from_uw(g, uw, Target, Boundary)
+
+    define(edge_nsp(u, n, i, val)).where(
+        neighbor(u, n, i, v),
+        nw(v, n + 1, val)
+    )
+
+    acc_nsp = linear_prefix_sum_with_groupby(edge_nsp)
+
+    define(nsp_interval(u, n, i, lo, hi)).where(
+        i == 1,
+        lo == 1,
+        acc_nsp(u, n, i, hi)
+    )
+    define(nsp_interval(u, n, i, lo, hi)).where(
+        acc_nsp(u, n, i - 1, lo - 1),
+        acc_nsp(u, n, i, hi)
+    )
+
+    define(ord_source(r, u)).where(
+        Source(u),
+        uw(u, 0, v),
+        r == rank(u)
+    )
+
+    define(ord_source(r, u)).where(
+        Source(u),
+        Target(u),
+        r == rank(u)
+    )
+
+    if num_paths is not None:
+        define(total_paths(num_paths))
+    else:
+        define(total_paths(sum(src, 0, n))).where(nw(src, 0, n))
+
+    define(int_source(src, n, m)).where(
+        total_paths(tot),
+        ord_source(1, src),
+        n == 1,
+        nw(src, 0, level),
+        n <= tot,
+        tot <= level,
+        m == tot
+    )
+
+    define(int_source(src, n, m)).where(
+        total_paths(tot),
+        ord_source(1, src),
+        n == 1,
+        nw(src, 0, level),
+        level < tot,
+        m == level
+    )
+
+    define(int_source(src, n, m)).where(
+        total_paths(tot),
+        ord_source(d, src),
+        ord_source(d-1, u),
+        int_source(u, r, s),
+        n == s + 1,
+        nw(src, 0, level),
+        n <= tot,
+        tot <= s + level,
+        m == tot
+    )
+
+    define(int_source(src, n, m)).where(
+        total_paths(tot),
+        ord_source(d, src),
+        ord_source(d-1, u),
+        int_source(u, r, s),
+        n == s + 1,
+        nw(src, 0, level),
+        s + level < tot,
+        m == s + level
+    )
+
+    where(
+        int_source(src, n, m),
+        path_num == range_int64(n, m + 1, 1),
+        r == path_num - n + 1,
+    ).define(paths_listing(src, r, 0, path_num))
+
+    where(
+        paths_listing(u, m, level - 1, path_num),
+        path_routing(u, level - 1, m, v, n),
+        not_(Target(u))
+    ).define(paths_listing(v, n, level, path_num))
+
+    where(
+        paths_listing(u, m, level - 1, path_num),
+        path_routing(u, level - 1, m - 1, v, n),
+        Target(u),
+        m >= 2
+    ).define(paths_listing(v, n, level, path_num))
+
+    where(
+        nsp_interval(u, level, i, lo, hi),
+        m == range_int64(lo, hi + 1, 1),
+        neighbor(u, level, i, v),
+        n == m - lo + 1
+    ).define(path_routing(u, level, m, v, n))
+
+    define(paths(path_num, level, v)).where(
+        paths_listing(v, n, level, path_num)
+    )
+
+    return paths
+
+# Explicitly export relevant classes and functions
+__all__ = []