Path-search in the pyramid and in other graphs

We are given an acyclic directed graph with one source, and a subset of its edges which contains exactly one outgoing edge for every non-sink vertex. These edges determine a unique path from the source to a sink. We can think of it as a switch in every vertex, which determines which way the water arriving to that vertex flows further. We are interested in determining either the sink the flow arrives, or the whole path, with as few questions as possible. The questions we can ask correspond to the vertices of the graph, and the answer describes the switch, i.e. tells which outgoing edge is in our given subset. Originally the problem was proposed by Soren Riis (who posed the question for pyramid graphs) in the following more general form. We are given a natural number k, and k questions can be asked in a round. The goal is to minimize the number of rounds. We completely solve this problem for complete t-ary trees. Also, for pyramid graphs we present some non-trivial partial results.

💡 Research Summary

The paper studies a query problem on directed acyclic graphs (DAGs) that have a single source and a distinguished subset E* of edges such that every non‑sink vertex has exactly one outgoing edge in E*. This subset defines a unique directed path P(E*) from the source to a sink, which can be interpreted as a “switch” at each vertex directing the flow. The central question is: how many vertex‑queries are needed, possibly in parallel rounds, to determine either the final sink or the entire path?

Two basic complexity measures are introduced:
* si(G) – the minimum number of queries required to identify the sink only.
* pa(G) – the minimum number of queries required to reconstruct the whole path.
Clearly si(G) ≤ pa(G) ≤ ℓ(G), where ℓ(G) denotes the length (number of edges) of the longest directed path in G.

A key technical tool is a “merging” operation that eliminates vertices of out‑degree 1. For a set M of vertices, the operation deletes M, creates a new vertex m, and redirects all edges from the rest of the graph into M to m, collapsing parallel edges. Repeating this until every non‑sink has out‑degree at least 2 yields a reduced graph G′ (for simple graphs) or G″ (for multigraphs). The authors prove:

• Theorem 1: If a simple graph has no out‑degree‑1 vertices, then si(G) = ℓ(G).
• Theorem 2: If a (multi)graph has no out‑degree‑1 vertices, then pa(G) = ℓ(G).

The proofs rely on an adversarial strategy: whenever a query is asked, the adversary answers with an edge that belongs to a fixed longest path P, thereby guaranteeing that each answer can eliminate at most one edge of P. Consequently, at least ℓ(G) questions are necessary, and the merging operation shows that no more than ℓ(G) queries ever suffice.

The paper then focuses on rooted directed trees, especially complete d‑ary trees T₍d₎(n) with n + 1 levels. When up to k queries may be asked in a single round, the authors determine the exact round complexity:

• Theorem 3:
   paₖ(T₍d₎(n)) = siₖ(T₍d₎(n)) = ⌈ n / log′₍d₎ k ⌉,

where log′₍d₎ k is the largest integer i such that 1 + d + … + d^{i‑1} ≤ k. The upper bound is achieved by a natural strategy that queries as many complete levels as possible each round; each round extends the known prefix of the path by log′₍d₎ k levels. For the lower bound, an adversary is constructed that, given any set S of k queried vertices in a round, forces at most log′₍d₎ k of them to lie on the final path. This is done by always directing the flow to the child subtree containing the fewest queried vertices, guaranteeing that the number of “path‑vertices” contributed by the round grows at most geometrically. Induction then shows that at least ⌈ n / log′₍d₎ k ⌉ rounds are unavoidable. Hence the parallel query model does not give any advantage beyond the logarithmic compression captured by log′₍d₎ k.

The authors also investigate the “pyramid graph”, a DAG where level i contains i vertices and each vertex has two outgoing edges to the next level (left and right). For k = 1, the problem reduces to the longest‑path bound, i.e., ℓ rounds are necessary. For k > 1, they present partial results: by querying vertices spread across several consecutive levels, one can reduce the number of rounds to O(log n), but the exact value of log′₍d₎ k or a matching lower bound remains open. The difficulty stems from the overlapping sub‑structures of the pyramid, which prevent a clean decomposition into independent sub‑trees as in the complete d‑ary case.

The paper further extends the analysis to graphs that may contain directed cycles. Here they define a “generalized path” (a directed path that may end with an extra edge returning to an earlier vertex). Let ℓ′(G) be the length of the longest generalized path. When no vertex has out‑degree 1, they prove pa(G) = ℓ′(G). However, for si(G) the merging operation can lose information about cycles, so a simple equality does not hold.

Motivation for the model includes parallel simulation of game trees: each vertex represents a game state, edges represent legal moves, and a deterministic (or black‑box) strategy corresponds to a unique outgoing edge at each state. Determining the final outcome of a match with parallel queries corresponds exactly to the sink‑search problem. The results therefore give optimal parallel algorithms for such simulations, albeit the authors note that in many practical games the underlying graph is huge and non‑trivial algorithms are hard to find.

The paper concludes with several open problems: determining exact paₖ and siₖ for pyramid graphs, tightening bounds for general DAGs, and understanding the sink‑search complexity when cycles are present. The techniques introduced—especially the merging reduction and the adversarial lower‑bound construction—provide a solid foundation for future work on parallel query models in directed graphs.