Structural Complexity Metrics

• Structural Complexity Metrics are quantitative measures that capture the number, arrangement, and inter-scale interactions of elements in a system.
• They combine graph-theoretic, multiscale, and software-inspired approaches to distinguish organized complexity from mere size or randomness.
• These metrics are applied across domains—from network analysis to image processing and software architecture—to inform system design and evaluation.

Searching arXiv for the cited papers to ground the article in the literature. Searching arXiv for graph-, multiscale-, and software-oriented structural complexity metrics. Structural complexity metrics are quantitative measures of how many structural elements a system contains, how those elements are arranged, and how strongly they interact across scales, interfaces, or dependency patterns. In the cited literature, the term spans principal graphs and cubic complexes, directed and undirected graphs, volumetric signals, software modules, prompts, test suites, graphical artifacts, and ecological or remote-sensing products; what unifies these settings is that complexity is treated as a property of organization rather than merely size, raw entropy, or runtime cost (Zinovyev et al., 2012, Mens, 2016, Bagrov et al., 2020).

1. Conceptual foundations

Several distinct formalisms recur under the same label. One class defines structural complexity by counting structural elements in an approximator or program representation, such as nodes, edges, stars, branches, interfaces, or memory channels. Another defines it by the amount of self-dissimilarity that remains when an object is coarse-grained across scales. A third defines it through graph topology, spectral signatures, or description length, especially when cycles, modular structure, or correlated disorder are the dominant source of difficulty (Zinovyev et al., 2012, Bagrov et al., 2020, Broekel, 2017, Goodwin, 11 Sep 2025).

Domain	Structural primitive	Representative metrics
Principal graphs and complexes	Nodes, edges, $k$-stars, grammar steps	$\mathrm{SC}(G)$, $\mathrm{GC}^\varphi(G)$, construction complexity
Directed and undirected graphs	Eigenvalues, cycles, BFS balls, modules, motifs	$F$, $C(G)$, $NDS$, $-\log(NDS)$
Multiscale fields and images	Overlap between adjacent coarse-grained layers	$C_k$, MSSC, $C(\lambda_i)$
Software and generated artifacts	Branches, interfaces, dispersion, annotations, elements	$V(G)$, FIFO, CCTR, purity/coverage/compactness/locality
Relational learning datasets	Effective edges, relation ambiguity, perturbation stability	$\mathrm{SC}(G)$0, relation entropy, ASC, ESC

A recurring distinction is between complexity and mere randomness. In materials chemistry, perfect crystals are structurally simple because they admit a terse crystallographic description, while random disorder is also structurally simple if it can be described efficiently through statistical mechanics; structural complexity emerges in the middle ground of correlated disorder, where non-random patterns exist without periodic repetition (Goodwin, 11 Sep 2025). A similar distinction appears in multiscale image and pattern metrics, where uniform patterns and fully random patterns both tend to yield low or saturated structural complexity, while intermediate, hierarchically organized patterns yield larger values (Bagrov et al., 2020, Kravchenko et al., 2024).

2. Graph- and network-based metrics

A major line of work defines structural complexity directly on graphs. For directed graphs, “spectral complexity” is built from the recurrence matrix $\mathrm{SC}(G)$1, obtained after splitting the graph into recurrent and non-recurrent parts, iteratively removing source nodes, normalizing rows, and adding self-loops at sinks. If the non-zero eigenvalues of $\mathrm{SC}(G)$2 are written as $\mathrm{SC}(G)$3, the metric is

$\mathrm{SC}(G)$4

The radial term measures leakage away from self-loops, while the angular term counts eigenvalues off the positive real axis and therefore encodes directed cycles. This is the essential property of the metric: it accounts for directed cycles, which in engineered and software systems correspond to feedback loops, subsystem interdependencies, instabilities, and infinite execution loops. The same framework defines a total complexity

$\mathrm{SC}(G)$5

thereby combining spectral complexity with component and edge contributions (Mezić et al., 2018).

