Logic Network Flow Framework

• Logic Network Flow (LNF) is an optimization-based planning framework that encodes temporal logic as edge-based polyhedral constraints in directed acyclic graphs.
• It uses a network-flow model with flow conservation to tightly couple logic predicates and enhance convex relaxation quality compared to traditional Logic Tree approaches.
• Empirical results demonstrate LNF's superior performance in root gap reduction, solution speed, and memory use, validated through dynamic planning and hardware experiments.

Logic Network Flow (LNF) is an optimization-based task and motion planning framework that integrates temporal logic specifications into mixed-binary linear programs and mixed-integer programs by encoding temporal predicates as polyhedron constraints on the edges of a network-flow model rather than as constraints between nodes in traditional Logic Tree formulations. In this representation, a directed acyclic graph carries a source-to-target unit flow whose traversal encodes satisfaction of the logic formula, and the edge-centric coupling induced by flow conservation yields tighter convex relaxations than conventional Logic Tree encodings for a range of robot planning problems (Lin et al., 2024, Lin et al., 29 Sep 2025).

1. Emergence of the framework

The initial arXiv formulation presents LNF as a method for optimization-based task and motion planning under Signal Temporal Logic (STL) specifications. Its central motivation is the weakness of Logic Tree (LT) encodings in mixed-binary optimization: in LT, temporal predicates are attached to nodes, and logical relations are enforced by constraints between parent and child nodes, which can produce loose convex relaxations and slow branch-and-bound search as formulas grow in size (Lin et al., 2024).

The later refinement generalizes the same idea as an optimization-based task and motion planning framework that integrates temporal logic specifications into mixed-integer programs, explicitly stating inspiration from the Graph-of-Convex-Sets formulation. The defining shift is that temporal predicates are encoded as polyhedron constraints on each edge of a network-flow model, not as constraints between nodes in Logic Tree formulations. This edge-based encoding is intended to make the logic and the flow structure coincide, so that logical alternatives are represented as alternative paths in a directed acyclic graph rather than as decoupled branches of a parse tree (Lin et al., 29 Sep 2025).

A persistent theme across both formulations is that LNF is not merely a syntactic reformulation of a Logic Tree. The network-flow structure couples predicates across alternatives through flow conservation, and that coupling is the stated source of tighter convex relaxations. This point is central to the theoretical and empirical claims associated with the framework (Lin et al., 2024, Lin et al., 29 Sep 2025).

2. Edge-based logic encoding

In the 2025 formulation, LNF constructs a directed acyclic graph from the logic formula, and edges, rather than nodes, are labeled with sets of predicates, possibly negated, that must be satisfied to traverse the edge. The network represents all possible logical execution paths, and a unit flow from source to target vertex traces a scenario in which the temporal logic is satisfied. For an edge $e$, the associated polyhedral constraint is written as

$$\begin{align*} \boldsymbol{\omega}_e &\geq y_e \boldsymbol{v}_e^+ \ \boldsymbol{\omega}_e &\leq \mathbf{1}_{|\Pi|} - y_e \boldsymbol{v}_e^- , \end{align*}$$

where $y_e \in \{0,1\}$ indicates whether the edge is traversed, $\boldsymbol{\omega}_e$ is the flow for each atomic predicate, and $\boldsymbol{v}_e^+$, $\boldsymbol{v}_e^-$ encode non-negated and negated predicate requirements on that edge. At the source vertex,

$$\boldsymbol{z}^\pi = \sum_{e \in \text{out}(v_s)} \boldsymbol{\omega}_e ,$$

and flow conservation at interior vertices enforces the temporal sequencing induced by the formula (Lin et al., 29 Sep 2025).

