---
title: Liquid-Graph Time-Constant Network (LGTC)
url: https://www.emergentmind.com/topics/liquid-graph-time-constant-network-lgtc
type: topic
---

# Liquid-Graph Time-Constant Network (LGTC)

The Liquid-Graph Time-Constant (LGTC) Network is a continuous-time graph neural network (GNN) architecture designed for distributed control of multi-agent systems. Extending the single-agent Liquid Time-Constant (LTC) network to communication graphs, LGTC introduces agent-specific, input-driven time constants via graph-filtered gating, and provides both ODE-based and closed-form state evolution. Its core innovations include a stable, contractive update rule, communication-efficient message-passing, and empirical validation in large-scale flocking control tasks. 

## 1. Mathematical Formulation of the LGTC Layer

Given an undirected graph $\mathcal{G}=(\mathcal{V},\mathcal{E})$ of $N$ agents, each maintains a hidden state $x_i(t)\in\mathbb{R}^F$ and receives local input $u_i(t)\in\mathbb{R}^G$. The support matrix $S\in\mathbb{R}^{N\times N}$ encodes the (possibly time-varying) communication topology. 

The LGTC layer is governed by the following continuous-time ODE: 
\[
\begin{cases}
f(x,u,S) = \rho(\hat{A}_S(x) + b_x) + \rho(\hat{B}_S(u) + b_u), \\[6pt]
\dot{x} = -\left(b + f(x,u,S)\right)\circ x - \sum_{k=1}^K S^k x A_k + f(x,u,S)\circ \sigma_c(B_S(u)),
\end{cases}
\tag{1}
\label{LGTC-ODE}
\]
where:
- $\rho(\cdot)$ is the pointwise ReLU,
- $\sigma_c(\cdot)$ is the pointwise $\tanh$,
- “$\circ$” denotes the Hadamard product,
- $\hat{A}_S(x) = \sum_{k=0}^K S^k x \hat{A}_k$ and $B_S(u) = \sum_{k=0}^K S^k u B_k$ are graph filters of length $K$ with learned weight matrices,
- $b, b_x, b_u\in\mathbb{R}^{N\times F}$ are positive agent-wise bias maps.

Every hidden component $x_i^j$ is modulated by an adaptive “liquid time constant” $b_i^j + f_i^j(t)$ determined by graph-aggregated states and inputs.

## 2. Closed-Form LGTC Update

Integrating the stiff ODE over $[0,T]$ at each step is computationally expensive. A closed-form, single-step approximation, preserving the contraction rate, is constructed as follows:
\[
\begin{aligned}
f_\sigma &= \rho(\hat{B}_S(u)+b_u) + \rho(\hat{A}_S(x)+b_x), \\
f_x &= \rho(\hat{A}_S(x)+b_x), \\
f &= -D_x f\, \hat{A}_S(x) + \sum_{k=1}^K S^k x A_k/(x+\epsilon), \\
x^+ &= \left(x \circ \sigma\left(-[b+f_x+f]\,T+\pi\right) - \sigma_c(B_S(u))\right) \circ \sigma(2\,f_\sigma) + \sigma_c(B_S(u)).
\end{aligned}
\tag{2}
\label{LGTC-CF}
\]
where:
- $\sigma$ denotes the logistic sigmoid,
- $D_x f$ is the derivative of the ReLU term,
- $\epsilon\ll 1$ prevents division by zero,
- $\pi\approx 1$ is a small stabilizing constant.

This update yields $x^+\approx x(T)$ in a single communication round, with a contraction rate matching that of the ODE.

## 3. Stability via Contraction Analysis

The stability of the LGTC system is grounded in contraction theory. The induced $\infty$-log-norm is defined as
\[
\mu_\infty(M) = \max_i\left\{M_{ii} + \sum_{j\ne i} |M_{ij}|\right\}.
\]
A vector field $F(x,u,S)$ is $c$-contractive if
\[
\mu_\infty(D_x F(x,u,S)) < -c,\quad c>0.
\tag{3}
\label{contract}
\]

**Theorem (δISS of LGTC–ODE):**  
Under bounded $S$-norm and $b\ge 0$, if
\[
c = \|b\|_\infty + \|A_{1:K}\|_\infty\,\|\tilde{S}_{1:K}\|_\infty + \|b_x\|_\infty - \|\hat{A}_{0:K}\|_\infty\,\|\bar{S}_{0:K}\|_\infty > 0,
\]
then, for all solutions $x_1(t)$, $x_2(t)$ with the same $S$ but different inputs or initial states,
\[
\|x_1(t)-x_2(t)\|_\infty \le e^{-ct}\|x_1(0)-x_2(0)\|_\infty + \frac{\ell_u}{c}(1-e^{-ct})\sup_{\tau\le t}\|u_1-u_2\|_\infty + \frac{\ell_S}{c}(1-e^{-ct})\sup_{\tau\le t}\|S_1-S_2\|_\infty.
\tag{4}
\]
Thus, the LGTC dynamics are incrementally input-to-state stable (δISS) under suitable norm bounds on graph filter weights and biases.

