Modular Complexity Analysis

Updated 28 December 2025

Modular Complexity Analysis is a compositional framework that decomposes programs into submodules, enabling localized analysis of runtime or derivation bounds.
It employs techniques such as ranking function synthesis, recurrence solving, and matrix interpretations to analyze integer, recursive, probabilistic, and term rewriting systems.
The approach facilitates efficient proof reuse and iterative refinement, yielding up to 15–20% performance improvements over traditional monolithic methods.

A modular complexity analysis approach is a compositional framework for inferring tight, sound upper bounds on the resource usage (typically, runtime or derivation length) of programs or rewriting systems by decomposing them into subprograms or subsystems, applying complexity analyses locally, and systematically combining the resulting local bounds to obtain global complexity guarantees. This paradigm originated in term rewriting and has become central in automated complexity analysis for integer programs (including non-linear, recursive, and probabilistic systems), graph problems, logics, and constraint satisfaction problems.

1. General Principles and Formal Structure

A modular approach is characterized by the following key features:

Decomposition into subprograms or modules: The program is partitioned (often by control-flow graph strongly connected components, recursion nestings, or syntactic splitting in rewrite systems) into subprograms suitable for specialized analysis.
Computation of local bounds: Each subprogram is analyzed in isolation using a method tailored to its syntactic or semantic structure; for example, applying ranking function synthesis on affine loops, solving recurrences for triangular weakly non-linear loops (twn-loops), or employing match-bounds and matrix interpretations in term rewriting.
Lifting/composition of local to global bounds: Local resource bounds are lifted (“composed”) into a global bound via an algebraic rule that tracks how subprograms are invoked by the whole system, incorporating the effect of variable growth across program call-sites, loop entries, or modular boundaries.
Alternation or refinement: In many frameworks, size-bound and runtime-bound inference are alternated, with improved size-bounds feeding into tighter runtime analyses and vice versa, until fixed-point.
Soundness and completeness: There are formal theorems guaranteeing both that local soundness is preserved globally by the lifting rules, and that, for large fragments of programs (e.g., twn-loops, prs-loops), the approach is algorithmically complete.

This approach stands in contrast to "monolithic" methods that apply a single global complexity criterion to the entire system, frequently resulting in less tight bounds or outright failure on complex or hybrid systems.

2. Modular Complexity for Integer and Recursive Programs

The state-of-the-art modular framework for integer programs is exemplified by the KoAT tool family (Giesl et al., 2022, Lommen et al., 2022, Lommen et al., 2023, Lommen et al., 15 Nov 2024, Lommen et al., 21 Dec 2025). The main algorithmic steps are:

Program Model and Decomposition