The earlier formulation describes the same structure in STL-specific terms. An LNF is defined as a tuple $(\mathcal{G}, \mathcal{P}, \Pi, \tau)$, where $\mathcal{G}=(\mathcal{V},\mathcal{E})$ is a directed acyclic graph with source $v_s$ and target $$\begin{align*} \boldsymbol{\omega}_e &\geq y_e \boldsymbol{v}_e^+ \ \boldsymbol{\omega}_e &\leq \mathbf{1}_{|\Pi|} - y_e \boldsymbol{v}_e^- , \end{align*}$$0, $$\begin{align*} \boldsymbol{\omega}_e &\geq y_e \boldsymbol{v}_e^+ \ \boldsymbol{\omega}_e &\leq \mathbf{1}_{|\Pi|} - y_e \boldsymbol{v}_e^- , \end{align*}$$1 is the set of STL predicates, $$\begin{align*} \boldsymbol{\omega}_e &\geq y_e \boldsymbol{v}_e^+ \ \boldsymbol{\omega}_e &\leq \mathbf{1}_{|\Pi|} - y_e \boldsymbol{v}_e^- , \end{align*}$$2 assigns to each edge $$\begin{align*} \boldsymbol{\omega}_e &\geq y_e \boldsymbol{v}_e^+ \ \boldsymbol{\omega}_e &\leq \mathbf{1}_{|\Pi|} - y_e \boldsymbol{v}_e^- , \end{align*}$$3 a set of predicates $$\begin{align*} \boldsymbol{\omega}_e &\geq y_e \boldsymbol{v}_e^+ \ \boldsymbol{\omega}_e &\leq \mathbf{1}_{|\Pi|} - y_e \boldsymbol{v}_e^- , \end{align*}$$4, and $$\begin{align*} \boldsymbol{\omega}_e &\geq y_e \boldsymbol{v}_e^+ \ \boldsymbol{\omega}_e &\leq \mathbf{1}_{|\Pi|} - y_e \boldsymbol{v}_e^- , \end{align*}$$5 carries times associated to predicates. Conjunction is encoded by serially chaining sub-flows, while disjunction is encoded by parallel branches. Predicate feasibility on an edge is expressed by a polyhedral constraint

$$\begin{align*} \boldsymbol{\omega}_e &\geq y_e \boldsymbol{v}_e^+ \ \boldsymbol{\omega}_e &\leq \mathbf{1}_{|\Pi|} - y_e \boldsymbol{v}_e^- , \end{align*}$$6

and both binary activation variables and predicate-flow variables obey conservation constraints at each vertex (Lin et al., 2024).

The 2025 paper also gives an explicit binary implication constraint for edge traversal: $$\begin{align*} \boldsymbol{\omega}_e &\geq y_e \boldsymbol{v}_e^+ \ \boldsymbol{\omega}_e &\leq \mathbf{1}_{|\Pi|} - y_e \boldsymbol{v}_e^- , \end{align*}$$7 This expresses that an edge can be activated only if all predicates attached to that edge are satisfied with the required polarity. A plausible implication is that the edge itself becomes the atomic carrier of both logical and geometric feasibility, which is why the formulation aligns well with path-planning interpretations (Lin et al., 29 Sep 2025).

3. Projection and convex-relaxation tightness

A major refinement of LNF is a network-flow-based Fourier-Motzkin elimination procedure that removes auxiliary continuous flow variables while preserving convex relaxation tightness. The starting point is that basic LNF introduces many continuous flow variables $$\begin{align*} \boldsymbol{\omega}_e &\geq y_e \boldsymbol{v}_e^+ \ \boldsymbol{\omega}_e &\leq \mathbf{1}_{|\Pi|} - y_e \boldsymbol{v}_e^- , \end{align*}$$8, which can be computationally expensive. The elimination recursively combines flow-conservation constraints and edge polyhedral constraints to produce inequalities involving only binary edge activations $$\begin{align*} \boldsymbol{\omega}_e &\geq y_e \boldsymbol{v}_e^+ \ \boldsymbol{\omega}_e &\leq \mathbf{1}_{|\Pi|} - y_e \boldsymbol{v}_e^- , \end{align*}$$9 and predicate variables $y_e \in \{0,1\}$0. Representative projected constraints include

