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

relationalai/experimental/paths/path_algorithms/find_paths.py

@@ -0,0 +1,280 @@
+# Find shortest paths and walks in a graph
+
+from relationalai.semantics import std, Integer, where, define, rank, sum, not_
+from 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__ = []

relationalai/experimental/paths/path_algorithms/one_sided_ball_repetition.py

@@ -0,0 +1,26 @@
+# For builder components.
+from relationalai.semantics import Integer, define
+from relationalai.experimental.paths.graph import Graph
+
+
+def ball_with_repetition(g:Graph, Source, max_length):
+    edge = g.Edge
+    Node = g.Node
+
+    ball = g.model.Relationship(f"ball_rep {{Integer}} {{{Node}}}") # , [Integer, Node])
+
+    u, v, src = Node.ref(), Node.ref(), Node.ref()
+    level, m = Integer.ref(), Integer.ref()
+
+    # Base case: a node is reachable from itself
+    define(ball(0, src)).where(Source(src))
+
+    # Recursive case:
+    define(ball(level, v)).where(
+        ball(m, u),
+        m == level - 1,
+        edge(u, v),
+        level <= max_length
+    )
+
+    return ball

relationalai/experimental/paths/path_algorithms/one_sided_ball_upto.py

@@ -0,0 +1,111 @@
+from relationalai.semantics import Integer, define, not_
+from ..graph import Graph
+from ..utilities.iterators import setup_iteration
+
+
+# Source and Target are concepts representing sets of nodes
+def ball_upto(g:Graph, Source, Target, max_length=None):
+    edge = g.Edge
+    Node = g.Node
+
+    # ball(d, ⋅) is the sphere of nodes at distance d from the source node
+    # visited(d, ⋅) is the union of all balls up to distance d
+
+    ball = g.model.Relationship(f"ball1 {{Integer}} {{{Node}}}") # , [Integer, Node])
+    visited = g.model.Relationship(f"visited1 {{{Node}}}") # , [Integer, Node])
+    condition = g.model.Relationship("condition1 {Integer}")
+
+    if max_length is None:
+        iter = setup_iteration(g.model, condition, 0, 1000000)
+    else:
+        iter = setup_iteration(g.model, condition, 0, max_length)
+
+    src, tgt = Node.ref(), Node.ref()
+
+    # Ball around src contains src at distance 0:
+    define(ball(0, src)).where(Source(src))
+
+    u, v = g.Node.ref(), g.Node.ref()
+    n, k = Integer.ref(), Integer.ref()
+
+    # Recursive case:
+    define(ball(k, v)).where(
+        iter(k),
+        ball(k - 1, u),
+        edge(u, v),
+        not_(
+            visited(v),
+        ),
+    )
+
+    define(ball(k, u)).where(
+        ball(k, u)
+    )
+
+    define(visited(u)).where(
+        iter(k),
+        ball(k, u)
+    )
+
+    define(visited(u)).where(
+        visited(u)
+    )
+
+    define(condition(n)).where(
+        iter(n),
+        ball(n, u),
+        not_(
+            ball(n, tgt),
+            Target(tgt)
+        )
+    )
+
+    return ball
+
+
+def ball_upto_alt(g:Graph, Source, Target, max_length=None):
+    edge = g.Edge
+    Node = g.Node
+
+    # ball(d, ⋅) is the sphere of nodes at distance d from the source node
+
+    ball = g.model.Relationship(f"ball2 {{Integer}} {{{Node}}}") # , [Integer, Node])
+    condition = g.model.Relationship("condition2 {Integer}")
+
+    if max_length is None:
+        iter = setup_iteration(g.model, condition, 0, 1000000)
+    else:
+        iter = setup_iteration(g.model, condition, 0, max_length)
+
+    src, tgt = Node.ref(), Node.ref()
+
+    # Ball around src contains src at distance 0:
+    define(ball(0, src)).where(Source(src))
+
+    u, v = g.Node.ref(), g.Node.ref()
+    n, k = Integer.ref(), Integer.ref()
+
+    # Recursive case:
+    define(ball(k, v)).where(
+        iter(k),
+        ball(k - 1, u),
+        edge(u, v),
+        not_(
+            ball(n, v),
+        ),
+    )
+
+    define(ball(k, u)).where(
+        ball(k, u)
+    )
+
+    define(condition(n)).where(
+        iter(n),
+        ball(n, u),
+        not_(
+            ball(n, tgt),
+            Target(tgt)
+        )
+    )
+
+    return ball

relationalai/experimental/paths/path_algorithms/single.py

@@ -0,0 +1,59 @@
+# For builder components.
+from relationalai.semantics import Integer, where, define, select, min
+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
+
+
+def single_path(g: Graph, ball, dst, radius):
+    edge = g.Edge
+    Node = g.Node
+
+    path = g.model.Relationship(f"path {{Integer}} {{v:{Node}}}")
+
+    d = Integer.ref()
+    u, v = Node.ref(), Node.ref()
+
+    define(path(radius, dst))  # path of length 0 starts at src
+
+    where(
+        path(d, v),
+        edge(u, v),
+        ball(d - 1, u)
+    ).define(path(d - 1, min(v, u).per(d)))
+
+    return path
+
+
+def single_walk(g: Graph, Source, Target, radius):
+    Node = g.Node
+
+    ball = ball_with_repetition(g, Source, radius)
+
+    # choose a destination node at distance radius:
+    u = Node.ref()
+    dst = where(ball(radius, u), Target(u)).select(min(u))
+    walk = single_path(g, ball, dst, radius)
+
+    return walk
+
+
+def single_shortest_path(g: Graph, Source, Target):
+    Node = g.Node
+
+    cand = g.model.Relationship(f"candidate {{Integer}} {{v:{Node}}}")
+
+    ball = ball_upto(g, Source, Target)
+
+    # choose a destination node at distance radius:
+    level = Integer.ref()
+    u, tgt = Node.ref(), Node.ref()
+    define(cand(level, u)).where(ball(level, u), Target(u))
+    radius = select(level).where(cand(level, u))
+    tgt = select(min(u)).where(cand(level, u))
+    path = single_path(g, ball, tgt, radius)
+
+    return path

