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

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

@@ -1,26 +0,0 @@
-# For builder components.
-from v0.relationalai.semantics import Integer, define
-from v0.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

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

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

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

@@ -1,59 +0,0 @@
-# For builder components.
-from v0.relationalai.semantics import Integer, where, define, select, min
-from v0.relationalai.experimental.paths.graph import Graph
-from v0.relationalai.experimental.paths.path_algorithms.one_sided_ball_repetition import ball_with_repetition
-from v0.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

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

@@ -1,39 +0,0 @@
-# For builder components.
-from v0.relationalai.semantics import Integer, define
-from v0.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

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

@@ -1,103 +0,0 @@
-# For builder components.
-from v0.relationalai.semantics import Integer, define, not_, count
-from v0.relationalai.experimental.paths.graph import Graph
-from v0.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

v0/relationalai/experimental/paths/path_algorithms/usp-old.py

@@ -1,130 +0,0 @@
-# For builder components.
-from v0.relationalai.semantics import Integer, define, max, sum, not_
-from v0.relationalai.experimental.paths.graph import Graph
-from v0.relationalai.experimental.paths.path_algorithms.one_sided_ball_upto import ball_upto
-from v0.relationalai.experimental.paths.path_algorithms.one_sided_ball_repetition import ball_with_repetition
-
-
-def compute_usp(g: Graph, Source, Target, max_length = None):
-    # Computes the Union of Shortest Paths (USP) from a source set to a destination set
-    # USP is a subgraph of the original graph
-
-    edge = g.Edge
-    Node = g.Node
-
-    n, d = Integer.ref(), Integer.ref()
-    tgt, u, v, w = Node.ref(), g.Node.ref(), g.Node.ref(), g.Node.ref()
-
-    if max_length is None:
-        ball = ball_upto(g, Source, Target)
-        usp_nodes = g.model.Relationship(f"Node {{{Node}}} is in the USP")
-        usp = g.model.Relationship(f"Edge {{{Node}}} to {{{Node}}} is in the USP")
-        boundary = g.model.Relationship(f"Target node {{{Node}}} is in the boundary of the ball")
-
-        # propagate backwards to find the nodes that are in the USP:
-        define(boundary(tgt)).where(
-            Target(tgt),
-            ball(n, tgt)
-        )
-
-        define(usp_nodes(tgt)).where(
-            boundary(tgt)
-        )
-
-        define(usp_nodes(u)).where(
-            usp(u, v)
-        )
-
-        define(usp(u, v)).where(
-            usp_nodes(v),
-            ball(d, v),
-            ball(d - 1, u),
-            edge(u, v)
-        )
-    else:
-        ball = ball_with_repetition(g, Source, max_length)
-        max_dist = g.model.Relationship("The maximum distance of a target node form the source nodes is {Integer}")
-        usp = g.model.Relationship(f"{{{Node}}} at distance {{Integer}} from the source nodes is connected with {{{Node}}}")
-        boundary = g.model.Relationship(f"Target pair {{{Node}}} {{Integer}} is in the boundary of the ball")
-
-        define(max_dist(max(n))).where(
-            ball(n, tgt),
-            Target(tgt)
-        )
-
-        define(boundary(tgt, n)).where(
-            max_dist(n),
-            Target(tgt),
-            ball(n, tgt)
-        )
-
-        define(usp(u, n, tgt)).where(
-            boundary(tgt, n + 1),
-            ball(n, u),
-            edge(u, v)
-        )
-
-        define(usp(u, n, v)).where(
-            usp(v, n + 1, w),
-            ball(n, u),
-            edge(u, v)
-        )
-
-
-    return usp, boundary
-
-
-
-
-def compute_nsp_from_usp(g: Graph, usp, Source, Target, Boundary):
-    Node = g.Node
-
-    n, m = Integer.ref(), Integer.ref()
-    tgt, u, v = Node.ref(), Node.ref(), Node.ref()
-
-    if usp._arity() == 2:
-        nsp = g.model.Relationship(f"Number of shortest paths from {{{Node}}} to destination is {{Integer}}")
-
-        define(nsp(tgt, 1)).where(
-            Boundary(tgt)
-        )
-
-        define(nsp(tgt, 1)).where(
-            Target(tgt),
-            Source(tgt)
-        )
-
-        define(nsp(u, sum(v, n).per(u))).where(
-            nsp(v, n),
-            usp(u, v)
-        )
-    else:
-        nsp = g.model.Relationship(f"Number of shortest paths from pair {{{Node}}} {{Integer}} to destination is {{Integer}}")
-
-        define(nsp(tgt, n, 1)).where(
-            Boundary(tgt, n)
-        )
-
-        define(nsp(u, n, sum(v, n + 1, m).per(u, n))).where(
-            nsp(v, n + 1, m),
-            usp(u, n, v),
-            not_(Target(u))
-        )
-
-        define(nsp(u, n, 1 + sum(v, n + 1, m).per(u, n))).where(
-            nsp(v, n + 1, m),
-            usp(u, n, v),
-            Target(u),
-            not_(Boundary(u, n))
-        )
-
-    return nsp
-
-
-def compute_nsp(g: Graph, Source, Target, max_length = None):
-    # Computes the number of shortest paths (NSP) from a source set to a destination set
-
-    usp, Boundary  = compute_usp(g, Source, Target, max_length)
-    nsp = compute_nsp_from_usp(g, usp, Source, Target, Boundary)
-
-    return nsp