The graph-theoretic interpretation is unusually explicit. On an irreducible component of period $\mathrm{SC}(G)$6, eigenvalues on the unit circle at roots of unity reveal cyclic partitions; real negative eigenvalues indicate strong two-cluster alternation; and the proposed spectral decomposition identifies “almost cycles” that Fiedler-vector methods on symmetrized graphs typically miss. The least complex recurrent graph is $\mathrm{SC}(G)$7, with $\mathrm{SC}(G)$8, whereas a fully mixed uniform transition matrix attains maximal spectral complexity $\mathrm{SC}(G)$9. For random row-normalized directed graphs, $\mathrm{GC}^\varphi(G)$0 with probability $\mathrm{GC}^\varphi(G)$1 as $\mathrm{GC}^\varphi(G)$2, and empirical examples include aircraft architectures, Wikipedia’s “who-votes-on-whom,” and Gnutella networks (Mezić et al., 2018).

A second graph formalism is renormalization-like rather than spectral. For an undirected graph $\mathrm{GC}^\varphi(G)$3, the breadth-first ball around node $\mathrm{GC}^\varphi(G)$4 at radius $\mathrm{GC}^\varphi(G)$5 induces a subgraph with $\mathrm{GC}^\varphi(G)$6 nodes, $\mathrm{GC}^\varphi(G)$7 edges, and density $\mathrm{GC}^\varphi(G)$8, where $\mathrm{GC}^\varphi(G)$9. The per-scale deviation is

$F$0

the node structural complexity is

$F$1

and the graph structural complexity is

$F$2

This construction compares the actual induced subgraph at each scale with its averaged complete-graph counterpart. It vanishes on empty graphs and complete graphs, generalizes to weighted graphs, and detects maxima near the emergence of giant components and at percolation thresholds, where multi-scale heterogeneity is largest (Snarskii, 2024).

A third network formulation appears in technological complexity. There, the object is a co-occurrence graph of IPC subclasses, and complexity is tied to ordered, complex, and random topologies. The Individual Network Diversity Score is

$F$3

averaged over sampled subgraphs to obtain $F$4, and transformed as

$F$5

The empirical conclusion is that this structural measure mirrors four stylized facts of technological complexity as good as or better than method-of-reflection and combinatorial-difficulty baselines, while avoiding key spatial endogeneities (Broekel, 2017).

3. Multiscale structural complexity in signals, images, and volumetric data

Another large family of metrics defines structural complexity as inter-scale dissimilarity under coarse-graining. In the renormalization-based framework for natural patterns, a pattern is repeatedly coarse-grained by non-overlapping $F$6 or $F$7 block averaging. If $F$8 and $F$9 denote non-normalized overlaps of successive layers, then

$C(G)$0

For simple block averaging, this reduces to half the absolute difference of adjacent self-overlaps. The metric is small for trivial order and for featureless randomness, and large when structure persists across well-separated scales. It accurately detects phase transitions in the 2D and 3D Ising model, resolves phase boundaries in Dzyaloshinskii–Moriya magnets, and traces non-equilibrium dynamics in dye mixing and skyrmion switching (Bagrov et al., 2020).

The same logic is adapted to visual stimuli in Multi-Scale Structural Complexity. In the continuous formulation, coarse-graining yields $C(G)$1 and

$C(G)$2

with total MSSC

$C(G)$3

A Fourier-based implementation progressively removes high spatial frequencies. On the SAVOIAS dataset, middle-scale MSSC correlates more strongly with subjective visual complexity than all-scale MSSC, with category-wise Pearson correlations of $C(G)$4 for Scenes, $C(G)$5 for Objects, and $C(G)$6 for Suprematism, while also showing more consistent behavior across categories than several baselines (Kravchenko et al., 2024).

In three-dimensional imaging, structural complexity is defined entirely in the voxel domain. If $C(G)$7 is the coarse-grained representation at scale $C(G)$8, the overlap between adjacent scales is

$C(G)$9

and the scale-specific structural complexity is

