Local Topology Slicing (LTS) Overview

• Local Topology Slicing (LTS) is a class of algorithms that isolates and manipulates local substructures in graphs and scalar fields to enable robust and scalable learning.
• Techniques include generating subgraphs for power systems and localized flattening in scalar field analysis to improve model generalization and computational efficiency.
• LTS significantly enhances performance, with error reductions up to 50% in power systems and speedups of up to 36× in parallel topological data analysis.

Local Topology Slicing (LTS) encompasses a class of algorithmic techniques that perform localized operations on graphs or scalar fields to facilitate robust learning or simplification under varying topological scenarios. Prominent implementations span data-augmentation for power system analysis and topological simplification in data analysis pipelines. The common thread is the isolation and manipulation of local substructures within a global system to enhance scalability, adaptability, or computational efficiency.

1. Formal Definitions and Problem Setting

The methodology of LTS is instantiated in at least two major contexts:

• In power systems, given a complete power-system graph $G = (B, E)$ (nodes $B$ representing buses and edges $E$ representing branches), LTS generates a family of connected subgraphs $G_{sk} = (B_{sk}, E_{sk})$ for $k = 1 \ldots M$, where $B_{sk} \subset B$ are chosen to satisfy prescribed size and connectivity constraints. These slices are treated as standalone "mini-systems" for training machine learning models for power flow prediction; boundary effects are controlled by converting external tie flows into equivalent PQ-loads on slice boundaries, with further random perturbations and line outages to enhance diversity (Li et al., 4 Jan 2026).
• In scalar field analysis, for a piecewise-linear manifold $M$ and scalar field $f: M \to \mathbb{R}$, LTS refers to the Localized Topological Simplification process. Here, the field is simplified locally by flattening sub- or superlevel set components associated with undesired extrema, with the guarantee that only user-selected extrema remain after simplification. This procedure is realized through local orderings, region-wise flattenings, and parallel recombination into a globally consistent field $g$ (Lukasczyk et al., 2020).

2. Algorithmic Frameworks

2.1 LTS for Power Systems

LTS in the SaMPFA framework follows a reproducible routine:

Input: G=(B,E), P_full, s_min,s_max, M, p_perturb,q_perturb, r_outage Output: {(G_sub^k, P_sub^k, Q_sub^k)}_{k=1…M} for k = 1 to M do 1. Sample target size s ~ Uniform({s_min,…,s_max}) 2. Pick random generator bus b₀ as seed 3. Build B_sub via BFS/DFS from b₀ until |B_sub| = s 4. Build E_sub: edges internal to B_sub 5. For boundary edges (i,j), add their P/Q flows to PQ-load at i; remove these edges 6. Perturb internal loads by ±p_perturb% / q_perturb%; randomly outage up to r_outage branches 7. Solve AC power flow on (G_sub, E_sub) to get labels 8. Store (G_sub, P_sub, Q_sub, V_sub, θ_sub) end for

Key constraints include enforcing subgraph connectivity, ensuring at least one generator bus per slice, and carefully handling boundary ties to preserve physical consistency.

2.2 LTS for Scalar Field Simplification

For a field $f$ on a mesh $M$, LTS operates as follows:

1. Construct an injective integer "order field" based on $f$.
2. Identify regions to be simplified via superlevel (for maxima) or sublevel (for minima) set propagations rooted at undesired extrema.
3. For each region, perform a local reordering (flattening) such that only designated saddles or minima/maxima are preserved, applying min–max flooding adapted for the confined region.
4. Embed local reorders into a global ordering using composite keys and parallel sorting.
5. Reconstruct the simplified scalar field $g$ in real space, preserving global order and proximity to $f$.

The process is output-sensitive and highly parallelizable, with critical correctness guarantees for extremum removal (Lukasczyk et al., 2020).

3. Statistical Properties and Hyperparameters

In power systems data augmentation, subgraph size $s$ is sampled from a target distribution, commonly uniform over $[s_{\min}, s_{\max}]$, e.g., $s_{\min} \approx 0.4N$, $s_{\max} \approx 1.1N$ for $N$-bus systems. Main hyperparameters include:

