2  Research Proposal: Dynamic Heterogeneous Multiplex Networks for Factor-Based Systemic Risk & Market Phase Transitions

---

2.1 1. Executive Summary & Research Proposal

2.1.1 1.1 The Problem

Traditional factor-investing frameworks (for example Fama-French and Barra) assume linear, stationary relationships and treat asset co-movements as independent. By construction they do not capture structural dependencies, liquidity crowding, or cascading supply-chain risk. Our motivating premise — grounded in the systemic-risk literature reviewed in §2 — is that this omission matters most precisely when it is most costly: standard risk models can misprice tail risk during market anomalies because they treat systemic risk as a sum of isolated asset volatilities rather than as an emergent property of a complex, interconnected system. We take this as the problem this research programme exists to test, not as a settled fact.

The empirical instrument behind this programme already measures market structure at a single layer — factor exposures and comovement — with point-in-time, survivorship-corrected discipline. What that single-layer view has not yet delivered is early-warning lead time. This proposal is the multi-layer extension designed to recover it.

2.1.2 1.2 Objective

We propose a framework combining heterogeneous multiplex networks with spatial-temporal graph neural networks (ST-GNNs) to model the global equity market, treating assets, systematic factors, and institutional funds as distinct nodes across specialised topological layers. This is proposed work; the sections below describe the instrument we would build to test it, and the register is therefore future and conditional throughout. Within this frame we set out to:

1. Formulate the mathematical constraints governing shock diffusion across multi-layered financial topologies.
2. Test whether the eigenvalue spectra of the network’s Supra-Laplacian matrix carry geometric signatures of critical slowing down — the hypothesised early-warning signals of market phase transitions — and, if so, whether they lead conventional risk metrics.
3. Determine whether a scalable, non-linear message-passing architecture out-performs a linear vector-autoregression (VAR) baseline in predicting systemic-risk propagation, and by how much.

---

2.2 2. Theoretical Foundations & Academic Literature

To establish rigorous groundings in both the statistical mechanics of complex networks and state-of-the-art graph architectures, the following core literature will form the basis of the literature review:

2.2.1 Econophysics & Financial Network Topology

• Caldarelli, G. (2007). Scale-Free Networks: Complex Webs in Nature and Technology. Oxford University Press. (Foundational network physics).
• Musmeci, N., Aste, T., & Di Matteo, T. (2015). Relation between financial market structure and the real economy via information filtering networks. Journal of Network Theory in Finance. (Key KCL methodology on filtered correlation topologies).
• Bardoscia, M., Battiston, S., Caccioli, F., & Caldarelli, G. (2017). Pathways towards instability in financial networks. Nature Communications 8:14416. (Mechanics of cascading failures in economic systems).

2.2.2 Multiplex & Multilayer Network Theory

• Boccaletti, S., et al. (2014). The structure and dynamics of multilayer networks. Physics Reports. (The definitive mathematical formulation of multilayer systems).
• Kivelä, M., et al. (2014). Multilayer networks. Journal of Complex Networks. (Terminology definitions for heterogeneous vs multiplex systems).

2.2.3 Graph Neural Networks & Graph ML

• Kipf, T. N., & Welling, M. (2016). Semi-Supervised Classification with Graph Convolutional Networks. arXiv. (Inception of standard GCN message-passing mechanics).
• Yu, B., Yin, H., & Zhu, Z. (2017). Spatio-Temporal Graph Convolutional Networks: A Deep Learning Framework for Traffic Forecasting. IJCAI. (Adaptable directly to financial time-series forecasting across graphs).

---

2.3 3. High-Level Architecture

The apparatus proposed to test the hypotheses is a four-stage pipeline; it is described here in the detail needed to judge feasibility, and it remains to be built. The pipeline would ingest empirical or simulated market vectors, structure them into a tensor-based multiplex graph, pass them through a geometric deep-learning engine, and evaluate structural-stability metrics.

Pipeline Stage	Subsystems & Architectural Components	Key Processes & Mathematical Tasks
1. Data Ingestion Engine	• Factor Loadings • Supply Chain Dependencies • Institutional Fund Portfolios	Ingests continuous empirical or simulated multi-source market vectors.
2. Supra-Adjacency Tensor Builder	• Layer 1: Bipartite Stock-Factor • Layer 2: Directed Unipartite Stock-Stock • Layer 3: Bipartite Institution-Stock	Maps isolated topology layers with variable edge weights and directed linkages into a global coordinate matrix (\(\mathcal{A}\)).
3. Geometric Deep Learning Framework	• Spatial-Temporal GNN (ST-GNN) • Heterogeneous Graph Attention Network (HAN) • Dynamic Feature Tracking	Executes non-linear message-passing architectures across node features like rolling price, volatility, and factor edge arrays.
4. Physics Evaluation Engine	• Supra-Laplacian Eigenvalue Spectral Analysis • Phase Transition Identification	Extracts the algebraic connectivity matrix to identify early warning metrics like the Critical Slowing Down Index before market anomalies.