relationalai/experimental/paths/path_algorithms/two_sided_balls_repetition.py

@@ -0,0 +1,39 @@
+# For builder components.
+from relationalai.semantics import Integer, define
+from relationalai.experimental.paths.graph import Graph
+
+
+def two_balls_repetition(g:Graph, Source, Target, max_length):
+    edge = g.Edge
+    Node = g.Node
+
+    source_ball = g.model.Relationship(f"source_ball1 {{Integer}} {{{Node}}}")
+    target_ball = g.model.Relationship(f"target_ball1 {{Integer}} {{{Node}}}")
+
+    radius_S = max_length // 2
+    radius_T = max_length - radius_S
+
+    u, v, src, tgt = Node.ref(), Node.ref(), Node.ref(), Node.ref()
+    level = Integer.ref()
+
+    # Ball around src contains src at distance 0:
+    define(source_ball(0, src)).where(Source(src))
+
+    # Recursive case:
+    define(source_ball(level, u)).where(
+        level <= radius_S,
+        source_ball(level - 1, v),
+        edge(v, u)
+    )
+
+    # Ball around dst contains dst at distance 0:
+    define(target_ball(0, tgt)).where(Target(tgt))
+
+    # Recursive case:
+    define(target_ball(level, u)).where(
+        level <= radius_T,
+        target_ball(level - 1, v),
+        edge(u, v)
+    )
+
+    return source_ball, target_ball

relationalai/experimental/paths/path_algorithms/two_sided_balls_upto.py

@@ -0,0 +1,103 @@
+# For builder components.
+from relationalai.semantics import Integer, define, not_, count
+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):
+    edge = g.Edge
+    Node = g.Node
+
+    source_ball = g.model.Relationship(f"source_ball2 {{Integer}} {{{Node}}}")
+    target_ball = g.model.Relationship(f"target_ball2 {{Integer}} {{{Node}}}")
+    source_condition = g.model.Relationship("source_condition1 {Integer}")
+    target_condition = g.model.Relationship("target_condition1 {Integer}")
+    source_surface = g.model.Relationship("source_surface1 {Integer}")
+    target_surface = g.model.Relationship("target_surface1 {Integer}")
+
+    if max_length is None:
+        radius_S = setup_iteration(g.model, source_condition, 0, 1000000)
+        radius_T = setup_iteration(g.model, target_condition, 0, 1000000)
+    else:
+        half_radius = max_length//2
+        radius_S = setup_iteration(g.model, source_condition, 0, half_radius)
+        radius_T = setup_iteration(g.model, target_condition, 0, max_length - half_radius)
+
+    u, v, w, src, tgt = Node.ref(), Node.ref(), Node.ref(), Node.ref(), Node.ref()
+    m, n, k, l1, l2 = Integer.ref(), Integer.ref(), Integer.ref(), Integer.ref(), Integer.ref()
+
+    # Ball around src contains src at distance 0:
+    define(source_ball(0, src)).where(Source(src))
+
+    # Recursive case:
+    define(source_ball(k, u)).where(
+        radius_S(k),
+        source_ball(k - 1, v),
+        edge(v, u),
+        not_(
+            source_ball(n, u),
+            n < k
+        )
+    )
+
+    define(source_ball(k, u)).where(
+        source_ball(k, u)
+    )
+
+    # Ball around dst contains dst at distance 0:
+    define(target_ball(0, tgt)).where(Target(tgt))
+
+    # Recursive case:
+    define(target_ball(k, u)).where(
+        radius_T(k),
+        target_ball(k - 1, v),
+        edge(u, v),
+        not_(
+            target_ball(n, u),
+            n < k
+        )
+    )
+
+    define(target_ball(k, u)).where(
+        target_ball(k, u)
+    )
+
+    define(source_condition(n)).where(
+        radius_S(n),
+        source_ball(n, u),
+        radius_T(m),
+        target_ball(m, v),
+        not_(
+            source_ball(n, w),
+            target_ball(m, w)
+        ),
+        source_surface(l1),
+        target_surface(l2),
+        l1 < l2
+    )
+
+    define(target_condition(m)).where(
+        radius_S(n),
+        source_ball(n, u),
+        radius_T(m),
+        target_ball(m, v),
+        not_(
+            source_ball(n, w),
+            target_ball(m, w)
+        ),
+        source_surface(l1),
+        target_surface(l2),
+        l1 >= l2
+    )
+
+    define(target_surface(count(u))).where(
+        radius_T(n),
+        target_ball(n, u)
+    )
+
+    define(source_surface(count(u))).where(
+        radius_S(n),
+        source_ball(n, u)
+    )
+
+    return source_ball, target_ball