Title: Deterministic Edge Connectivity and Max Flow using Subquadratic Cut | Queries
Domain: Computer Science

Question: Develop a deterministic algorithm to find the global min-cut of a simple graph using sub-quadratic queries in the cut query model, specifically aiming for \( \tilde{O}(n^{5/3}) \) queries. Design an algorithm to find \( s \)-\( t \) max-flows of size \( \tilde{O}(n) \) using \( \tilde{O}(n^{5/3}) \) queries. Additionally, provide efficient cut-query implementations for expander decomposition and isolating cuts.

Background: The problem of computing the global min-cut of a graph, also known as edge connectivity, is a fundamental problem in algorithmic graph theory. This problem involves finding the smallest set of edges whose removal disconnects the graph. The study of this problem has been extensive, with various computational models being explored, including dynamic, parallel, distributed, and streaming algorithms. One model that has attracted significant attention recently is the cut-query model, where the edge set of the graph is unknown, and the algorithm can only make cut queries to an oracle that returns the number of edges crossing a given cut. Previous work in this model has focused on randomized algorithms, but the deterministic approach remains a significant challenge. The best-known deterministic algorithm for edge connectivity still requires a large number of queries, and there is a substantial gap between the upper and lower bounds for deterministic algorithms. | | **Global Min-Cut**: The smallest set of edges whose removal disconnects the graph. | | **Edge Connectivity**: The minimum number of edges that need to be removed to disconnect the graph. | | **Cut-Query Model**: A model where the algorithm can only make queries to an oracle that returns the number of edges crossing a given cut. | | **Deterministic Algorithm**: An algorithm that always produces the same output for a given input, without any randomness. | | **Sub-Quadratic Queries**: Queries that are less than quadratic in the number of vertices, i.e., \( \tilde{O}(n^{5/3}) \). | | **Expander Decomposition**: A technique to decompose a graph into expander graphs, which are graphs with good connectivity properties. | | **Isolating Cuts**: A technique to find cuts that isolate specific vertices or sets of vertices in the graph. | | **s-t Max-Flow**: The maximum flow that can be sent from a source vertex \( s \) to a sink vertex \( t \) in a flow network.