$y_e \in \{0,1\}$1

The result is stated to have fewer constraints and fewer continuous variables while encapsulating exactly the same feasible set, and the paper states that the tightness of the root LP relaxation is preserved (Lin et al., 29 Sep 2025).

The same paper states that Theorem 1 and a lemma in the appendix prove that the projected constraints yield a convex relaxation strictly tighter than the equivalent Logic Tree formulation, and at least as tight as the original network-flow version. It also states that the method handles general logic forms, while being especially tight for specifications in conjunctive-disjunctive normal form (Lin et al., 29 Sep 2025).

A compact comparison reported in the paper is:

Method	Root Gap	Solve Time
LT (Logic Tree)	30–60%	Baseline
LNF (without F-M)	10–25%	2–10x Faster
LNF (with F-M)	6–18%	10–40x faster

These figures summarize the stated effect of moving from node-based logic constraints to edge-based network flow, and then further projecting out continuous flow variables. The papers treat relaxation quality, not logical expressiveness, as the main differentiator between LT and LNF (Lin et al., 29 Sep 2025).

4. Coupling with system dynamics

In the 2024 formulation, LNF is synthesized with Dynamic Network Flows. System behavior is described by discrete-time dynamics

$y_e \in \{0,1\}$2

and an STL predicate $y_e \in \{0,1\}$3 at time $y_e \in \{0,1\}$4 is represented by a binary variable $y_e \in \{0,1\}$5 linked to a linear threshold condition on $y_e \in \{0,1\}$6. The dynamic feasibility of trajectories is represented by a separate flow problem on a time-indexed network, and predicate variables synchronize the dynamic flow with the logic flow. The complete mixed-binary linear program minimizes a cost over dynamic-network-flow variables $y_e \in \{0,1\}$7 subject to LNF constraints, dynamic-network-flow constraints, and predicate-coupling constraints (Lin et al., 2024).

This coupling is important because it distinguishes LNF from purely logical encodings. The logic network does not by itself plan motion; it is integrated with a dynamic feasibility layer. The 2025 formulation states explicitly that the method applies to temporal logic motion planning with piecewise-affine dynamic systems, and its experiments include vehicle routing, multi-robot coordination, and temporal logic control on dynamical systems using point mass and linear inverted pendulum models (Lin et al., 29 Sep 2025).

The final optimization model in the 2025 account consists only of dynamics variables, binary predicate indicators, edge variables, and polyhedral constraints derived via Fourier-Motzkin elimination. This suggests that the mature form of the framework is a projected hybrid formulation in which the logical network is retained structurally, but superfluous continuous logic-flow variables are removed (Lin et al., 29 Sep 2025).

5. Empirical behavior, scaling, and hardware validation

The empirical results reported for LNF emphasize root-relaxation quality, branch-and-bound efficiency, and scaling. The 2024 study reports root relaxation gaps of $y_e \in \{0,1\}$8 for LNF versus $y_e \in \{0,1\}$9 for LT, and states that LNF requires exploring $\boldsymbol{\omega}_e$0-$\boldsymbol{\omega}_e$1 orders of magnitude fewer branch-and-bound nodes for the same quality of upper and lower bounds. Specific examples include $\boldsymbol{\omega}_e$2 nodes for LNF versus $\boldsymbol{\omega}_e$3 for LT on one task, and $\boldsymbol{\omega}_e$4 versus $\boldsymbol{\omega}_e$5 on a more complex task (Lin et al., 2024).