An integer program is modeled as a finite set of program locations $L$ , integer variables $V$ , and transitions $T$ of the form $(\ell, \text{guard}, \text{update}, \ell')$ . For recursion, the model extends to recursive integer transition systems (rec-ITS) including function calls and returns (Lommen et al., 21 Dec 2025).
The control-flow graph is decomposed into strongly connected components (SCCs), and nested subprograms are identified (loops, cycles, recursive procedures).

Local Bound Synthesis

For each SCC or subprogram $T'$ , the system attempts to synthesize a ranking function (linear, multiphase, or $\rho$ -ranking for recursion (Lommen et al., 21 Dec 2025)), solve recurrence equations (as for twn-loops (Lommen et al., 2022, Lommen et al., 2023)) or closed forms (as for periodic rational solvable loops (Lommen et al., 15 Nov 2024)), or apply custom analyses (e.g., logarithmic bounds for certain geometric loops).
For instance, in the twn-loop case, closed forms for the variable updates are derived, and a stabilization threshold (polynomial or logarithmic) is inferred such that the loop guard remains false after this threshold, yielding a tight local bound on iterations (Lommen et al., 2022).
In recursive settings, $\rho$ -ranking functions are constructed to track progress across nested calls, with parameters $r_d, r_{tf}, r_f$ bounding the non-recursive, recursive transition, and recursive function call components, respectively (Lommen et al., 21 Dec 2025).

Size Bound Inference

In parallel, size-bounds are computed for each program variable after each transition, propagating bounds through a result-variable dependency graph, and combining them via algebraic or inductive methods.

Lifting Local to Global Bounds

Lifting is formalized by rules such as:

For each transition $t$ in the subprogram $T'$ , the global bound is set as:

$G(t) := \sum_{r \in E_{T'}} G(r) \cdot \text{RB}(t)[v \mapsto \text{SB}(r, v)]$

where $E_{T'}$ are the entry transitions, $G(r)$ are global bounds for entries, and $\text{SB}(r,v)$ the size-bound substitutions for inputs (Lommen et al., 2022, Lommen et al., 21 Dec 2025, Lommen et al., 15 Nov 2024).

For recursive calls, additional summations over function entries and careful substitution of argument bounds are performed (Lommen et al., 21 Dec 2025).

This modular lifting principle aligns with the method from modular term rewriting (Zankl et al., 2014), which uses relative rewriting as the basis for modularly combining complexity measures proved on subsystems.

3. Modular Approaches in Term Rewriting, Probabilistic Programs, and SAT/Logic

Term Rewriting Systems (TRS)

Relative rewriting: Analyze a TRS as a pair $(\mathcal{R},\mathcal{S})$ and use matrix interpretations on components, match-bounds for linear fragments, and complexity pairs to obtain bounds. These techniques modularly combine to infer complexity of the union via tight asymptotic equivalences and gap principles (Zankl et al., 2014).
The framework supports a strictly broader class of systems than “single-method” approaches, because it exploits module-wise heterogeneity and proof-tightening across splits.

Probabilistic and Non-deterministic Programs

The expected runtime of probabilistic While programs is bounded modularly by constructing syntactic expectation transformers $E_c[\cdot]$ that are monotone and $\omega$ -continuous, and composing bounds by propagation of size transformers and cost-bound functions through program structure (Avanzini et al., 2019). Modular soundness is guaranteed by induction over program composition and loop invariants.

Modular Reductions for Model Checking and CSP

Modular reductions are systematically used to encode model checking, enumeration, and counting for logics with team semantics into modules for propositional SAT of special classes (horn, 2-CNF, dual-horn) (Durand et al., 2022). This achieves tight P/NL tractability boundaries for expressive logics by modularizing the syntactic/semantic structure.
In counting and modular CSPs, “modular complexity” refers to the stratified analysis of solution counting and operational hardness via automorphism, rigidity, and rectangularity properties, decomposing CSPs into binary, rectangular forms for reduction and tractability/hardness analysis (Kazeminia et al., 8 Jan 2025, Brakensiek et al., 2019).

4. Worked Example: Integer Programs via Modular Twn-Loop Analysis

A detailed example highlights the modular workflow (Lommen et al., 2023, Lommen et al., 2022):

Consider a program with cycles and a non-linear self-loop. Each SCC is isolated:
- The branching cycle admits a linear ranking function, giving a bound $x_4$ .
- The twn-loop self-loop (with $x_1^2 + x_3^5 < x_2 \wedge x_1 \neq 0$ ) is analyzed by recurrence closure and stabilization (e.g., $x_1(n)=4^n x_1$ ), yielding a polynomial local bound (e.g., $2 x_2 + 1$ ).
- Global bounds are composed as per the entry structure and size-bounds (e.g., $G(t_3) = x_4 \cdot (2 x_5 + 1)$ ).
The approach is complete and sound on the twn-loop fragment and scales via topological SCC ordering (Lommen et al., 2022).

A simplified global lifting formula used throughout modular integer program analysis is:

Subprogram	Local Bound	Entry Bound	Global Bound
$T'$	RB(t)	$G(r)$	$G(t)=\sum_r G(r)\cdot RB(t)[v\mapsto SB(r,v)]$

5. Soundness, Completeness, and Empirical Performance

Soundness: Modular approaches maintain that if each local bound is sound (e.g., by ranking function synthesis, closed-form thresholding, or expectation transform monotonicity), then the lifted global bound is also sound, as is proved inductively (Giesl et al., 2022, Lommen et al., 21 Dec 2025, Lommen et al., 15 Nov 2024).

Completeness: For certain classes (e.g., twn-loops, prs-loops, modular TRS), the approach is algorithmically complete, able to synthesize exact polynomial or logarithmic bounds whenever the system admits one (Lommen et al., 15 Nov 2024, Lommen et al., 2022).

Empirical Results: Experimental studies on large benchmarks (e.g., Termination Problem Database, CINT/CITS, and rec-ITS extensions) show that modular frameworks implemented in tools like KoAT strictly dominate previous approaches in both coverage and tightness, especially for nonlinear transition systems and recursive programs (Lommen et al., 2022, Lommen et al., 21 Dec 2025, Lommen et al., 2023). The problem decomposition and local bound reuse are shown to yield 15–20% improvements without significant computational overhead.

6. Broader Impact and Limitations

Generality: Modular complexity analysis unifies diverse methods (ranking function synthesis, acceleration, closed-form recurrence, interpolation) and naturally extends to advanced models including recursion, probabilistic, and non-deterministic systems.
Heterogeneity: The primary methodological advantage is the ability to apply distinct techniques to distinct modules, achieving overall complexity bounds not accessible to homogeneous, "single-method" analyzers.
Reuse and Proof Tightening: Local bounds (and their proofs) can be reused, updated, and improved as new invariants or decompositions emerge, facilitating iterative proof refinement (Zankl et al., 2014).
Limitations: The method relies on the effectiveness and decidability of the local analyzers (e.g., completeness for twn-loops and prs-loops, solvability of ranking function constraints), and overly fine decompositions can incur overhead. Non-triangular, fully non-linear loops remain challenging unless further decidable subclasses are integrated (Lommen et al., 2022, Lommen et al., 15 Nov 2024).

7. Outlook: Extensions and Open Challenges

Extension to richer program classes: The modular framework admits natural extension to, e.g., periodic rational solvable loops (prs-loops), commutator cycles, and symmetries in counting CSPs, broadening its applicability (Lommen et al., 15 Nov 2024, Kazeminia et al., 8 Jan 2025).
Hybrid and probabilistic systems: Ongoing work incorporates modular approaches for hybrid dynamical systems, probabilistic algorithms, and quantum circuits, leveraging modular expectation transformers and compositional spectral techniques (Avanzini et al., 2019).
Automated proof synthesis and verification: Integration with SMT and algebraic solvers enhances automation, while ongoing improvements in invariant generation feed directly into tighter modular bounds (Giesl et al., 2022).
Open Problems: The classification of complexity for more general non-triangular loops, hardness boundaries under modular partition parameters (graphs, CSP), and completeness for higher-rank program classes remain active areas of research.