$NDS$0

A sliding-window coarse-graining scheme is introduced because traditional block-based tiling becomes unstable at coarse resolutions. Applied to UK Biobank, ADNI, and NACC structural MRI, the method finds that structural complexity decreases systematically with age, with the strongest effects at coarse scales; for example, $NDS$1 gives $NDS$2 and $NDS$3 gives $NDS$4, both with $NDS$5 (Cheng et al., 23 Jan 2026).

A related remote-sensing usage treats structural complexity as a supervised target rather than a handcrafted predictor. Global forest mapping is trained against GEDI L4C Footprint Level WSCI, a unitless structural complexity index derived by learning the relationship between GEDI waveforms and ALS-based 3D canopy entropy. The resulting 25 m global quarterly maps from 2015–2022 achieve $NDS$6 and RMSE $NDS$7 against held-out GEDI targets, with calibrated uncertainty from an EfficientNetV2-based multimodal fusion model (Conto et al., 7 Oct 2025).

4. Software, control, and spreadsheet metrics

In software engineering, structural complexity concerns how modules, classes, packages, and their dependencies affect understanding, testing, modification, and evolution. A standard taxonomy separates code/function-level control-flow and data-flow metrics, class-level coupling and cohesion metrics, and package/component/system-level dependency-graph metrics. Canonical examples include McCabe’s cyclomatic complexity

$NDS$8

Henry–Kafura-style information flow

$NDS$9

CBO, RFC, LCOM, Halstead effort

$-\log(NDS)$0

and dep-degree, defined as the number of edges in the def-use graph. The literature surveyed there emphasizes that coupling and cohesion must be interpreted jointly, that module-level metrics are often heavy-tailed and need inequality-aware aggregation such as Gini or Theil, and that socio-technical network measures can correlate more strongly with post-release defects than dependency graphs alone (Mens, 2016).

For IEC 61131-3 control software, six metrics are assembled into a language-compliant overall measure spanning LD, FBD, SFC, and ST. The set includes Halstead program length $-\log(NDS)$1, cyclomatic complexity $-\log(NDS)$2, information flow $-\log(NDS)$3, Halstead vocabulary $-\log(NDS)$4, Halstead difficulty

$-\log(NDS)$5

and a new data-structure metric

$-\log(NDS)$6

Each metric is normalized to the sample median,

$-\log(NDS)$7

and aggregated as

$-\log(NDS)$8

Industrial evaluation on 50 manually analyzed POUs and later on 2222 POUs showed that the resulting rankings and decompositions aligned with domain-expert judgments of complexity (Fischer et al., 2022).

Spreadsheet models require a different structural vocabulary, because spatial arrangement and reference dispersion are central. Logic-structure metrics include decision count $-\log(NDS)$9, maximum nesting depth $C_k$0, average nesting level

$C_k$1

and a conditional-construct complexity

$C_k$2

Data-structure metrics include fan-in, fan-out, and reachability

$C_k$3

Dispersion is measured from row and column deltas of references; the baseline metric is

$C_k$4

The framework uses these metrics to identify cells liable to errors, adjust cell error rates, and improve reliability, auditability, and comprehensibility through constructs such as reference branching condition cells and condition blocks (0802.3895).

5. Prompt-, test-, and artifact-aware metrics

As software artifacts broaden beyond conventional source code, structural complexity metrics have been extended to domains in which much of the behavioral logic is not expressed as ordinary control flow. For unit tests, CCTR is a test-aware cognitive complexity defined at the method level by

$C_k$5

with uniform weights $C_k$6. Here $C_k$7 is Sonar-style nesting complexity, $C_k$8 counts assertions or fail() statements, $C_k$9 counts mocking-related constructs such as mock(), verify(), and when(), and $C(\lambda_i)$0 counts test-related annotations, with $C(\lambda_i)$1 for @Test, @BeforeEach, and @AfterEach, and $C(\lambda_i)$2 for @ParameterizedTest. Aggregated by summation over methods, CCTR discriminates between structured and fragmented suites where SonarSource’s Cognitive Complexity often returns near-zero scores, with means of $C(\lambda_i)$3 and $C(\lambda_i)$4 for GPT-4o and Mistral Large on Defects4J, versus $C(\lambda_i)$5 for EvoSuite (Ouédraogo et al., 7 Jun 2025).