2.3.1 Architectural Subsystems

1. The Representation Layer: Built on top of PyTorch Geometric (PyG), transforming heterogeneous nodes into independent vector spaces, mapping inter-layer couplings via a Supra-Adjacency matrix.
2. The Message-Passing Engine: Utilises a Modified Heterogeneous Graph Transformer (HGT) to account for time-varying edge weights (dynamic factor loadings) and node attributes.
3. The Spectral Analyser: Computes the algebraic connectivity (second smallest eigenvalue of the Supra-Laplacian) to flag structural vulnerability thresholds.

---

2.4 4. Software Dependencies (requirements.txt)

The proposed implementation environment relies on GPU-accelerated tensor math and specialised geometric-deep-learning libraries; the pinned set below records the intended dependencies.

torch>=2.4.0
torch-geometric>=2.5.0
networkx>=3.3
numpy>=1.26.0
pandas>=2.2.0
scikit-learn>=1.4.0
scipy>=1.12.0
tensorly>=0.8.1
matplotlib>=3.8.0

---

2.5 5. Data Requirements & Sourcing Options

To validate the model empirically, the architecture requires distinct financial and structural datasets:

Data Category	Target Variables	Academic / Free Sourcing	Commercial Sourcing
Asset Pricing & Factors	Daily/Intraday OHLCV, Fama-French 3/5 factor portfolios, Momentum, Volatility vectors.	French Data Library, Yahoo Finance API, OpenBB SDK.	CRSP, Axioma, Barra (MSCI), Bloomberg API.
Supply Chain Links	Customer-Supplier transaction directionality, percentage revenues.	Academic papers, SEC Edgar Parsing (Form 10-K extraction via NLP).	FactSet Revere, Bloomberg SPLC.
Institutional Ownership	Fund holdings, quarterly share counts, capital under management.	SEC Form 13F filings via EDGAR system.	Whalewisdom, Thomson Reuters (Refinitiv).

---

2.6 6. Synthetic Data Simulation Strategy (Model Proofing)

Before any claim can be made against real market data, we propose a synthetic-data simulator as a controlled proof of concept: an environment in which known systemic shocks can be injected, so that the spectral estimators can be checked for the property that they respond to a structural change we put there ourselves. We are explicit about what such a check can and cannot establish. A positive result on synthetic data shows only that the estimator is sensitive, by construction, to injected crowding and factor concentration; it is not evidence that the estimator leads stress in real markets. That remains to be tested on empirical data, and is the burden of the questions in the research-questions page.

2.6.1 6.1 Simulation Design

We model a synthetic environment with N=100 Stocks, F=5 Factors, and I=10 Institutional Funds.

1. Layer 1 (Factor Loadings): Generated via structural stochastic differential equations (SDEs) where asset returns are driven by latent brownian paths of factors.
2. Layer 2 (Supply Chain): Structured as a Scale-Free Directed Network using a Barabási–Albert model variant.
3. Layer 3 (Ownership Crowding): Structured as random bipartite linkages with a tunable concentration parameter to simulate “crowded trades”.

2.6.2 6.2 Python Verification Script

The reference script below generates the synthetic multiplex data tensors and computes the structural-stability profile from the network’s Laplacian; it is illustrative of the intended construction rather than a validated result.

import numpy as np
import pandas as pd
import networkx as nx
import scipy.sparse as sp