• $s_{\min}, s_{\max}$: limits on slice size—too small erodes physical context, too large reduces topological variability.
• $M$: number of slices per scenario; linearly increases coverage.
• $p_\mathrm{perturb}, q_\mathrm{perturb}$: perturbation ratios (e.g., $\pm20\%$); regulate overfitting vs. instability.
• $r_\mathrm{outage}$: number of random branch outages per slice; injects topological variation.

The dependence of generalization on $s_\mathrm{range}$ is weak for modest variations, provided the training slice scale distribution covers likely test system sizes.

For scalar field simplification, the main controls are the set of extrema to preserve, persistence thresholds in the persistence-driven variant, and implementation choices for region propagation and sorting.

4. Computational Complexity and Parallelism

LTS is computationally efficient in both usage domains:

• For power system slicing: per-slice cost is $O(s_\mathrm{sub} (1 + E/N))$ for BFS, boundary handling, and perturbations. In practice, millions of slices on a 39-node, 46-edge graph are generated within tens of seconds on a modern CPU (Li et al., 4 Jan 2026).
• For scalar field simplification: region-wise propagations and local flattenings run in $O(|R| \log |R|)$ per region, with total cost $O(k \log k)$ for $k \ll |V|$ affected vertices and $O(|V| \log |V|)$ worst-case (Lukasczyk et al., 2020). The algorithm is output-sensitive, and embarrassingly parallel across regions, achieving up to $36\times$ speedups and $70\%$ parallel efficiency on 12-core machines.

5. Empirical Results and Practical Impact

Power Systems

• Exposing GNN-based models to a wide distribution of slice topologies dramatically improves their cross-scale generalization.
• On the IEEE-39 test case, LTS raises Gen-U (upscaled test set) accuracy from $66\%$ to $82.4\%$, reducing maximum prediction errors on system expansions by 40–50%.
• On a 300–690 bus provincial grid, error reductions of 48.3–71.7% are reported across voltage, angle, branch-power, and unbalanced-power metrics, with overall accuracy elevated from $90.7\%$ to $97.98\%$ (Li et al., 4 Jan 2026).
• LTS thus acts as a "multi-scale graph generator," mitigating distributional shift as network scale or topology evolves.

Scalar Field Simplification

• LTS achieves $3\times$–$8\times$ speedup sequentially and $20\times$–$36\times$ parallel speedup over global methods in practice.
• Persistence-driven specialization further accelerates pipelines by $2\times$–$3\times$.
• Enables interactive exploration of topological parameters as pre-processing for contour-tree or Morse–Smale complex extraction (Lukasczyk et al., 2020).

6. Illustrative Examples

Power Systems:

In the IEEE-39 application, LTS generates:

• A 12-bus slice (seeded at bus 17)
• A 20-bus slice (seeded at bus 22)
• A 30-bus slice (seeded at a generator bus 5)

Each slice is processed with boundary tie adjustments and two internal branch outages, with $\pm20\%$ load perturbations. All produce physically valid AC power flow cases, greatly expanding the diversity of training scenarios and enhancing model robustness (Li et al., 4 Jan 2026).

Scalar Field Simplification:

Example on a 9-vertex chain: removing a spurious bump at 13 via flattening the region to its saddle at 10 yields a field with only the designated maximum retained, with $\|f-g\|_\infty=3$. On a $3\times3$ grid, flattening corners yields a single preserved maximum at the center, fully eliminating undesired local extrema (Lukasczyk et al., 2020).

7. Applications and Significance

LTS has demonstrated central utility in:

• Robust machine learning for power grid analysis, enabling scale-invariant inference and broader operational adaptability. Within SaMPFA, LTS is a core element supporting Reference-free Multi-task Graph Learning (RMGL) and alleviating distributional shift in GNN workflows (Li et al., 4 Jan 2026).
• High-performance, interactive topological data analysis (TDA) pipelines, where it drastically reduces end-to-end computational cost for scalar field simplification, persistence diagram computation, and subsequent contour or Morse–Smale extraction (Lukasczyk et al., 2020).

A plausible implication is that the general paradigm of local decomposition and targeted modification, as implemented in LTS, is extensible to related combinatorial, physical, or geometric systems desiring localized augmentation, simplification, or adaptation.