For LLM-integrated applications, HECATE treats prompts as specifications. Prompt-as-Specification models a prompt as $C(\lambda_i)$6, where $C(\lambda_i)$7 is a set of behavioral rules, $C(\lambda_i)$8 a set of global invariants, and $C(\lambda_i)$9 a vocabulary of state predicates. This enables prompt-layer structural metrics such as prompt decision density

$V(G)$0

alongside counts of distinct prompt templates, compound NL conditions, code-to-prompt injection surfaces, memory-related attributes, and LLM call sites. Out of 52 candidate metrics tested on 118 components from 18 repositories, only 10 remained significant after controlling for $V(G)$1; the strongest were $V(G)$2, $V(G)$3, $V(G)$4, $V(G)$5, $V(G)$6, $V(G)$7, $V(G)$8, and $V(G)$9. The central claim is that prompt complexity remains significant even when the strongest code-level metric is included as a covariate, establishing prompt complexity as a dimension in its own right (Xu et al., 2 Jul 2026).

SVG generation introduces a different notion of structure: element-level modularity for editing. A leave-one-out procedure renders the SVG with and without each element and computes the per-element contribution

$\mathrm{SC}(G)$00

where $\mathrm{SC}(G)$01 is CLIP image-to-image similarity. Difference masks $\mathrm{SC}(G)$02 are intersected with grounded concept heatmaps $\mathrm{SC}(G)$03 to define an attribution matrix

$\mathrm{SC}(G)$04

From this, four structural metrics are derived: purity, coverage, compactness, and locality. On over 19,000 edits across five generation systems and three complexity tiers, purity emerged as the most discriminative metric, while overall edit precision in the complex tier ranged from $\mathrm{SC}(G)$05 to $\mathrm{SC}(G)$06 for model-generated SVGs versus $\mathrm{SC}(G)$07 for source SVGs, reflecting the fact that generated SVGs often separate concepts into editable elements more cleanly than compound source paths (Zhu et al., 9 Apr 2026).

6. Predictive, learning-theoretic, and dataset-centric uses

Structural complexity metrics are increasingly used not only to describe artifacts but to predict downstream behavior. In graph neural networks, structural complexity is defined as the number of effective aggregation edges. For fixed aggregation,

$\mathrm{SC}(G)$08

and for attention-based models thresholded at $\mathrm{SC}(G)$09,

$\mathrm{SC}(G)$10

These quantities appear explicitly in Rademacher-complexity bounds. For example, in a two-layer GCN,

$\mathrm{SC}(G)$11

while two-layer GAT bounds couple $\mathrm{SC}(G)$12 and $\mathrm{SC}(G)$13 multiplicatively. The empirical message is that more effective edges induce smoother representations but higher generalization error, motivating structural entropy regularization to reduce redundant or cross-class aggregation (Wang et al., 13 May 2026).

In knowledge-graph link prediction, the paper examining CSG reaches the opposite conclusion for a spectral classifier-agnostic measure: CSG is highly sensitive to parameterization, does not robustly scale with the number of classes, and shows weak or inconsistent correlation with MRR and Hit@1. By contrast, global relation entropy

$\mathrm{SC}(G)$14

node-level Maximum Relation Diversity, and Relation Type Cardinality exhibit strong inverse correlations with MRR and Hit@1, whereas Average Degree, Degree Entropy, PageRank, and Eigenvector Centrality correlate positively with Hit@10. The article is therefore a cautionary case: a spectral complexity metric that was proposed as general can fail to be task-aligned in multi-relational KG settings (Gul et al., 21 Aug 2025).