A supporting lemma states: if $b>0$ and all $A_k^T\otimes S^k\ge 0$, then $\|x(t)\|_\infty\le 1$ whenever $\|x(0)\|_\infty\le 1$.

## 4. Communication-Efficient Message Passing

LGTC achieves communication efficiency through selective message broadcasting: each agent communicates only a subset $F'\ll F$ of its hidden features, and only $G'\ll G$ input channels if required. The graph filter $\sum_{k=0}^K S^k x H_k$ is computed with $K$ successive 1-hop exchanges; lowering $F'$ reduces per-edge payload. The adaptive time-constant term $f_i(t)$ is locally computable without exchanging additional gating variables, unlike in standard GNNs (e.g., GGNN) where all hidden and gate vectors are broadcast. This design constrains per-step communication to $\mathcal{O}(|\mathcal{E}| F')$.

## 5. Empirical Evaluation in Flocking Control

The LGTC network is evaluated in decentralized flocking, modeling agents as double-integrators in $\mathbb{R}^2$, updated discretely as $r(t+1)=r(t)+T v(t)$, $v(t+1)=v(t)+T u(t)$ with $T=0.05$ s. Communication links are determined by proximity ($\|r_i-r_j\|_2\le R$), with $R$ and team size $N$ varied across experiments. The centralized expert implements a leader-follower control policy based on global velocity averaging and collision avoidance.

Each agent receives a $10$-dimensional input vector, processes it through a single LGTC (or alternative) layer (hidden size $F=50$, filter length $K=2$, $F'=4$ communicated dims), and outputs control via a readout MLP. All models are regularized for contraction using a Softplus penalty.

Training follows the DAGGER paradigm over 60 expert trajectories, with the Adam optimizer, and mean-squared error loss between predicted and expert controls.

**Results:**
- **Scalability:** For $R=4$ m, LGTC and its closed-form variant (CfGC) reduce flocking error by $\sim$30–40% and leader error by $\sim$10% compared to GGNN, while GraphODE performs worst. LGTC/CfGC performance is near-identical, confirming closed-form fidelity.
- **Communication Range Robustness:** All methods degrade at $R=2$ m, flocking improves for $R=8$ m but leader tracking worsens. LGTC/CfGC maintain closest adherence to expert policy under range variation.
- **Communication efficiency:** LGTC/CfGC outperform or match baselines with dramatically fewer exchanged features.

| Model          | Mean Flocking Error | Leader Tracking Error | Comm. Dims per Edge |
|----------------|--------------------|----------------------|---------------------|
| LGTC/CfGC      | Lowest             | Lowest               | $F'=4$              |
| GGNN           | Higher             | Higher               | $F\gg 4$            |
| GraphODE       | Highest            | Highest              | $F\gg 4$            |

## 6. Implementation Details and Hyperparameters

One step of the discrete (closed-form) LGTC update is:

```python
# Inputs: x [N×F], u [N×G], S [N×N], params, Δt, ε, π
Âx  = sum_k(S**k * x * Â_k)
B̂u = sum_k(S**k * u * B̂_k)
BSu = sum_k(S**k * u * B_k)
Ax  = sum_k(S**k * x * A_k, k=1..K)
f_sigma = ReLU(B̂u+b_u) + ReLU(Âx+b_x)
f_x = ReLU(Âx+b_x)
Df = derivative of ReLU(Âx+b_x)
f = - (Df ∘ x)/(x+ε) * Âx + Ax
tau = -(b + f_x + f) * Δt + π
stau = sigmoid(tau)
s2 = sigmoid(2*f_sigma)
s = tanh(BSu)
x_plus = (x ∘ stau - s) ∘ s2 + s
```

Key hyperparameters include hidden size $F$, communicated dims $F'$, filter length $K$, step $\Delta t$, bias initializations $b$, $b_x$, $b_u$, and contraction margin in the Softplus regularization.

## 7. Significance and Context

LGTC advances multi-agent control by enabling each agent’s state evolution to depend adaptively on both local and graph-filtered signals, via liquid time constants. The closed-form update achieves the expressivity of continuous-time dynamics with the computational tractability and communication frugality needed for large-scale distributed deployment. LGTC consistently outperforms discrete models in challenging flocking control tasks, with strong theoretical stability guarantees grounded in contraction analysis. These properties position LGTC as a theoretically principled and practically scalable approach to distributed learning and control on graphs [2404.13982].

Source: https://www.emergentmind.com/topics/liquid-graph-time-constant-network-lgtc