class MarketMultiplexSimulator:
    def __init__(self, n_stocks=100, n_factors=5, n_funds=10):
        self.n_stocks = n_stocks
        self.n_factors = n_factors
        self.n_funds = n_funds
        self.total_nodes = n_stocks + n_factors + n_funds
        
        # Node index mapping
        self.stock_idx = np.arange(0, n_stocks)
        self.factor_idx = np.arange(n_stocks, n_stocks + n_factors)
        self.fund_idx = np.arange(n_stocks + n_factors, self.total_nodes)

    def generate_layer_1_factors(self):
        """Generates continuous bipartite factor exposures (Stock x Factor)"""
        # Dense random matrix representing factor loadings (Beta weights)
        loadings = np.random.normal(loc=0.5, scale=0.2, size=(self.n_stocks, self.n_factors))
        # Enforce sparsity or structural constraints if needed
        loadings[loadings < 0.2] = 0.0
        return loadings

    def generate_layer_2_supply_chain(self):
        """Generates a scale-free directed adjacency matrix for stocks"""
        g = nx.scale_free_graph(n=self.n_stocks, alpha=0.41, beta=0.54, gamma=0.05, seed=42)
        adj = nx.to_numpy_array(g)
        return adj

    def generate_layer_3_funds(self, crowding_factor=0.1):
        """Generates institutional ownership matrix (Fund x Stock)"""
        # Crowding factor increases probability of overlapping portfolios
        base_prob = 0.15 + crowding_factor
        holdings = np.random.binomial(n=1, p=base_prob, size=(self.n_funds, self.n_stocks)).astype(float)
        # Weight holdings randomly to represent capital allocation percentage
        holdings *= np.random.uniform(0.01, 0.25, size=holdings.shape)
        return holdings

    def build_supra_laplacian(self, loadings, supply_chain, holdings, interlayer_coupling=1.0):
        """
        Assembles the comprehensive Supra-Adjacency and Supra-Laplacian matrix.
        Handles embedding the isolated layer topologies into a uniform global coordinate system.
        """
        # 1. Initialize empty global Adjacency Matrix
        W = np.zeros((self.total_nodes, self.total_nodes))
        
        # Embed Layer 1 (Bipartite Stock-Factor mappings)
        for s in range(self.n_stocks):
            for f in range(self.n_factors):
                weight = loadings[s, f]
                if weight > 0:
                    W[self.stock_idx[s], self.factor_idx[f]] = weight
                    W[self.factor_idx[f], self.stock_idx[s]] = weight # Symmetric link
                    
        # Embed Layer 2 (Unipartite Stock-Stock mappings)
        W[np.ix_(self.stock_idx, self.stock_idx)] += supply_chain
        
        # Embed Layer 3 (Bipartite Fund-Stock mappings)
        for fn in range(self.n_funds):
            for s in range(self.n_stocks):
                weight = holdings[fn, s]
                if weight > 0:
                    W[self.fund_idx[fn], self.stock_idx[s]] = weight
                    W[self.stock_idx[s], self.fund_idx[fn]] = weight

        # Add uniform identity-based inter-layer coupling to model identity retention
        np.fill_diagonal(W, interlayer_coupling)

        # 2. Compute Degree Matrix
        row_sums = np.sum(W, axis=1)
        D = np.diag(row_sums)
        
        # 3. Formulate Laplacian
        L = D - W
        return L

    def compute_stability_metrics(self, L):
        """
        Uses spectral analysis of the Laplacian to identify structural vulnerability.
        The second smallest eigenvalue (Algebraic Connectivity) measures network structural coherence.
        """
        eigenvalues = np.linalg.eigvalsh(L)
        # Sorted naturally ascending by eigvalsh
        unique_vals = np.sort(eigenvalues)
        
        # The first eigenvalue of a valid Laplacian is always 0 (up to numerical precision)
        algebraic_connectivity = unique_vals[1]
        spectral_radius = unique_vals[-1]
        
        return {
            "algebraic_connectivity": algebraic_connectivity,
            "spectral_radius": spectral_radius,
            "system_brittleness_index": 1.0 / (algebraic_connectivity + 1e-6)
        }

if __name__ == "__main__":
    # Execute structural simulation
    sim = MarketMultiplexSimulator(n_stocks=100, n_factors=5, n_funds=12)
    
    print("[1] Simulating Normal Market Regime...")
    l1 = sim.generate_layer_1_factors()
    l2 = sim.generate_layer_2_supply_chain()
    l3 = sim.generate_layer_3_funds(crowding_factor=0.0) # Base system diversification
    
    L_normal = sim.build_supra_laplacian(l1, l2, l3)
    metrics_normal = sim.compute_stability_metrics(L_normal)
    
    print(f" -> Normal Market Connectivity: {metrics_normal['algebraic_connectivity']:.5f}")
    print(f" -> Normal System Brittleness:  {metrics_normal['system_brittleness_index']:.5f}\n")

    print("[2] Simulating Highly Crowded/Stressed Market Regime...")
    # Injecting systemic risk via high factor concentration and institutional crowding
    l1_stressed = l1 * 2.5 
    l3_stressed = sim.generate_layer_3_funds(crowding_factor=0.65) # Massive portfolio overlap
    
    L_stressed = sim.build_supra_laplacian(l1_stressed, l2, l3_stressed)
    metrics_stressed = sim.compute_stability_metrics(L_stressed)
    
    print(f" -> Stressed Market Connectivity: {metrics_stressed['algebraic_connectivity']:.5f}")
    print(f" -> Stressed System Brittleness:  {metrics_stressed['system_brittleness_index']:.5f}")
    
    print("\n[Result] Verification Successful: Brittleness increase confirms Phase Transition structural detection capacity.")