The 2025 study reports that LNF achieves root relaxation gaps $\boldsymbol{\omega}_e$6–$\boldsymbol{\omega}_e$7x smaller than LT, with examples such as $\boldsymbol{\omega}_e$8 for LNF versus $\boldsymbol{\omega}_e$9-$\boldsymbol{v}_e^+$0 for LT. It reports that in Dynamic Network Flow planning scenarios LNF solves globally optimal plans $\boldsymbol{v}_e^+$1–$\boldsymbol{v}_e^+$2x faster than LT, and that for large multi-robot or Vehicle Routing problems LNF found feasible solutions $\boldsymbol{v}_e^+$3x faster and proved optimality significantly faster, up to $\boldsymbol{v}_e^+$4x, than LT. The same study reports $\boldsymbol{v}_e^+$5–$\boldsymbol{v}_e^+$6 lower memory usage for the reduced formulation (Lin et al., 29 Sep 2025).

The same evidence base also makes clear that tighter relaxation is not identical to uniformly lower total computation time. The 2024 paper states that as the problem size scales up, LNF discovers better lower and upper bounds by exploring fewer number of nodes during branch-and-bound, although this comes at the cost of increased computational load for each node when exploring branches. The 2025 paper similarly notes that LNF without Fourier-Motzkin elimination is not always better at large scale because of the burden of continuous variables, and that when dynamics are the main bottleneck, as in linear inverted pendulum walking, total speedups are more modest, $\boldsymbol{v}_e^+$7–$\boldsymbol{v}_e^+$8x, and may saturate if the logic is not the computational bottleneck (Lin et al., 2024, Lin et al., 29 Sep 2025).

Hardware demonstrations are a prominent part of the later presentation. The 2025 paper reports hardware demonstrations with quadrupedal robots that validate real-time replanning capabilities under dynamically changing environmental conditions, and specifically states that Unitree quadruped robots were able to switch goals or re-route around obstacles detected in real time with full STL specifications encoded via LNF (Lin et al., 29 Sep 2025).

6. Related research and terminological boundaries

Within adjacent arXiv literature, LNF sits among several efforts that combine logic with graph or flow structure, but these efforts are methodologically distinct. TeLoGraF, for example, encodes general STL specifications as graphs processed by a Graph Neural Network and uses flow matching to learn conditional generative models for satisfying trajectories. It is reported to be $\boldsymbol{v}_e^+$9-$\boldsymbol{v}_e^-$0X faster in inference than classical STL planning algorithms and to work on any system dynamics, but it is a learned planning pipeline rather than a mixed-integer network-flow encoding of logic (Meng et al., 1 May 2025).

A second nearby line is flow-based synthesis of reactive tests from temporal logic specifications. That framework uses Deterministic Büchi Automata, product graphs, and a mixed-integer linear program over a virtual product graph to synthesize minimally restrictive reactive test strategies for discrete decision-making systems. Here the role of network flow is to restrict system actions so that any path from source to target must also satisfy a test objective, which is conceptually related to LNF’s use of source-to-target flow but directed toward testing rather than task and motion planning (Graebener et al., 2024).

A broader logical context is provided by “Flow Logic,” which introduces BFL*, a modal logic in which flow functions are explicit first-order objects and atomic assertions can refer to flow values such as $\boldsymbol{v}_e^-$1 or $\boldsymbol{v}_e^-$2. BFL* is concerned with specification and model checking over flow networks, not with constructing planning MILPs, but it shows that the interaction of logic and flow has also been developed as a verification language (Kupferman et al., 2018).

Research on Boolean and logical networks is also adjacent but separate. “Data-based control of Logical Networks” studies Boolean Control Networks and gives necessary and sufficient data-based conditions for state feedback stabilization, safe control, and output regulation without identifying the underlying model. That work is stated to be suited for biological networks, smart infrastructure, social networks, and network flow problems where full models are difficult to identify, yet its object is control of Boolean dynamics rather than temporal-logic task and motion planning (Disarò et al., 16 May 2025).

Taken together, these neighboring lines indicate that the distinctive meaning of Logic Network Flow is the edge-based encoding of temporal logic inside a network-flow optimization model for planning. Other arXiv uses of logic-plus-flow emphasize learning, testing, verification, or Boolean-network control rather than the specific convex-relaxation agenda that defines LNF (Lin et al., 2024, Lin et al., 29 Sep 2025).