A related predictive use appears in recommender systems. There, predictability is measured via structural consistency under perturbation of the user–item matrix $\mathrm{SC}(G)$15. Analytical Structural Consistency uses exact SVD of a perturbed matrix $\mathrm{SC}(G)$16, reconstructs a structurally perturbed approximation $\mathrm{SC}(G)$17, and uses the normalized RMSE on perturbed entries as the predictability score. Empirical Structural Consistency instead permutes a subset of ratings, trains a TSVD model, and averages the normalized RMSE over repeated perturbations. On real datasets, the correlations between the predictability metric and the best observed algorithmic RMSE are high: ASC yields Pearson $\mathrm{SC}(G)$18, Spearman $\mathrm{SC}(G)$19, and ESC yields Pearson $\mathrm{SC}(G)$20, Spearman $\mathrm{SC}(G)$21 (Valderrama et al., 2024).

Requirements engineering supplies another predictive example. Requirement networks extracted from text are measured using spectral quantities such as Graph Energy

$\mathrm{SC}(G)$22

Laplacian Graph Energy

$\mathrm{SC}(G)$23

and structural metrics such as cyclomatic complexity and integration load. In a controlled experiment using molecular integration tasks as structurally isomorphic proxies, spectral metrics predicted completion time with correlations above $\mathrm{SC}(G)$24: Integration LGE achieved $\mathrm{SC}(G)$25, Integration GE $\mathrm{SC}(G)$26, and Integration Load $\mathrm{SC}(G)$27, whereas density-based metrics showed no significant predictive validity (Vierlboeck et al., 6 Feb 2026).

7. Methodological issues, misconceptions, and outlook

A persistent misconception is that density, entropy, or connectivity alone can serve as universal surrogates for structural complexity. The surveyed literature repeatedly rejects that simplification. In directed graphs, graph energy does not track directed-cycle complexity well, while spectral complexity does (Mezić et al., 2018). In requirements graphs, density and density-derived variants show no significant predictive validity, whereas eigenvalue-derived measures do (Vierlboeck et al., 6 Feb 2026). In KG link prediction, CSG fails to be stable or task-aligned, whereas relation ambiguity metrics are far more informative (Gul et al., 21 Aug 2025). In visual complexity, extreme scales dominate raw MSSC but correlate weakly with subjective judgments, making middle-scale aggregation preferable (Kravchenko et al., 2024).

A second recurring issue is that structural complexity is relative to a representation. Principal-graph measures depend on grammar choice and approximator class; spreadsheet metrics depend on tokenization and layout; graph metrics depend on directedness, normalization, source removal, or thresholding; prompt metrics depend on extraction rules for instruction units and injection surfaces; and remote-sensing metrics such as WSCI inherit assumptions from the upstream GEDI-to-ALS mapping (Zinovyev et al., 2012, 0802.3895, Xu et al., 2 Jul 2026, Conto et al., 7 Oct 2025). This suggests that no single metric is representation-independent.

A third issue is scale. Some metrics, such as $\mathrm{SC}(G)$28, MSSC, and $\mathrm{SC}(G)$29, make scale explicit and expose where structure resides. Others, such as Halstead counts or effective-edge measures, collapse structure into a single scalar and are useful precisely because they are operationally simple. A plausible implication is that future structural complexity work will continue to combine both views: a scalar score for ranking and intervention, plus a decomposition that reveals which scales, channels, concepts, or interfaces actually generate the complexity.

Across the surveyed work, the most durable pattern is that structurally meaningful metrics count or encode distinct organizational elements rather than sheer volume. They privilege directed cycles over undirected connectivity, inter-scale dissimilarity over pixel entropy, interface breadth over raw LOC, relation ambiguity over class count, and concept modularity over image-level fidelity. In that sense, structural complexity metrics are less a single formula than a research program: the quantitative study of how organization itself becomes a measurable source of difficulty, fragility, or functional richness (Mezić et al., 2018, Bagrov et al., 2020, Mens, 2016, Xu et al., 2 Jul 2026).