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

relationalai/experimental/paths/path_algorithms/find_paths.py

@@ -1,280 +0,0 @@
-# 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

@@ -1,26 +0,0 @@
-# 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

@@ -1,111 +0,0 @@
-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

@@ -1,59 +0,0 @@
-# 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

@@ -1,39 +0,0 @@
-# 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

@@ -1,103 +0,0 @@
-# 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