Coordinative structures as scale-free networks: Cascade and percolation dynamics in motor learning with empirical validation.
10 blocks of code here have a permanent identifier (oscr:b:…), listed with the matches below: citable for good, with a page of its own. Select a match and press Cite to copy it. What a block identifier is.
The 14 matches
- [1] § 2. Materials and methods › 2.2. Cascade dynamics model ↔ simulations/02_cascade_dynamics.py, lines 115 to 208 · score 0.90 · neighbor mediated propagation, state variables, spontaneous activation, state transition, coordination strength, timestep · block
oscr:b:0118C4Y7ZFGYW-C· Report a mismatch - [2] § 3. Results › 3.2. Cascade dynamics ↔ simulations/02_cascade_dynamics.py, lines 1 to 44 · score 0.86 · topology isolated trials, DOF recruitment, spontaneous activation, single seed, asymmetry ratio, Cascade dynamics · block
oscr:b:B5C47Z58FKVBV-5· Report a mismatch - [3] § 2. Materials and methods › 2.4. Percolation model and coupled learning dynamics ↔ simulations/04_coupled_learning.py, lines 1 to 41 · score 0.82 · Hebbian weight updates, preferential attachment, step coupled, practice iteration, fitness, 2–4 · block
oscr:b:GG0TNXSNS78FV-0· Report a mismatch - [4] § 2. Materials and methods › 2.1. Network model specifications ↔ simulations/01_network_generation.py, lines 1 to 42 · score 0.78 · Barab si Albert, canonical network, Watts Strogatz, scale free networks, Erd, nyi · block
oscr:b:TMT8RPEERZJDJ-Q· Report a mismatch - [5] § 2. Materials and methods › 2.2. Cascade dynamics model ↔ simulations/02_cascade_dynamics.py, lines 1 to 44 · score 0.74 · baseline stability, centrality weighted, coordination strength, neighbors, S2, activation · block
oscr:b:B5C47Z58FKVBV-5· Report a mismatch - [6] § 3. Results › 3.4. Coupled learning dynamics ↔ simulations/04_coupled_learning.py, lines 1 to 41 · score 0.72 · Hebbian learning rate, coupled learning dynamics, practice iterations, weight hierarchy, algorithm, decay · block
oscr:b:GG0TNXSNS78FV-0· Report a mismatch - [7] § 2. Materials and methods › 2.1. Network model specifications ↔ simulations/01_network_generation.py, lines 1 to 42 · score 0.65 · small world network, power law, random network, scale free network, clustering, connecting · block
oscr:b:TMT8RPEERZJDJ-Q· Report a mismatch - [8] § 2. Materials and methods › 2.4. Percolation model and coupled learning dynamics ↔ simulations/03_percolation_robustness.py, lines 82 to 127 · score 0.58 · giant component fraction, occupation probability, bond, percolation · block
oscr:b:6BRFG3S2DZHFT-I· Report a mismatch - [9] § 3. Results › 3.1. Network topology comparison ↔ simulations/01_network_generation.py, lines 244 to 371 · score 0.57 · exemplar network, hub fraction, eigenvector centrality, Gini, scale free network, seed · block
oscr:b:1XKTB03DFM23E-N· Report a mismatch - [10] § 3. Results › 3.3. Percolation dynamics and robustness-fragility ↔ simulations/03_percolation_robustness.py, lines 1 to 41 · score 0.56 · bond occupation sweeps, robustness, susceptibility, fragility, percolation, realizations · block
oscr:b:GTYN5CRB6FA2C-L· Report a mismatch - [11] § 2. Materials and methods › 2.3. Mapping network topology to coordinative structures ↔ simulations/03_percolation_robustness.py, lines 173 to 196 · score 0.56 · random node removal, fragmentation ratio, Robustness · block
oscr:b:6FS5AF0YCHGBS-M· Report a mismatch - [12] § 3. Results › 3.1. Network topology comparison ↔ simulations/01_network_generation.py, lines 103 to 124 · score 0.54 · Gini coefficient, hub fraction, eigenvector centrality, nodes, networks · block
oscr:b:TFE7YP4VHJK1J-A· Report a mismatch - [13] § 2. Materials and methods › 2.4. Percolation model and coupled learning dynamics ↔ simulations/04_coupled_learning.py, lines 147 to 176 · score 0.54 · co activated, coupled learning, decay, strengthen, Edges, weights · block
oscr:b:F9G2KBNKX1250-2· Report a mismatch - [14] § 3. Results › 3.1. Network topology comparison ↔ simulations/01_network_generation.py, lines 244 to 371 · score 0.53 · Power law fitting, network ensembles, KS, WS, BA, topologies · block
oscr:b:1XKTB03DFM23E-N· Report a mismatch
Paper
Loaded from Europe PMC by your browser; OSCR does not store it: doi.org · Europe PMC
The paper is loaded when this pane is shown.
The authors' code
Python · 455 lines · 17 KB · MIT · 5 matches
- #!/usr/bin/env python3
- """
- 01_network_generation.py
- ========================
- Coordinative Structures as Scale-Free Networks (Park, 2026)
- Manuscript Section 2.1 — Network Topology
- Generates three canonical network topologies with matched connectivity:
- - Erdős–Rényi (ER) random network
- - Watts–Strogatz (WS) small-world network
- - Barabási–Albert (BA) scale-free network
- Computes structural metrics for manuscript Tables S1a–S1d and Table 2:
- - Degree statistics: ⟨k⟩, σ_k, k_max
- - Degree heterogeneity: κ = ⟨k²⟩/⟨k⟩
- - Power-law exponent: γ̂ (MLE) with KS goodness-of-fit
- - Centrality: eigenvector centrality, Gini coefficient, hub fraction
- - Topology: clustering coefficient, average path length
- Parameters (from manuscript §2.1):
- N = 100 nodes
- ⟨k⟩ ≈ 6 (matched across topologies)
- ER: p = 0.0606
- WS: K = 6, β = 0.1
- BA: m = 3 (m₀ = 3 initial complete graph)
- Realizations: 100
- Base random seed: 42
- Output:
- data/simulation_outputs/network_structural_metrics.csv
- data/simulation_outputs/network_ensemble_data.npz
- Usage:
- python simulations/01_network_generation.py
- """
- import numpy as np
- import networkx as nx
- from scipy import stats
- import os
- import sys
- import time
- # ══════════════════════════════════════════════════════════════
- # PARAMETERS — manuscript §2.1, Tables S1b, S1d
- # ══════════════════════════════════════════════════════════════
- N = 100 # Number of nodes (degrees of freedom)
- N_REALIZATIONS = 100 # Independent network instances
- BASE_SEED = 42 # For reproducibility
- # Topology-specific parameters (Table S1b)
- ER_P = 6.0 / (N - 1) # ≈ 0.0606, targeting ⟨k⟩ ≈ 6
- WS_K = 6 # Ring neighbors (each side K/2 = 3)
- WS_BETA = 0.1 # Rewiring probability
- BA_M = 3 # Edges per new node (⟨k⟩ → 2m = 6)
- # Hub identification threshold
- HUB_CRITERION = 'mean_plus_sd' # C_e > μ + σ
- # Output directory
- OUTPUT_DIR = os.path.join(os.path.dirname(os.path.dirname(
- os.path.abspath(__file__))), 'data', 'simulation_outputs')
- # ══════════════════════════════════════════════════════════════
- # NETWORK GENERATION FUNCTIONS
- # ══════════════════════════════════════════════════════════════
- def generate_er(n, p, seed):
- """Erdős–Rényi G(N,p) random network (Eq S1 Appendix, Algorithm 1)."""
- return nx.erdos_renyi_graph(n, p, seed=seed)
- def generate_ws(n, k, beta, seed):
- """Watts–Strogatz small-world network (Algorithm 2)."""
- return nx.watts_strogatz_graph(n, k, beta, seed=seed)
- def generate_ba(n, m, seed):
- """Barabási–Albert scale-free network via preferential attachment (Eq 1)."""
- return nx.barabasi_albert_graph(n, m, seed=seed)
- # ══════════════════════════════════════════════════════════════
- # STRUCTURAL ANALYSIS FUNCTIONS
- # ══════════════════════════════════════════════════════════════
- def compute_degree_stats(G):
- """Compute degree distribution statistics."""
- degrees = np.array([G.degree(n) for n in G.nodes()])
- k_mean = degrees.mean()
- k_std = degrees.std()
- k_max = degrees.max()
- k_second_moment = (degrees ** 2).mean()
- kappa = k_second_moment / k_mean if k_mean > 0 else 0.0
- return {
- 'k_mean': k_mean,
- 'k_std': k_std,
- 'k_max': k_max,
- 'kappa': kappa,
- 'degrees': degrees,
- }
- def compute_centrality_stats(G):
- """Compute eigenvector centrality and derived measures."""
- try:
- ce = nx.eigenvector_centrality_numpy(G)
- except nx.NetworkXError:
- # Fallback for disconnected graphs
- ce = nx.eigenvector_centrality(G, max_iter=1000, tol=1e-6)
- ce_vals = np.array([ce[n] for n in G.nodes()])
- # Gini coefficient of eigenvector centrality
- gini = _gini_coefficient(ce_vals)
- # Hub fraction: nodes with C_e > μ + σ
- ce_mean = ce_vals.mean()
- ce_std = ce_vals.std()
- hub_fraction = np.mean(ce_vals > (ce_mean + ce_std))
- return {
- 'gini_ce': gini,
- 'hub_fraction': hub_fraction,
- 'ce_values': ce_vals,
- }
- def _gini_coefficient(values):
- """Compute Gini coefficient for a set of values."""
- sorted_vals = np.sort(values)
- n = len(sorted_vals)
- if n == 0 or sorted_vals.sum() == 0:
- return 0.0
- index = np.arange(1, n + 1)
- return (2 * np.sum(index * sorted_vals) / (n * np.sum(sorted_vals))) - (n + 1) / n
- def compute_topology_stats(G):
- """Compute clustering coefficient and average path length."""
- clustering = nx.average_clustering(G)
- # Average shortest path length (handle disconnected graphs)
- if nx.is_connected(G):
- avg_path = nx.average_shortest_path_length(G)
- else:
- # Use largest connected component
- gcc = max(nx.connected_components(G), key=len)
- subG = G.subgraph(gcc).copy()
- avg_path = nx.average_shortest_path_length(subG) if len(subG) > 1 else float('inf')
- return {
- 'clustering': clustering,
- 'avg_path_length': avg_path,
- }
- def powerlaw_fit(degrees, k_min=None):
- """
- Maximum Likelihood Estimation of power-law exponent γ̂.
- Uses the discrete MLE formula (Eq S1 in S1 Appendix):
- γ̂ = 1 + n [Σᵢ ln(kᵢ / (k_min − 0.5))]⁻¹
- Following Clauset, Shalizi & Newman (2009) [Ref 58 in manuscript].
- Returns:
- gamma_hat: MLE exponent estimate
- ks_pvalue: KS test p-value against power-law distribution
- k_min_used: k_min threshold used
- """
- degrees = np.array(degrees)
- degrees = degrees[degrees > 0] # Remove zeros
- if k_min is None:
- # Find optimal k_min by minimizing KS statistic
- unique_k = np.unique(degrees)
- unique_k = unique_k[unique_k >= 2] # Minimum meaningful k_min
- best_ks = np.inf
- best_kmin = 2
- best_gamma = 3.0
- for km in unique_k:
- if km >= degrees.max():
- break
- tail = degrees[degrees >= km]
- if len(tail) < 10:
- break
- g = 1 + len(tail) * (np.sum(np.log(tail / (km - 0.5)))) ** (-1)
- if g > 1.5 and g < 5.0: # Reasonable range
- # KS statistic
- cdf_emp = np.sort(tail)
- cdf_emp = np.arange(1, len(cdf_emp) + 1) / len(cdf_emp)
- cdf_theo = 1 - (np.sort(tail) / km) ** (-(g - 1))
- ks = np.max(np.abs(cdf_emp - cdf_theo))
- if ks < best_ks:
- best_ks = ks
- best_kmin = km
- best_gamma = g
- k_min = best_kmin
- # Final fit with chosen k_min
- tail = degrees[degrees >= k_min]
- if len(tail) < 5:
- return np.nan, np.nan, k_min
- gamma_hat = 1 + len(tail) * (np.sum(np.log(tail / (k_min - 0.5)))) ** (-1)
- # KS goodness-of-fit via Monte Carlo (simplified)
- n_mc = 500
- ks_orig = _ks_stat_powerlaw(tail, gamma_hat, k_min)
- n_exceed = 0
- rng = np.random.RandomState(BASE_SEED)
- for _ in range(n_mc):
- # Generate synthetic power-law sample
- synth = _generate_powerlaw_sample(len(tail), gamma_hat, k_min, rng)
- if len(synth) < 5:
- continue
- g_synth = 1 + len(synth) * (np.sum(np.log(synth / (k_min - 0.5)))) ** (-1)
- ks_synth = _ks_stat_powerlaw(synth, g_synth, k_min)
- if ks_synth >= ks_orig:
- n_exceed += 1
- ks_pvalue = n_exceed / n_mc
- return gamma_hat, ks_pvalue, k_min
- def _ks_stat_powerlaw(data, gamma, k_min):
- """KS statistic between data and power-law CDF."""
- sorted_data = np.sort(data)
- n = len(sorted_data)
- cdf_emp = np.arange(1, n + 1) / n
- cdf_theo = 1 - (sorted_data / k_min) ** (-(gamma - 1))
- return np.max(np.abs(cdf_emp - cdf_theo))
- def _generate_powerlaw_sample(n, gamma, k_min, rng):
- """Generate discrete power-law random sample via inverse transform."""
- u = rng.uniform(0, 1, size=n)
- samples = np.floor(k_min * (1 - u) ** (-1.0 / (gamma - 1))).astype(int)
- return samples[samples >= k_min]
- # ══════════════════════════════════════════════════════════════
- # MAIN ENSEMBLE SIMULATION
- # ══════════════════════════════════════════════════════════════
- def run_ensemble():
- """
- Generate network ensembles and compute all structural metrics.
- Reproduces Tables S1b, S1d, and Table 2 (structural rows).
- """
- print("=" * 70)
- print("01_network_generation.py")
- print("Coordinative Structures as Scale-Free Networks")
- print(f"N = {N}, ⟨k⟩ ≈ 6, {N_REALIZATIONS} realizations, seed = {BASE_SEED}")
- print("=" * 70)
- topologies = {
- 'ER': {'generator': lambda seed: generate_er(N, ER_P, seed),
- 'params': f'p = {ER_P:.4f}'},
- 'WS': {'generator': lambda seed: generate_ws(N, WS_K, WS_BETA, seed),
- 'params': f'K = {WS_K}, β = {WS_BETA}'},
- 'BA': {'generator': lambda seed: generate_ba(N, BA_M, seed),
- 'params': f'm = {BA_M}'},
- }
- # Storage for ensemble results
- results = {}
- ensemble_data = {}
- for topo_name, topo_info in topologies.items():
- print(f"\n--- {topo_name} ({topo_info['params']}) ---")
- t0 = time.time()
- # Per-realization storage
- k_means = []
- k_stds = []
- k_maxs = []
- kappas = []
- clusterings = []
- path_lengths = []
- gini_ces = []
- hub_fracs = []
- gamma_hats = []
- ks_pvals = []
- all_degrees = []
- for r in range(N_REALIZATIONS):
- seed = BASE_SEED + r
- G = topo_info['generator'](seed)
- # Degree statistics
- dstats = compute_degree_stats(G)
- k_means.append(dstats['k_mean'])
- k_stds.append(dstats['k_std'])
- k_maxs.append(dstats['k_max'])
- kappas.append(dstats['kappa'])
- all_degrees.append(dstats['degrees'])
- # Centrality statistics
- cstats = compute_centrality_stats(G)
- gini_ces.append(cstats['gini_ce'])
- hub_fracs.append(cstats['hub_fraction'])
- # Topology statistics
- tstats = compute_topology_stats(G)
- clusterings.append(tstats['clustering'])
- path_lengths.append(tstats['avg_path_length'])
- # Power-law fit (BA only — ER and WS are not power-law)
- if topo_name == 'BA':
- gamma, ks_p, _ = powerlaw_fit(dstats['degrees'])
- gamma_hats.append(gamma)
- ks_pvals.append(ks_p)
- elapsed = time.time() - t0
- print(f" Completed {N_REALIZATIONS} realizations in {elapsed:.1f}s")
- # Ensemble statistics
- res = {
- 'k_mean': (np.mean(k_means), np.std(k_means)),
- 'k_std': (np.mean(k_stds), np.std(k_stds)),
- 'k_max': (np.mean(k_maxs), np.std(k_maxs)),
- 'kappa': (np.mean(kappas), np.std(kappas)),
- 'clustering': (np.mean(clusterings), np.std(clusterings)),
- 'avg_path': (np.mean(path_lengths), np.std(path_lengths)),
- 'gini_ce': (np.mean(gini_ces), np.std(gini_ces)),
- 'hub_fraction': (np.mean(hub_fracs), np.std(hub_fracs)),
- }
- if topo_name == 'BA':
- valid_gamma = [g for g in gamma_hats if not np.isnan(g)]
- valid_ks = [p for p in ks_pvals if not np.isnan(p)]
- res['gamma_hat'] = (np.mean(valid_gamma), np.std(valid_gamma))
- res['ks_pvalue'] = (np.mean(valid_ks), np.std(valid_ks))
- results[topo_name] = res
- # Store ensemble arrays for downstream use
- ensemble_data[f'{topo_name}_kappas'] = np.array(kappas)
- ensemble_data[f'{topo_name}_gini'] = np.array(gini_ces)
- ensemble_data[f'{topo_name}_hub_frac'] = np.array(hub_fracs)
- ensemble_data[f'{topo_name}_k_means'] = np.array(k_means)
- ensemble_data[f'{topo_name}_k_stds'] = np.array(k_stds)
- ensemble_data[f'{topo_name}_k_maxs'] = np.array(k_maxs)
- ensemble_data[f'{topo_name}_clusterings'] = np.array(clusterings)
- ensemble_data[f'{topo_name}_path_lengths'] = np.array(path_lengths)
- # Store exemplar network (seed=42) for visualization
- G_exemplar = topo_info['generator'](BASE_SEED)
- pos_exemplar = nx.spring_layout(G_exemplar, seed=BASE_SEED,
- k=1.8 / np.sqrt(N), iterations=80)
- deg_exemplar = np.array([G_exemplar.degree(n) for n in G_exemplar.nodes()])
- try:
- ce_exemplar = np.array(list(
- nx.eigenvector_centrality_numpy(G_exemplar).values()))
- except Exception:
- ce_exemplar = np.zeros(N)
- ce_norm = (ce_exemplar - ce_exemplar.min()) / (
- ce_exemplar.max() - ce_exemplar.min() + 1e-10)
- pos_array = np.array([pos_exemplar[n] for n in G_exemplar.nodes()])
- edges_array = np.array(list(G_exemplar.edges()))
- ensemble_data[f'net_{topo_name}_pos'] = pos_array
- ensemble_data[f'net_{topo_name}_degs'] = deg_exemplar
- ensemble_data[f'net_{topo_name}_ce'] = ce_norm
- ensemble_data[f'net_{topo_name}_edges'] = edges_array
- return results, ensemble_data
- def print_results(results):
- """Print results in Table S1d format."""
- print("\n" + "=" * 70)
- print("TABLE S1d — Structural validation measures")
- print(f"(ensemble means ± SD; {N_REALIZATIONS} realizations; "
- f"N = {N}, ⟨k⟩ ≈ 6, seed base = {BASE_SEED})")
- print("=" * 70)
- measures = [
- ('⟨k⟩', 'k_mean'),
- ('σ_k', 'k_std'),
- ('k_max', 'k_max'),
- ('κ = ⟨k²⟩/⟨k⟩', 'kappa'),
- ('Clustering', 'clustering'),
- ('Avg path', 'avg_path'),
- ('Gini(C_e)', 'gini_ce'),
- ('Hub fraction', 'hub_fraction'),
- ]
- header = f"{'Measure':<18} {'ER (Random)':<20} {'WS (Small-World)':<20} {'BA (Scale-Free)':<20}"
- print(header)
- print("-" * 78)
- for label, key in measures:
- row = f"{label:<18}"
- for topo in ['ER', 'WS', 'BA']:
- mean, sd = results[topo][key]
- row += f" {mean:>7.2f} ± {sd:<6.2f} "
- print(row)
- # BA-specific measures
- if 'gamma_hat' in results['BA']:
- mean, sd = results['BA']['gamma_hat']
- print(f"{'γ̂ (MLE)':<18} {'---':<20} {'---':<20} {mean:>7.2f} ± {sd:<6.2f}")
- if 'ks_pvalue' in results['BA']:
- mean, sd = results['BA']['ks_pvalue']
- print(f"{'KS p-value':<18} {'---':<20} {'---':<20} {mean:>7.2f} ± {sd:<6.2f}")
- # Manuscript Table 2 comparison
- print("\n" + "=" * 70)
- print("VERIFICATION against manuscript Table 2")
- print("=" * 70)
- expected = {
- 'ER': {'kappa': 6.84, 'gini_ce': 0.26, 'hub_fraction': 0.16},
- 'WS': {'kappa': 6.09, 'gini_ce': 0.16, 'hub_fraction': 0.16},
- 'BA': {'kappa': 9.67, 'gini_ce': 0.35, 'hub_fraction': 0.10},
- }
- for topo in ['ER', 'WS', 'BA']:
- print(f"\n {topo}:")
- for key, exp_val in expected[topo].items():
- sim_val = results[topo][key][0]
- match = "✓" if abs(sim_val - exp_val) / (exp_val + 1e-10) < 0.15 else "✗"
- print(f" {key:<15} expected={exp_val:.2f} simulated={sim_val:.2f} {match}")
- def save_results(results, ensemble_data):
- """Save results to CSV and NPZ files."""
- os.makedirs(OUTPUT_DIR, exist_ok=True)
- # CSV summary
- csv_path = os.path.join(OUTPUT_DIR, 'network_structural_metrics.csv')
- with open(csv_path, 'w') as f:
- f.write("topology,measure,mean,sd\n")
- for topo in ['ER', 'WS', 'BA']:
- for key, (mean, sd) in results[topo].items():
- f.write(f"{topo},{key},{mean:.6f},{sd:.6f}\n")
- print(f"\nSaved: {csv_path}")
- # NPZ ensemble data (for downstream scripts and figure generation)
- npz_path = os.path.join(OUTPUT_DIR, 'network_ensemble_data.npz')
- np.savez_compressed(npz_path, **ensemble_data)
- print(f"Saved: {npz_path}")
- # ══════════════════════════════════════════════════════════════
- # ENTRY POINT
- # ══════════════════════════════════════════════════════════════
- if __name__ == '__main__':
- results, ensemble_data = run_ensemble()
- print_results(results)
- save_results(results, ensemble_data)
- print("\n✓ 01_network_generation.py complete.")
01_network_generation.py at commit 04d398f, under MIT · at the source
Overview
- Department of Physical Education, Seoul National University, Seoul, South Korea
- Systemic Risk and Resilience, International Institute for Applied Systems Analysis (IIASA), Laxenburg, Austria
- Complexity Science and Evolution, Okinawa Institute of Science and Technology (OIST), Okinawa, Japan
Abstract
Coordinative structures are the functional groupings of degrees of freedom that simplify motor control. Decades of research have documented them well, yet they remain mechanistically unexplained. How they emerge and why they are hierarchically organized are both unresolved questions. This study proposes scale-free network topology as the missing mechanism. Systematic simulations compared random networks, small-world networks, and scale-free networks. Scale-free organization reproduced the defining features of coordinative structures more completely than either alternative. Those features are a hub-periphery hierarchy, ordered hub-first recruitment, an abrupt onset of global coordination, and a balance between stability and flexibility. Four formal correspondences connect these features to established coordination phenomena. A coupled learning model reproduced the characteristic curve of skill acquisition, and scale-free networks reached the coordination threshold fastest. The model was then validated against published data from five independent studies spanning motor learning, bimanual coordination, brain networks, and joint coordination. It yields eleven testable predictions with explicit quantitative thresholds, together with five criteria that would disconfirm it. Network topology therefore offers a principled account of how coordinative structures form through structural constraints and experience. That account is empirically grounded and open to falsification.
Reproduced under the paper's license (CC BY), from the paper cited above.
Repositories
Its files are read in the Code ↔ Paper reader above, with 14 matches between paragraphs and lines of code.
pcw8531/Coordinative-structures-scale-free-networks
04d398f99cf12af41cbd2324fba7fa8754bf5036, 7 July 2026Availability: 1 check, the latest on 27 September 2026: the link answers
- 27 September 2026: the link answers
6 files
- simulations/
01_network_generation.py , Python, 455 lines, 5 matches - simulations/
02_cascade_dynamics.py , Python, 479 lines, 3 matches - simulations/
03_percolation_robustnes , Python, 393 lines, 3 matchess.py - simulations/
04_coupled_learning.py , Python, 477 lines, 3 matches - LICENSE, License, 21 lines
- README.md, Text, 206 lines
Zenodo 20694466
Availability: 1 check, the latest on 27 September 2026: the link answers (HTTP 200)
- 27 September 2026: the link answers (HTTP 200)
6 files
- simulations/
01_network_generation.py , Python, 455 lines - simulations/
02_cascade_dynamics.py , Python, 479 lines - simulations/
03_percolation_robustnes , Python, 393 liness.py - simulations/
04_coupled_learning.py , Python, 477 lines - LICENSE, License, 21 lines
- README.md, Text, 195 lines
The paper's code and data availability statement is in the Data section.
Tracing map
Proposed by the machine: these links were found in the paper and verified at the source, without human review. The map will receive a Zenodo DOI once one of the paper's authors has validated it with their ORCID.
What the map holds:
- 2 repositories of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
- 8 scripts, each with its path and the digest of its content;
- 14 matches between paragraphs of the paper and lines of the code (method lexical-v1);
- neither the text of the paper nor the code itself.
Its JSON (tracing-map.json) is deposited on Zenodo with its DOI once the map is validated.
Data
No dataset and no data link were found in the paper.
Data Availability
All data underlying the findings are within the paper and its Supporting information files. The complete simulation source code is openly available under an MIT license at https://
Reproduced under the paper's license (CC BY), from the paper cited above.
Versions
The history of this record: each version stored by the harvester or made by a correction of its authors or of the maintainers of its code, and what changed in its facts. The texts of the paper (its abstract, its availability statements) are not part of it; versions that changed only those are not listed.
Version 1, 27 September 2026: the first record
Recorded: type, language, journal, volume, issue, pages, dates, 1 author, 8 MeSH terms, 2 funders, 47 references.
Cite
This paper
Park, C. (2026). Coordinative structures as scale-free networks: Cascade and percolation dynamics in motor learning with empirical validation. PLoS computational biology, 22(7), e1014523. https://
BibTeX
@article{park2026coordin
author = {Park, Chulwook},
title = {{Coordinative structures as scale-free networks: Cascade and percolation dynamics in motor learning with empirical validation}},
journal = {PLoS computational biology},
year = {2026},
month = jul,
volume = {22},
number = {7},
pages = {e1014523},
publisher = {PLOS},
issn = {1553-734X},
doi = {10.1371/
url = {https://
pmid = {42479799},
pmcid = {PMC13423191}
}
RIS
TY - JOUR
AU - Park, Chulwook
TI - Coordinative structures as scale-free networks: Cascade and percolation dynamics in motor learning with empirical validation
T2 - PLoS computational biology
J2 - PLoS Comput Biol
PY - 2026
DA - 2026/
VL - 22
IS - 7
SP - e1014523
SN - 1553-734X
PB - PLOS
DO - 10.1371/
UR - https://
LA - en
ER -
CSL-JSON
{
"id": "10.1371/
"type": "article-journal",
"title": "Coordinative structures as scale-free networks: Cascade and percolation dynamics in motor learning with empirical validation",
"container-title": "PLoS computational biology",
"author": [
{
"family": "Park",
"given": "Chulwook"
}
],
"container-title-short":
"volume": "22",
"issue": "7",
"page": "e1014523",
"DOI": "10.1371/
"PMID": "42479799",
"PMCID": "PMC13423191",
"ISSN": "1553-734X",
"publisher": "PLOS",
"URL": "https://
"language": "en",
"issued": {
"date-parts": [
[
2026,
7,
21
]
]
}
}
The tracing map gets a citation of its own once an author has validated it and it has a DOI.
Similar papers
The papers with a page that share the most with this one: the tools found in their code, their categories, datasets, cited references and authors, the rarest counting most.
- [1] doi:10.1073/pnas.2218007120 [code]
- Early path dominance as a principle for neurodevelopment.Journal: Proceedings of the National Academy of Sciences of the United States of AmericaIn common: NetworkX, SciPy, NumPy, 5 references
- [2] doi:10.1162/netn.a.39 [code]
- Benchmarking overlapping community detection methods for applications in human connectomics.Journal: Network neuroscience (Cambridge, Mass.)In common: NetworkX, SciPy, NumPy, 4 references
- [3] doi:10.1038/s43588-024-00735-z [code]
- A simulated annealing algorithm for randomizing weighted networks.Journal: Nature computational scienceIn common: NetworkX, SciPy, NumPy, computational, computational modeling (no new data), 3 references
- [4] doi:10.1038/s41467-026-72510-9 [code]
- Single-neuron network topology governs neural computation and learning in primate cortex.Journal: Nature communicationsIn common: SciPy, NumPy, 5 references
- [5] doi:10.1162/netn_a_00246
- Percolation may explain efficiency, robustness, and economy of the brain.Journal: Network neuroscience (Cambridge, Mass.)In common: 5 references
- [6] doi:10.1093/pnasnexus/pgaf365 [code]
- Identifying key regulators in neuronal transdifferentiation by gene regulatory network analysis.Journal: PNAS nexusIn common: NetworkX, SciPy, NumPy, 3 references
- [7] doi:10.1186/s12984-025-01561-8 [code]
- Motor modules are largely unaffected by pathological walking biomechanics: a simulation study.Journal: Journal of neuroengineering and rehabilitationIn common: NumPy, computational, 3 references
- [8] doi:10.1162/netn_a_00284 [code]
- Multimodal multilayer network centrality relates to executive functioning.Journal: Network neuroscience (Cambridge, Mass.)In common: NetworkX, SciPy, NumPy, 3 references
- [9] doi:10.1038/s42003-025-08962-4 [code]
- Transcriptomic divergence of network hubs in the prenatal human brain.Journal: Communications biologyIn common: NetworkX, SciPy, NumPy, 3 references
- [10] doi:10.1162/netn_a_00439 [code]
- Metric structural human connectomes: Localization and multifractality of eigenmodes.Journal: Network neuroscience (Cambridge, Mass.)In common: NetworkX, SciPy, NumPy, computational, computational modeling (no new data), 2 references
Contribute
The authors of this paper can claim it, correct its record and validate its tracing map, and the maintainers of its code (its owner, or a public member of its organization) correct what it says of their repository; anyone signed in can ask for its removal. Every request goes to OSCR's own machine, which answers it; your account page follows them.
Sign in with ORCID to claim this paper as one of its authors, correct its record or validate its tracing map: when the paper's metadata lists your ORCID iD, you are recognized at once. Maintainers of its code: sign in with GitHub, then claim the repository on your account page.
Claim this paper
Correct its record
Say what each link of this record is, remove the ones that are not the paper's, add the ones that are missing. The correction becomes a new version of the record, in its Versions section.
Validate its tracing map
You validate the map as this page shows it: 2 repositories of the authors' code, each at its verified commit and with its license, 8 scripts, and 14 matches between paragraphs and code (see the Code and Map sections). It then receives a DOI on Zenodo, with you (your ORCID iD) and OSCR as its creators; the code itself is not deposited.
The map's fingerprint: sha256:9c43b12fee404c79…
Add the badge to the code's README
If you are an author or a maintainer of this paper's code, you can add this badge. It says what OSCR knows of the paper (its code, its validated tracing map) and links the code to this page. Paste one of these snippets under the README's title. Keep the two marks around it, so that the badge can be replaced in place and is never added twice. OSCR changes nothing in your repository.
Markdown
<!-- oscr-badge:start -->
[](https://openscicode.org/badge/doi/10.1371/journal.pcbi.1014523)
<!-- oscr-badge:end -->reStructuredText
.. oscr-badge:start
.. image:: https://openscicode.org/badge/doi/10.1371/journal.pcbi.1014523.svg
:target: https://openscicode.org/badge/doi/10.1371/journal.pcbi.1014523
:alt: OSCR
.. oscr-badge:endHTML
<!-- oscr-badge:start -->
<a href="https://openscicode.org/badge/doi/10.1371/journal.pcbi.1014523"><img src="https://openscicode.org/badge/doi/10.1371/journal.pcbi.1014523.svg" alt="OSCR"></a>
<!-- oscr-badge:end -->On GitHub, open the README, choose Edit (the pencil), paste the snippet under the title, then "Commit changes".
If you choose to, you can have the badge kept up to date for you, with oscr badge --write from the command line or with the GitHub Action in your repository's workflows. Every other form and option (a card, AsciiDoc, LaTeX, shields.io) is on the badge page.
Request its removal
To ask OSCR to remove this record, the copies of its authors' scripts or its tracing map, use the removal request page: signed in, you say who you are, what to remove and why, then review and confirm the request. Published rules decide every request (how).
Discussion, reproductions, activity
Discussion: code errors and mismatches between the code and the paper about this paper and its code, from readers and its authors, beside the paper and its tracing map.
Report a mismatch between the code and the paper · Report a code error (signed in)
Reproductions: reports from readers who ran the authors' code and did not get the paper's result, what they ran, with which environment, commit and data.
Report a reproduction failure (signed in)
Versions of its code: the releases of its code tied to a version of this paper (the preprint, the accepted manuscript, the version of record…), each with the tracing map versioned with it.
Activity: what happens around this paper: new versions of its record, its map's validation, discussions and reproductions. It opens with sign-in.