v0/relationalai/experimental/paths/path_algorithms/usp-tuple.py

@@ -1,183 +0,0 @@
-# For builder components.
-from v0.relationalai.semantics import Model, Integer, define, max, sum, select, not_
-from v0.relationalai.experimental.paths.graph import Graph
-from v0.relationalai.experimental.paths.path_algorithms.one_sided_ball_upto import ball_upto
-from v0.relationalai.experimental.paths.path_algorithms.one_sided_ball_repetition import ball_with_repetition
-
-
-def compute_usp(g: Graph, Source, Target, max_length = None):
-    # Computes the Union of Shortest Paths (USP) from a source set to a destination set
-    # USP is a subgraph of the original graph
-
-    edge = g.Edge
-    Node = g.Node
-
-    n, d = Integer.ref(), Integer.ref()
-    tgt, u, v = Node.ref(), g.Node.ref(), g.Node.ref()
-
-    if max_length is None:
-        ball = ball_upto(g, Source, Target)
-        usp_nodes = g.model.Relationship(f"usp_nodes1 {{{Node}}}")
-        usp = g.model.Relationship(f"usp1 {{{Node}}} {{{Node}}}")
-        boundary = g.model.Relationship(f"boundary1 {{{Node}}}")
-
-        # propagate backwards to find the nodes that are in the USP:
-        define(boundary(tgt)).where(
-            Target(tgt),
-            ball(n, tgt)
-        )
-
-        define(usp_nodes(tgt)).where(
-            boundary(tgt)
-        )
-
-        define(usp_nodes(u)).where(
-            usp(u, v)
-        )
-
-        define(usp(u, v)).where(
-            usp_nodes(v),
-            ball(d, v),
-            ball(d - 1, u),
-            edge(u, v)
-        )
-    else:
-        ball = ball_with_repetition(g, Source, max_length)
-        max_dist = g.model.Relationship("max_dist1 {Integer}")
-        NodeDist = g.model.Concept("NodeDist")
-        usp = g.model.Relationship(f"usp2 {{{NodeDist}}} {{{NodeDist}}}")
-        boundary = g.model.Relationship(f"boundary2 {{{NodeDist}}}")
-
-        define(NodeDist.new(node = u, layer = n)).where(
-            ball(n, u)
-        )
-
-        define(max_dist(max(n))).where(
-            ball(n, tgt),
-            Target(tgt)
-        )
-
-        uu, vv, ww = NodeDist.ref(), NodeDist.ref(), NodeDist.ref()
-
-        define(boundary(uu)).where(
-            NodeDist(uu),
-            max_dist(n),
-            Target(tgt),
-            ball(n, tgt),
-            uu.node == tgt,
-            uu.layer == n
-        )
-
-        define(usp(uu, vv)).where(
-            boundary(vv),
-            NodeDist(uu),
-            vv.node == v,
-            vv.layer == n + 1,
-            uu.node == u,
-            uu.layer == n,
-            ball(n, u),
-            edge(u, v)
-        )
-
-        define(usp(uu, vv)).where(
-            usp(vv, ww),
-            vv.node == v,
-            vv.layer == n + 1,
-            uu.node == u,
-            uu.layer == n,
-            ball(n, u),
-            edge(u, v)
-        )
-
-
-    return usp, boundary
-
-
-
-
-def compute_nsp_from_usp(g: Graph, usp, Source, Target, Boundary):
-    Node = g.Node
-
-    n, m = Integer.ref(), Integer.ref()
-    tgt, u, v = Node.ref(), Node.ref(), Node.ref()
-
-    """if max_dist is None:
-        nsp = g.model.Relationship(f"nsp2 {{{Node}}} {{Integer}}")
-        define(nsp(tgt, 1)).where(
-            Target(tgt),
-            usp(u, tgt)
-        )
-
-        define(nsp(tgt, 1)).where(
-            Target(tgt),
-            Source(tgt)
-        )
-
-        define(nsp(u, sum(v, n).per(u))).where(
-            nsp(v, n),
-            usp(u, v)
-        )
-    else:
-    """
-    nsp = g.model.Relationship(f"nsp1 {{{Node}}} {{Integer}} {{Integer}}")
-
-    define(nsp(tgt, n, 1)).where(
-        Boundary(tgt, n)
-    )
-
-    define(nsp(u, n, sum(v, n + 1, m).per(u, n))).where(
-        nsp(v, n + 1, m),
-        usp(u, n, v),
-        not_(Target(u))
-    )
-
-    define(nsp(u, n, 1 + sum(v, n + 1, m).per(u, n))).where(
-        nsp(v, n + 1, m),
-        usp(u, n, v),
-        Target(u),
-        not_(Boundary(u, n))
-    )
-
-    return nsp
-
-
-def compute_nsp(g: Graph, Source, Target, max_length = None):
-    # Computes the number of shortest paths (NSP) from a source set to a destination set
-
-    if max_length is None:
-        usp, Boundary = compute_usp(g, Source, Target)
-        nsp = compute_nsp_from_usp(g, usp, Source, Target, Boundary)
-    else:
-        usp, Boundary  = compute_usp(g, Source, Target, max_length)
-        nsp = compute_nsp_from_usp(g, usp, Source, Target, Boundary)
-
-    return nsp
-
-
-model = Model("test_usp_nsp_single", dry_run=False)
-
-grid1 = Graph.construct_grid(model, 2, "undirected")
-
-source1 = grid1.Node.new(row = 1, col = 1)
-target1 = grid1.Node.new(row = 2, col = 2)
-
-Source1 = model.Concept("Source1", extends=[grid1.Node])
-Target1 = model.Concept("Target1", extends=[grid1.Node])
-
-define(Source1(source1))
-define(Target1(target1))
-define(Target1(source1))
-
-usp, boundary = compute_usp(grid1, Source1, Target1, 4)
-
-usp.inspect()
-#nsp = compute_nsp(grid1, Source1, Target1, 4)
-
-
-u, v = grid1.Node.ref(), grid1.Node.ref(),
-n, m = Integer.ref(), Integer.ref()
-
-select(u, v).where(usp(u, v)).inspect()
-
-
-# select(u.row, u.col, n, m).where(nsp(u, n, m)).inspect()