Definitions: - **Cut Query**: A query to an oracle that returns the number of edges crossing a given cut in a graph. Specifically, for a set \( S \subseteq V \) in an undirected capacitated graph \( G \), the cut query oracle returns the total capacity of cut-edges \( \text{Cut}(S) = \sum_{a \in S, b \in \overline{S}} c(a, b) \). | | - **Bipartite Independent Set (BIS) Query**: A query to an oracle that returns whether there exists an edge between two disjoint sets \( A \) and \( B \) in a graph. For sets \( A, B \subseteq V \) in a capacitated graph \( H \), the BIS query oracle returns a boolean value indicating if \( c(A, B) = \sum_{a \in A, b \in B} c(a, b) > 0 \). | | - **Layered Graph**: Given an undirected graph \( G \) and a source vertex \( s \), the layered graph \( GL \) is a decomposition of the vertices of \( G \) into layers based on their distance from \( s \) in the residual graph \( Gf \). The \( i \)-th layer \( Li \) is defined as \( \{v \mid \text{dist}_{Gf}(s, v) = i\} \). | | - **Blocking Flow**: In the context of the layered graph \( GL \), a blocking flow \( f' \) is an \( s \)-\( t \) flow such that for every \( s \)-\( t \) path in \( GL \), some edge is saturated by \( f' \). | | - **(φ, R)-Expander**: A graph \( G \) is a (φ, R)-expander if for every cut \( (S, V \setminus S) \), the sparsity \( \Phi(S) = \frac{|∂S|}{\min\{|R \cap S|, |R \setminus S|\}} \geq φ(τ + 1) \). | | - **(φ, R)-Almost Expander**: A graph \( G \) is a (φ, R)-almost expander with core \( R' \) if \( R' \subseteq R \), \( |R'| \geq |R|(1 - \frac{1}{\log n}) \), and for any cut \( (S, V \setminus S) \), the sparsity \( \Phi(S) = \frac{|∂S|}{\min\{|R' \cap S|, |R' \setminus S|\}} \geq φ(τ + 1) \). | | - **Minimum Isolating Cut**: For any set of vertices \( R \subseteq V \) and \( r \in R \), the minimum isolating cut of \( r \) is an \( \{r\}-(R \setminus \{r\}) \) min-cut. The minimum isolating cut of \( R \) is the minimum-sized cut among the minimum isolating cuts over all \( r \in R \).

Methodology: ### Algorithm Improvement | - **Leverage Existing Algorithms**: Start by reviewing classic algorithms and think about how to modify them for new requirements. For example, use the Dinitz algorithm as a foundation. | - **Two-Phase Approach**: Divide the problem into two phases based on the shortest path distance. When the distance is less than or equal to \(n^{2/3}\), it's phase one; otherwise, it's phase two. Analyze and handle each phase separately. | | ### Problem Transformation and Simplification | - **Problem Conversion**: Turn the global min-cut problem into a Steiner min-cut problem. For a terminal set \(T\), a Steiner min-cut separates a pair of terminals in \(T\). If \(T = V(G)\), this becomes the global min-cut. | - **Use Dominating Sets**: Simplify the problem by choosing a dominating set \(D\) as the initial terminal set instead of the entire vertex set \(V(G)\). This set \(D\) has a size of \(\tilde{O}(n/\delta)\), where \(\delta\) is the minimum degree, and the global min-cut must separate \(D\). | | ### Isolating Cuts and Expander Decomposition | - **Isolating Cuts Technique**: Use isolating cuts to find the minimum isolating cut for specific vertices. | - **Expander Decomposition**: Implement expander decomposition and prove its effectiveness in the cut-query model. Use it as a tool for graph partitioning and decomposition, especially when balancing cut size and vertex count is important. | | ### Deterministic Algorithm Design | - **Deterministic Algorithms Benefits**: Look into converting randomized algorithms into deterministic ones to enhance reliability and applicability. | - **Graph Properties Utilization**: Make the most of the graph's simplicity and unweighted nature to boost algorithm efficiency. | | ### Other Query Models Reference | - **Compare Different Query Models**: Look into other query models for inspiration. For instance, study how matrix properties are learned via vector-matrix-vector queries or how graph connectivity is researched in quantum query models.

Answer: 1. Problem and model


We study deterministic algorithms in the cut-query model for a simple undirected graph G=(V,E), |V|=n. A cut query on S\subseteq V returns \mathrm{Cut}(S), the total capacity of edges crossing (S,V\setminus S). The goal is to (i) compute a global minimum cut using subquadratic many queries; and as a key ingredient, (ii) compute an s-t maximum flow of value \tilde O(n) using only \tilde O(n^{5/3}) queries. (Throughout, \tilde O(\cdot) hides polylogarithmic factors.)  

A second oracle we will simulate is the Bipartite-Independent-Set (BIS) query on (directed) residual graphs: given disjoint sets A,B, it asks whether there exists any edge from A to B. Crucially, a BIS query on an undirected graph can be simulated with 3 cut queries using
c(A,B) = \tfrac12(\mathrm{Cut}(A)+\mathrm{Cut}(B)-\mathrm{Cut}(A\cup B)).
Moreover, BIS queries on the residual graph G_f of an explicit flow f can also be simulated with 3 cut queries on G by subtracting the known contribution of f. This lets us explore residual neighborhoods and BFS layers using only cut queries.  

We assume unit capacities unless noted; with integral capacities in [1,W] the bounds below scale by W.  



2. Deterministic s-t max-flow in \tilde O(n^{5/3}) cut queries



2.1 Classical structure: Dinitz with blocking flows


Work in iterations. Maintain flow f, residual graph G_f, and the layered graph G_L given by BFS levels L_0=\{s\},L_1,\dots in G_f. Each iteration finds a blocking flow f’ in G_L that saturates at least one edge on every s-t path, augments f\leftarrow f+f’, and recomputes G_f. The key invariant is that after each iteration the layered distance strictly increases:
\mathrm{dist}_{G_f}(s,t)\ \text{increases by at least 1}.
With integral capacities \le W, Dinitz terminates in O(n^{2/3}W) iterations using the standard “short/long layered distance” analysis: once \mathrm{dist}\ge n^{2/3}, at most O(n^{2/3}W) further flow remains.  


2.2 Implementing Dinitz with only cut queries


Two primitives suffice, both via BIS\tocut simulation:

 BFS / layered graph: Build a BFS tree of G_f from s in \tilde O(n) BIS queries (hence \tilde O(n) cut queries). The idea is to recover residual neighbors by repeated BIS-guided binary search on candidate sets; total cost charges to discovered vertices.  
 
 Blocking flow search: Maintain a stack path s\leadsto t within the layered graph, pushing a next-layer neighbor if a BIS test finds one; otherwise pop and delete that vertex from the search. Every push/pop costs \tilde O(1). Each time the stack reaches length d’=\mathrm{dist}_{G_f}(s,t), one unit of flow is sent and the stack drops by d’. Over the whole blocking-flow phase this costs
 \tilde O\big(n + d’\cdot \mathrm{val}(f’)\big)
 BIS (thus cut) queries, where \mathrm{val}(f’) is the value of the blocking flow found in that iteration.  
 



2.3 Two-phase query bound


Sum the per-iteration costs over all iterations:

 Phase I (short distance): While d’<n^{2/3}, the total additional flow sent is at most the final max-flow value, assumed \tilde O(nW). With at most n^{2/3} iterations and d’<n^{2/3},
 \sum \tilde O\big(n + d’\cdot \mathrm{val}(f’)\big)\ \le\ \tilde O(n\cdot n^{2/3})\ +\ \tilde O(n^{2/3}\cdot nW)\ =\ \tilde O(n^{5/3}W).
 
 Phase II (long distance): Once d’\ge n^{2/3}, only O(n^{2/3}W) more flow remains, and d’\le n. With at most n^{2/3} iterations,
 \sum \tilde O\big(n + d’\cdot \mathrm{val}(f’)\big)\ \le\ \tilde O(n\cdot n^{2/3})\ +\ \tilde O(n\cdot n^{2/3}W)\ =\ \tilde O(n^{5/3}W).
 


Therefore an s-t max-flow of value \tilde O(nW) can be computed deterministically in \tilde O(n^{5/3}W) cut queries; in unweighted simple graphs W=1, this is \tilde O(n^{5/3}).  



3. From s-t max-flow to global min-cut in \tilde O(n^{5/3}) queries


The global min-cut routine follows a thresholded framework: given parameter \tau\le \delta-1, where \delta is the minimum degree, either (a) output a cut of size \le \tau or (b) certify the global min-cut >\tau, using \tilde O(n^{5/3}) queries. Then binary search on \tau (and the trivial \lambda=\delta case) produces the exact global min-cut.  

Two core subroutines are needed in the cut-query model:

 Minimum isolating cuts for a set of terminals R.
 
 A terminal-aware expander decomposition that preserves small cuts.
 


A structural device makes both max-flow instances small: dominating sets are separated by every cut of size \le \delta-1.  


3.1 Dominating-set separation and how to find one quickly


Let R\subseteq V be a dominating set. Then every cut of size \le \delta-1 hits both sides of R (“(\delta-1)-separated”). Intuition: if some side contained all of R, vertices on the other side would all need at least \delta cross edges by domination, contradicting a \le \delta-1 cut. This uses simplicity (no parallel edges).  

Moreover, one can deterministically find a dominating set of size |R|=\tilde O(n/\delta) with only \tilde O(n) cut queries:

 Reduction rule: While some v has degree >\delta/2 in the current graph G’, add v to R and delete v\cup N_{G’}(v). Each application removes \Omega(\delta) vertices, so this happens at most O(n/\delta) times, and its query cost charges \tilde O(1) to each deleted neighbor by BIS-guided neighbor recovery.
 
 Low-degree phase: When all current degrees \le \delta/2, consider the bipartite graph between W_1=N_G(R) and the remaining W_2=V(G’). Average degree arguments plus binary-search via cut queries find a vertex v\in W_1 adjacent to \Omega(|W_2|\delta/n) many vertices of W_2; add v to R and delete its neighbors from G’. This shrinks G’ by a constant factor every O(n/\delta) steps, giving |R|=\tilde O(n/\delta). Total queries remain \tilde O(n).  
 


This R ensures that all flow instances used later (isolating cuts, cut-matching) have total flow \tilde O(n) from the super-source/sink, so the \tilde O(n^{5/3}) max-flow routine applies.  



4. Minimum isolating cuts via \tilde O(n^{5/3}) queries


Given terminals R and a threshold \tau, an isolating cut for r\in R is a minimum \{r\}–(R\setminus\{r\}) cut; the minimum isolating cut of R is the minimum over r\in R. The task is to either find one of size \le \tau or certify all isolating cuts >\tau, with |R|=\tilde O(n/\tau). The algorithm adapts a bit-decomposition trick so that only \tilde O(\log |R|) max-flow instances are solved, each of total value \tilde O(n).  

Procedure.

 Encode & split: Assign each r\in R a distinct O(\log|R|)-bit label. For each bit position c, define a bipartition (A_c,B_c) of R by bit c. Every pair of terminals is separated in at least one bipartition.  
 
 Auxiliary graph H: For a bipartition (A,B), create H by adding super-source s_{\text{src}} and super-sink s_{\text{snk}}; connect s_{\text{src}}\to a for a\in A and b\to s_{\text{snk}} for b\in B with capacity \tau+1. Edges of G have capacity 1. Compute an s_{\text{src}}{\text{–}}s_{\text{snk}} max-flow. (To keep the graph simple and unit-capacity, replace capacity \tau+1 by \tau+1 parallel subdivided unit-edges; this increases n only by \tilde O(n).)  
 
 Record restricted min-cut: Let (C_A,C_B) be the min s_{\text{src}}{\text{–}}s_{\text{snk}} cut restricted back to G (remove the supers). By max-flow/min-cut, (C_A,C_B) is a min cut separating C_A\cap A from C_B\cap B in G.  
 
 Delete and grow components: Delete \partial C_A (for all bit bipartitions). For each r\in R, let T_r be the vertices now reachable from r; put into R’ those r that were never saturated in any bipartition max-flow (formally: the super-source edge into r was not saturated whenever r\in A, and symmetrically for B). Then the sets T_r for r\in R’ are pairwise disjoint.  
 
 Local contraction tests: For each r\in R’, contract V\setminus(\{r\}\cup(T_r\setminus R)) to a single sink s_r in a new graph G_r (keeping parallel edges). Compute the min (r,s_r) cut; if its size \le\tau, output it as an isolating cut; otherwise set \lambda_r=\infty. Because T_r are disjoint, the sum of the query costs over all r\in R’ is bounded by \sum \tilde O(|T_r|^{5/3})\le \tilde O(n^{5/3}).  
 


Correctness. If some r^\star has a closest isolating cut C_{r^\star} of size \le\tau, then in every bipartition (A,B) that separates r^\star from some other terminal, r^\star is unsaturated, and C_{r^\star}\subseteq C_A (when r^\star\in A) by submodularity/closest-cut arguments. Hence C_{r^\star}\subseteq T_{r^\star}, so the contracted test in G_{r^\star} recovers a cut \le\tau. If no r has isolating cut \le\tau, the procedure certifies this.  

Query complexity. Each bipartition’s max-flow in H has total flow value \tilde O(n) (all terminals live in R of size \tilde O(n/\tau), each incident capacity \le \tau+1); thus each is solvable in \tilde O(n^{5/3}) cut queries. There are only O(\log|R|)=\tilde O(1) bipartitions, and the disjoint-sum bound over local tests yields a total of \tilde O(n^{5/3}) queries.  



5. Handling unbalanced vs. balanced small cuts


Let R be \tau-separated (e.g., a dominating set) and \varphi\in \mathrm{poly}(1/\log n).

 A cut C=(C_1,C_2) with |\partial C|\le \tau is \varphi-unbalanced for R if \min\{|C_1\cap R|,|C_2\cap R|\}\le (1/\varphi)^3+1/\varphi; otherwise it is \varphi-balanced.  
 



5.1 Unbalanced case → isolating cuts suffice


Using a splitter family \mathcal{F} of size \tilde O(1) (deterministically constructed subsets with the property that every small subset of R is “hit” exactly once), one can run the isolating-cut routine on the sets in \mathcal{F}. If an unbalanced cut of size \le\tau exists, one of these calls will succeed and output a cut \le\tau. Total queries remain \tilde O(n^{5/3}).  


5.2 Balanced case → terminal-aware expander decomposition


When all \le\tau cuts are \varphi-balanced for R, compute a decomposition of V into parts V_1,\dots,V_k such that each induced subgraph G[V_i] is a (\varphi,R_i)-almost expander with a large core R’i\subseteq R_i=R\cap V_i, and the number of inter-part edges is bounded by
\sum{i\ne j} |E(V_i,V_j)|\ =\ O\big(\varphi\,|R|\,(\tau+1)\,\log^6 n\big).
This is achieved via a cut-matching game with a strengthened matching player:

 In each round, the cut player bisects R (explicit, no queries).
 
 The matching player either returns a \varphi(\tau+1)-sparse balanced cut (then we are done), or embeds a (\tau+1)-regular almost perfect matching between the two sides using multicommodity flow with congestion 1/\varphi. To implement this with cut queries, add s_{\text{src}} to one side with capacity \tau+1 per terminal and s_{\text{snk}} to the other; edges of G get capacity 1/\varphi. The total flow is \tilde O(n), so each round costs \tilde O(n^{5/3}) queries.  
 


After O(\log n) rounds, the union of perfect b-matchings has sparsity \Omega(\tau+1). Some edges are fake (to complete almost matchings); expander pruning removes a tiny set P of vertices so that the remaining graph (without fake edges) has conductance \tilde\Omega(1). Defining R’ = (R\setminus P) minus the few terminals with too many edges touching P or fake edges gives |R’|\ge (1-1/\log n)|R|. One concludes that each piece G[V_i] is a (\varphi,R_i)-almost expander with large core R’_i. All of this holds with \tilde O(n^{5/3}) total queries.  


5.3 Sparsify the terminal set and recurse


Having the decomposition, build a smaller \tau-separated terminal set R_e by:

 Adding all R_i\setminus R’_i (few by construction),
 
 From each small part (very small core), pick one terminal from R’_i,
 
 From each large part, pick only 1+1/\varphi terminals from R’_i.
 


If no part has |\partial V_i|\le \tau, then |R_e|\ \le\ O\big(\varphi |R|\log^6 n\big)+ |R|/\log n, and one can show R_e remains \tau-separated. Choosing \varphi=1/\log^{10} n ensures |R_e|\le \tfrac12 |R|. Thus, either we already found a \le\tau cut (a part boundary) or we halve the terminal set while preserving separability. Depth is O(\log |R|)=\tilde O(1), and each level costs \tilde O(n^{5/3}) queries.  



6. Threshold theorem and global min-cut


Threshold version. For any \tau\le \delta-1, there is a deterministic \tilde O(n^{5/3})-query algorithm that either outputs a cut of size \le\tau or certifies the global min-cut >\tau. This follows by:
(i) computing a \tilde O(n/\delta)-size dominating set R in \tilde O(n) queries;
(ii) if an unbalanced \le\tau cut exists, finding it via isolating cuts; otherwise (iii) performing the terminal-aware expander decomposition to obtain a smaller \tau-separated R_e and recursing; a \le\tau cut is found at some level or ruled out. Overall queries: \tilde O(n^{5/3}).  

Global min-cut. Binary search over \tau (and handle the trivial \lambda=\delta case via a min-degree vertex) yields the exact global minimum cut in \tilde O(n^{5/3}) cut queries for simple unweighted graphs—the first deterministic subquadratic bound in this model.  



7. Implementation notes and scope


 Unit capacities via subdivision. Super-source/sink edges of capacity \tau+1 are realized by \tau+1 parallel subdivided unit edges, keeping the graph simple and only \tilde O(n) larger. This preserves the \tilde O(n^{5/3}) query bounds of the max-flow routine.  
 
 Why simplicity matters. The dominating-set separation lemma uses that every vertex in the “light” side of a small cut has degree \ge \delta with no parallel edges inflating capacity, so a \le \delta-1 cut cannot contain all of R on one side. Extending to weighted or non-simple graphs breaks this argument.  
 
 Weighted graphs. With integer capacities in [1,W], the s-t routine costs \tilde O(n^{5/3}W) queries; the global-min-cut framework continues to apply where the specialized flow instances remain of value \tilde O(nW).  
 




8. Complexity summary (deterministic, cut-query model)


 BIS simulation: 1 BIS on G_f \Rightarrow 3 cut queries on G. Neighborhood/BFS in \tilde O(n) queries.  
 
 Blocking flow iteration: \tilde O\big(n + \mathrm{dist}\cdot \mathrm{val}(f’)\big) queries; total \tilde O(n^{5/3}W).  
 
 Dominating set: size \tilde O(n/\delta) in \tilde O(n) queries.  
 
 Isolating cuts: either find an isolating cut \le\tau or certify >\tau in \tilde O(n^{5/3}) queries (for |R|=\tilde O(n/\tau)).  
 
 Expander decomposition (w.r.t. R): \tilde O(n^{5/3}) queries to obtain (\varphi,R)-almost expanders and \sum_{i\ne j}|E(V_i,V_j)|=O(\varphi|R|(\tau+1)\log^6 n).  
 
 Global min-cut: \tilde O(n^{5/3}) queries overall.

Checklist: 1. The answer should clearly define the cut-query model, including how a query is made and what information it returns.  
2. It should state the main goal: designing a deterministic algorithm for global min-cut using sub-quadratic queries, specifically ~O(n^(5/3)).  
3. The trivial baseline of reconstructing the whole graph in ~O(n^2) queries should be mentioned as a contrast.  
4. The solution must highlight that computing s–t max-flow of size ~O(n) with ~O(n^(5/3)) queries is the key subroutine.  
5. The algorithm should be explained as an adaptation of Dinitz’s blocking flow algorithm to the cut-query setting.  
6. The role of BIS queries and how they can be simulated with a constant number of cut queries should be described.  
7. There should be an explanation of how to construct BFS layers in the residual graph using only ~O(n) cut queries.  
8. The blocking flow procedure should be described, including its query complexity O(n + dist·val).  
9. The two-phase complexity analysis (short distance < n^(2/3) and long distance ≥ n^(2/3)) should be included to justify the ~O(n^(5/3)) bound.  
10. The answer should introduce the use of dominating sets, explain why every small cut must separate them, and how to compute such a set in ~O(n) queries.  
11. It should define isolating cuts, explain the bit-partition encoding trick, and show how this reduces the problem to ~O(log|R|) max-flow computations.  
12. The unbalanced vs balanced cases for small cuts should be distinguished, with isolating cuts handling the unbalanced case.  
13. The balanced case should be resolved using an expander decomposition tailored to the terminal set, implemented via the cut-matching game and expander pruning.  
14. The recursive framework that repeatedly halves the terminal set while preserving separability should be explained, ensuring depth O(log n).  
15. Finally, the overall result should be summarized: the first deterministic sub-quadratic algorithm for global min-cut and efficient cut-query implementations for isolating cuts and expander decomposition.