OSCR

Coherent-resonant netting: disorder-enhanced selectivity from transient wave-like dynamics on biological connectomes.

Code ↔ Paper

16 matches between paragraphs of the paper and lines of its authors' code, computed by the harvester (lexical-v1). Click a colored paragraph or line to see its counterpart.

The 16 matches
  1. [1] § Methods › Controls (competitors) and surrogate networks ↔ experiments/drosophila/A8_4_5/A8_4_5_bundle_localization_arch/A8_5_architecture_dependence.py, lines 337–403 · score 0.86 · lesion_KC_MBON, lesion_drop, n_surrogates, n_trials, architecture dependence, rewired
  2. [2] § Methods › Substrates and rationale ↔ experiments/bridgeA_scripts/A2_freeze_benchmark_config.py, lines 306–384 · score 0.80 · k_source, k_target, max_hops, active subgraph, PN, MBON
  3. [3] § Methods › Simulation parameters ↔ experiments/step6_release_candidate/CRN_step6_release_candidate/steps/step2_repro_bundle/CRN_step2_repro_bundle/step2_cortex_transport/run_cortex_transport_eps_sweep.py, lines 1–39 · score 0.68 · diagonal disorder amplitude, temperature parameter, T_env
  4. [4] § Methods › Model–substrate correspondence ↔ experiments/bridgeA_scripts/A3_run_real_graph_benchmark.py, lines 219–315 · score 0.68 · sink jump, L_sym, Hamiltonian, uv, symmetrized, Laplacian
  5. [5] § The CRN framework › Two-factor mechanism: coherence × topology ↔ experiments/bridgeA_scripts/A3_run_real_graph_benchmark.py, lines 219–315 · score 0.65 · sink jump, L_sym, distractor node, symmetrized, coherent, graph
  6. [6] § The CRN framework › Two-regime architecture: Stage-I netting and Stage-II fixation ↔ datasets/zenodo_18379851_evolutionary_game/PUBLIC/run_step4_evolutionary_selection.py, lines 1–48 · score 0.64 · recurrent associative memory, confinement, gating, permeability, recall, dynamics
  7. [7] § Results › Architecture dependence across κ ↔ experiments/drosophila/A8_4_5/A8_4_5_bundle_localization_arch/A8_5_architecture_dependence.py, lines 4–45 · score 0.64 · Disorder Enhanced Selectivity, Architecture dependence, mushroom body, confidence, lesion, variant
  8. [8] § Results › Architecture dependence across κ ↔ experiments/drosophila/A8_6/A8_6_postprocess_A85.py, lines 168–243 · score 0.60 · P_good, pT_min, coverage end, lesion, variants, rewiring
  9. [9] § Methods › Statistical analysis ↔ experiments/elegans_touch_circuit/crn_nematode_pipeline.py, lines 132–173 · score 0.60 · elegans touch circuit, expm multiply, Liouvillian, CRN
  10. [10] § The CRN framework › Two-regime architecture: Stage-I netting and Stage-II fixation ↔ datasets/zenodo_18379851_evolutionary_game/PUBLIC/run_cortex_transport.py, lines 1–66 · score 0.60 · associative memory, inter, leaks, permeability, inhibitory, recurrent
  11. [11] § Methods › Model–substrate correspondence ↔ experiments/bridgeA_scripts/A2_freeze_benchmark_config.py, lines 1–36 · score 0.58 · active subgraph, Drosophila larva, PN, MBON, hop, benchmark
  12. [12] § Methods › Model–substrate correspondence ↔ experiments/bridgeA_scripts/A2_freeze_benchmark_config.py, lines 1–36 · score 0.55 · mushroom body, canonical, PN, MBON, subgraph, hop
  13. [13] § Methods › Statistical analysis ↔ experiments/drosophila/A8_analysis/A8_1_uncertainty_analysis.py, lines 262–307 · score 0.55 · coverage_end, Uncertainty, Selectivity_end, bootstrap, curves, model
  14. [14] § The CRN framework › Two-regime architecture: Stage-I netting and Stage-II fixation ↔ datasets/zenodo_18379851_evolutionary_game/PUBLIC/run_step3_architecture_tradeoff.py, lines 241–291 · score 0.54 · probability mass, t_end, global, memory, architectural, distractor
  15. [15] § Methods › Statistical analysis ↔ experiments/elegans_touch_circuit/crn_graph_topology_metrics.py, lines 412–463 · score 0.54 · elegans touch circuit, human, seeds, CRN, graph
  16. [16] § Methods › Model–substrate correspondence ↔ experiments/bridgeA_stepA1_real_connectome/CRN_bridgeA_stepA1_real/scripts/run_stepA1_real_connectome.py, lines 541–664 · score 0.53 · PN nodes, MBON nodes, subgraph, larva, connectome

Paper

Loaded from Europe PMC by your browser, not stored by OSCR: doi.org · Europe PMC

The paper is loaded when this pane is shown.

The authors' code

Python · 481 lines · 16 KB · MIT · 3 matches

  1. #!/usr/bin/env python3
  2. # -*- coding: utf-8 -*-
  3. """
  4. A2_freeze_benchmark_config.py
  6. Step A.2 (Drosophila larva / Mushroom Body): Freeze a reproducible benchmark config
  7. on top of the real connectome graph produced in Step A.1.
  9. What it does:
  10. 1) Loads GraphML(s) from A.1 outputs (core and/or extended).
  11. 2) Detects node "type" attribute and edge weight attribute.
  12. 3) Computes sanity/topology reports (reachability, path length stats).
  13. 4) Picks canonical Source / Target / Distractor sets deterministically.
  14. 5) Builds an "active subgraph" (nodes on PN→...→MBON paths, hop-limited).
  15. 6) Writes:
  16. - topology_report_<mode>.json
  17. - bench_config_<mode>.json
  18. - active_subgraph_<mode>.graphml
  19. - active_nodes_<mode>.csv
  20. - active_edges_<mode>.csv
  22. No pandas required (pure stdlib + networkx + numpy).
  23. """
  25. import argparse
  26. import csv
  27. import json
  28. import os
  29. import sys
  30. from collections import Counter, defaultdict, deque
  32. import networkx as nx
  33. import numpy as np
  36. KNOWN_TYPE_TOKENS = ("PN", "KC", "MBON", "MBIN", "FBN", "FFN")
  39. def _find_graphml_files(a1_dir: str):
  40. """Recursively find .graphml files under a directory."""
  41. out = []
  42. for root, _, files in os.walk(a1_dir):
  43. for fn in files:
  44. if fn.lower().endswith(".graphml"):
  45. out.append(os.path.join(root, fn))
  46. return sorted(out)
  49. def _guess_mode_from_path(p: str) -> str:
  50. low = os.path.basename(p).lower()
  51. if "extended" in low:
  52. return "extended"
  53. if "core" in low:
  54. return "core"
  55. # Fallback: infer from directory names
  56. low2 = p.lower()
  57. if "/extended" in low2 or "\\extended" in low2:
  58. return "extended"
  59. if "/core" in low2 or "\\core" in low2:
  60. return "core"
  61. return "unknown"
  64. def _detect_node_type_attr(G: nx.Graph):
  65. """
  66. Detect node attribute containing the coarse cell type.
  67. Heuristic: attribute whose values contain tokens PN/KC/MBON etc.
  68. """
  69. # Collect candidate keys
  70. keys = set()
  71. for _, attrs in G.nodes(data=True):
  72. for k in attrs.keys():
  73. keys.add(k)
  75. # Score keys by how many values look like known types
  76. best_key = None
  77. best_score = -1
  78. for k in keys:
  79. vals = []
  80. for _, attrs in G.nodes(data=True):
  81. v = attrs.get(k, None)
  82. if v is None:
  83. continue
  84. vals.append(str(v))
  85. if not vals:
  86. continue
  87. score = 0
  88. for v in vals:
  89. vv = v.upper()
  90. if any(tok in vv for tok in KNOWN_TYPE_TOKENS):
  91. score += 1
  92. # Prefer keys that classify most nodes
  93. if score > best_score:
  94. best_score = score
  95. best_key = k
  97. return best_key, best_score
  100. def _detect_weight_attr(G: nx.Graph):
  101. """
  102. Detect edge attribute that represents weight (synapse count).
  103. Preference order: 'weight', 'w', 'synapses', 'count', otherwise first numeric attr.
  104. """
  105. if G.number_of_edges() == 0:
  106. return None
  107. u, v, attrs = next(iter(G.edges(data=True)))
  108. preferred = ["weight", "w", "synapses", "count", "n_syn", "n_synapses"]
  109. for k in preferred:
  110. if k in attrs:
  111. return k
  112. # Fallback: first numeric
  113. for k, val in attrs.items():
  114. try:
  115. float(val)
  116. return k
  117. except Exception:
  118. continue
  119. return None
  122. def _as_float(x, default=1.0):
  123. try:
  124. return float(x)
  125. except Exception:
  126. return default
  129. def _node_type(G: nx.Graph, n, type_key: str):
  130. v = G.nodes[n].get(type_key, None)
  131. if v is None:
  132. return "UNKNOWN"
  133. return str(v)
  136. def _split_types(G: nx.DiGraph, type_key: str):
  137. """
  138. Return dict of {coarse_type: set(nodes)}. Uses substring matching.
  139. """
  140. buckets = defaultdict(set)
  141. for n in G.nodes():
  142. t = _node_type(G, n, type_key).upper()
  143. if "MBON" in t:
  144. buckets["MBONs"].add(n)
  145. elif "KC" in t:
  146. buckets["KCs"].add(n)
  147. elif "PN" in t:
  148. buckets["PNs"].add(n)
  149. elif "MBIN" in t:
  150. buckets["MBINs"].add(n)
  151. elif "FBN" in t:
  152. buckets["MB-FBNs"].add(n)
  153. elif "FFN" in t:
  154. buckets["MB-FFNs"].add(n)
  155. else:
  156. buckets["OTHER"].add(n)
  157. return buckets
  160. def _edge_type_counts(G: nx.DiGraph, type_key: str):
  161. c = Counter()
  162. for u, v in G.edges():
  163. tu = _node_type(G, u, type_key)
  164. tv = _node_type(G, v, type_key)
  165. c[f"{tu}->{tv}"] += 1
  166. return dict(c)
  169. def _weighted_out_degree(G: nx.DiGraph, nodes, weight_key: str):
  170. scores = {}
  171. for n in nodes:
  172. s = 0.0
  173. for _, v, attrs in G.out_edges(n, data=True):
  174. s += _as_float(attrs.get(weight_key, 1.0), 1.0)
  175. scores[n] = s
  176. return scores
  179. def _weighted_in_degree(G: nx.DiGraph, nodes, weight_key: str):
  180. scores = {}
  181. for n in nodes:
  182. s = 0.0
  183. for u, _, attrs in G.in_edges(n, data=True):
  184. s += _as_float(attrs.get(weight_key, 1.0), 1.0)
  185. scores[n] = s
  186. return scores
  189. def _multi_source_bfs_limited(G: nx.DiGraph, sources, max_hops: int):
  190. """
  191. Return dict {node: dist} for nodes within max_hops from any source (directed).
  192. """
  193. dist = {}
  194. q = deque()
  195. for s in sources:
  196. dist[s] = 0
  197. q.append(s)
  198. while q:
  199. u = q.popleft()
  200. du = dist[u]
  201. if du >= max_hops:
  202. continue
  203. for v in G.successors(u):
  204. if v in dist:
  205. continue
  206. dist[v] = du + 1
  207. q.append(v)
  208. return dist
  211. def _path_length_stats(G: nx.DiGraph, sources, targets):
  212. """
  213. Compute directed shortest-path lengths from any source to each target.
  214. """
  215. # BFS from all sources (unweighted hop-count)
  216. dist = _multi_source_bfs_limited(G, sources, max_hops=10**9)
  217. lens = []
  218. unreachable = 0
  219. for t in targets:
  220. if t in dist:
  221. lens.append(dist[t])
  222. else:
  223. unreachable += 1
  224. if lens:
  225. arr = np.array(lens, dtype=float)
  226. stats = {
  227. "n_targets": int(len(targets)),
  228. "n_reachable": int(len(lens)),
  229. "n_unreachable": int(unreachable),
  230. "min": float(np.min(arr)),
  231. "p25": float(np.percentile(arr, 25)),
  232. "median": float(np.median(arr)),
  233. "mean": float(np.mean(arr)),
  234. "p75": float(np.percentile(arr, 75)),
  235. "max": float(np.max(arr)),
  236. }
  237. else:
  238. stats = {
  239. "n_targets": int(len(targets)),
  240. "n_reachable": 0,
  241. "n_unreachable": int(unreachable),
  242. }
  243. return stats
  246. def _write_csv_nodes(path, rows):
  247. with open(path, "w", newline="", encoding="utf-8") as f:
  248. w = csv.DictWriter(f, fieldnames=list(rows[0].keys()))
  249. w.writeheader()
  250. for r in rows:
  251. w.writerow(r)
  254. def _write_csv_edges(path, rows):
  255. with open(path, "w", newline="", encoding="utf-8") as f:
  256. w = csv.DictWriter(f, fieldnames=list(rows[0].keys()))
  257. w.writeheader()
  258. for r in rows:
  259. w.writerow(r)
  262. def freeze_one(graphml_path: str, out_dir: str, k_source: int, k_target: int, max_hops: int, seed: int):
  263. mode = _guess_mode_from_path(graphml_path)
  264. print(f"\n[A2] Loading GraphML ({mode}): {graphml_path}")
  266. G = nx.read_graphml(graphml_path)
  267. if not isinstance(G, nx.DiGraph):
  268. # GraphML can load as Graph; if so, treat as directed for safety
  269. G = nx.DiGraph(G)
  271. type_key, type_score = _detect_node_type_attr(G)
  272. if type_key is None:
  273. raise RuntimeError("Could not detect node-type attribute in GraphML nodes.")
  274. weight_key = _detect_weight_attr(G)
  275. if weight_key is None:
  276. raise RuntimeError("Could not detect edge-weight attribute in GraphML edges.")
  278. # Normalize weight attribute to float for all edges
  279. for u, v, attrs in G.edges(data=True):
  280. attrs[weight_key] = _as_float(attrs.get(weight_key, 1.0), 1.0)
  282. buckets = _split_types(G, type_key)
  283. pns = sorted(list(buckets.get("PNs", [])))
  284. kcs = sorted(list(buckets.get("KCs", [])))
  285. mbons = sorted(list(buckets.get("MBONs", [])))
  287. node_type_counts = {k: len(v) for k, v in buckets.items() if len(v) > 0}
  289. # Simple sanity
  290. isolated = [n for n in G.nodes() if (G.in_degree(n) + G.out_degree(n)) == 0]
  291. n_isolated = len(isolated)
  293. # Weighted degree for picking sources/targets
  294. rng = np.random.default_rng(seed)
  296. pn_scores = _weighted_out_degree(G, pns, weight_key)
  297. # take top-k_source by weighted out-degree; tie-break by node id for determinism
  298. pns_sorted = sorted(pns, key=lambda n: (-pn_scores.get(n, 0.0), str(n)))
  299. source_nodes = pns_sorted[: min(k_source, len(pns_sorted))]
  301. mbon_scores = _weighted_in_degree(G, mbons, weight_key)
  302. mbons_sorted = sorted(mbons, key=lambda n: (-mbon_scores.get(n, 0.0), str(n)))
  303. target_nodes = mbons_sorted[: min(k_target, len(mbons_sorted))]
  304. distractor_nodes = mbons_sorted[min(k_target, len(mbons_sorted)) : min(2 * k_target, len(mbons_sorted))]
  306. # Reachability stats (any PN -> MBON)
  307. path_stats_all = _path_length_stats(G, sources=pns, targets=mbons)
  308. path_stats_sel = _path_length_stats(G, sources=source_nodes, targets=target_nodes)
  310. # Active subgraph: forward-reachable from selected sources within max_hops AND
  311. # reverse-reachable to selected targets within max_hops.
  312. forward = _multi_source_bfs_limited(G, source_nodes, max_hops=max_hops)
  313. Grev = G.reverse(copy=False)
  314. backward = _multi_source_bfs_limited(Grev, target_nodes, max_hops=max_hops)
  316. active_nodes = set(forward.keys()).intersection(set(backward.keys()))
  317. # Always include selected endpoints
  318. active_nodes.update(source_nodes)
  319. active_nodes.update(target_nodes)
  320. active_nodes.update(distractor_nodes)
  322. H = G.subgraph(active_nodes).copy()
  324. # Edge-type counts (coarse)
  325. edge_type_counts = Counter()
  326. for u, v in H.edges():
  327. tu = _node_type(H, u, type_key)
  328. tv = _node_type(H, v, type_key)
  329. edge_type_counts[f"{tu}->{tv}"] += 1
  331. # Build reports
  332. def _node_label(n):
  333. # Try common label keys; else return node id
  334. attrs = G.nodes[n]
  335. for k in ("label", "name", "id", "cell_id"):
  336. if k in attrs and attrs[k] not in (None, ""):
  337. return str(attrs[k])
  338. return str(n)
  340. selection = {
  341. "sources": [{"node": str(n), "label": _node_label(n), "w_out": pn_scores.get(n, 0.0)} for n in source_nodes],
  342. "targets": [{"node": str(n), "label": _node_label(n), "w_in": mbon_scores.get(n, 0.0)} for n in target_nodes],
  343. "distractors": [{"node": str(n), "label": _node_label(n), "w_in": mbon_scores.get(n, 0.0)} for n in distractor_nodes],
  344. }
  346. topo_report = {
  347. "mode": mode,
  348. "graphml": os.path.abspath(graphml_path),
  349. "detected": {"node_type_attr": type_key, "node_type_score": int(type_score), "weight_attr": weight_key},
  350. "counts_full": {"N_nodes": int(G.number_of_nodes()), "N_edges": int(G.number_of_edges()), "N_isolated": int(n_isolated)},
  351. "counts_types_full": node_type_counts,
  352. "path_lengths_all_PN_to_all_MBON": path_stats_all,
  353. "path_lengths_selected_sources_to_selected_targets": path_stats_sel,
  354. "selection": selection,
  355. "active_subgraph": {"N_nodes": int(H.number_of_nodes()), "N_edges": int(H.number_of_edges()), "max_hops": int(max_hops)},
  356. "edge_type_counts_active": dict(edge_type_counts),
  357. }
  359. bench_config = {
  360. "mode": mode,
  361. "graphml_source": os.path.abspath(graphml_path),
  362. "node_type_attr": type_key,
  363. "weight_attr": weight_key,
  364. "seed": int(seed),
  365. "k_source": int(k_source),
  366. "k_target": int(k_target),
  367. "max_hops": int(max_hops),
  368. "source_nodes": [str(n) for n in source_nodes],
  369. "target_nodes": [str(n) for n in target_nodes],
  370. "distractor_nodes": [str(n) for n in distractor_nodes],
  371. "active_nodes": [str(n) for n in sorted(active_nodes, key=str)],
  372. # Simulation defaults (editable later)
  373. "sim_defaults": {
  374. "gamma": 1.0,
  375. "eta_sink": 1.0,
  376. "kappa_grid": [1e-3, 3e-3, 1e-2, 3e-2, 1e-1, 3e-1, 1.0, 3.0, 10.0],
  377. "T_max": 10.0,
  378. "dt": 0.05,
  379. "disorder": {"kind": "none", "epsilon": 0.0, "seed": int(seed)},
  380. },
  381. "selection_human_readable": selection,
  382. }
  384. os.makedirs(out_dir, exist_ok=True)
  386. # Write JSONs
  387. topo_path = os.path.join(out_dir, f"topology_report_{mode}.json")
  388. cfg_path = os.path.join(out_dir, f"bench_config_{mode}.json")
  389. with open(topo_path, "w", encoding="utf-8") as f:
  390. json.dump(topo_report, f, indent=2, ensure_ascii=False)
  391. with open(cfg_path, "w", encoding="utf-8") as f:
  392. json.dump(bench_config, f, indent=2, ensure_ascii=False)
  394. # Write active subgraph
  395. subgraph_path = os.path.join(out_dir, f"active_subgraph_{mode}.graphml")
  396. nx.write_graphml(H, subgraph_path)
  398. # Write nodes/edges CSV for convenience
  399. nodes_rows = []
  400. for n, attrs in H.nodes(data=True):
  401. row = {"node": str(n), "cell_type": str(attrs.get(type_key, ""))}
  402. # store a couple of optional labels if exist
  403. for k in ("label", "name"):
  404. if k in attrs:
  405. row[k] = str(attrs.get(k))
  406. nodes_rows.append(row)
  408. edges_rows = []
  409. for u, v, attrs in H.edges(data=True):
  410. row = {"u": str(u), "v": str(v), "weight": float(attrs.get(weight_key, 1.0))}
  411. # also preserve edge type if present
  412. for k in ("type", "edge_type"):
  413. if k in attrs:
  414. row[k] = str(attrs.get(k))
  415. edges_rows.append(row)
  417. nodes_csv = os.path.join(out_dir, f"active_nodes_{mode}.csv")
  418. edges_csv = os.path.join(out_dir, f"active_edges_{mode}.csv")
  419. if nodes_rows:
  420. _write_csv_nodes(nodes_csv, nodes_rows)
  421. if edges_rows:
  422. _write_csv_edges(edges_csv, edges_rows)
  424. # Print summary
  425. print(f"[A2:{mode}] node_type_attr='{type_key}', weight_attr='{weight_key}'")
  426. print(f"[A2:{mode}] FULL: N={G.number_of_nodes()} E={G.number_of_edges()} (isolated={n_isolated})")
  427. print(f"[A2:{mode}] ACTIVE: N={H.number_of_nodes()} E={H.number_of_edges()} (max_hops={max_hops})")
  428. print(f"[A2:{mode}] Sources={len(source_nodes)} Targets={len(target_nodes)} Distractors={len(distractor_nodes)}")
  429. print(f"[A2:{mode}] Wrote:")
  430. print(f" - {topo_path}")
  431. print(f" - {cfg_path}")
  432. print(f" - {subgraph_path}")
  433. if nodes_rows:
  434. print(f" - {nodes_csv}")
  435. if edges_rows:
  436. print(f" - {edges_csv}")
  438. return topo_path, cfg_path, subgraph_path
  441. def main():
  442. ap = argparse.ArgumentParser()
  443. ap.add_argument("--a1_dir", default=None, help="Folder where Step-A1 wrote GraphML(s). If set, auto-discovers .graphml files.")
  444. ap.add_argument("--graphml", default=None, nargs="*", help="Explicit GraphML file path(s). Overrides --a1_dir.")
  445. ap.add_argument("--out_dir", default="A2_outputs", help="Output folder.")
  446. ap.add_argument("--k_source", type=int, default=10, help="Number of PN source nodes to freeze.")
  447. ap.add_argument("--k_target", type=int, default=5, help="Number of MBON target nodes to freeze.")
  448. ap.add_argument("--max_hops", type=int, default=4, help="Hop limit used to define the active subgraph.")
  449. ap.add_argument("--seed", type=int, default=42, help="RNG seed for deterministic selection.")
  450. args = ap.parse_args()
  452. graphml_files = []
  453. if args.graphml:
  454. graphml_files = [os.path.abspath(os.path.expanduser(p)) for p in args.graphml]
  455. elif args.a1_dir:
  456. a1 = os.path.abspath(os.path.expanduser(args.a1_dir))
  457. graphml_files = _find_graphml_files(a1)
  458. if not graphml_files:
  459. raise RuntimeError(f"No .graphml files found under: {a1}")
  460. else:
  461. raise RuntimeError("Provide either --graphml <file(s)> or --a1_dir <folder>.")
  463. out_dir = os.path.abspath(os.path.expanduser(args.out_dir))
  464. os.makedirs(out_dir, exist_ok=True)
  466. # Freeze each graphml found
  467. for p in graphml_files:
  468. freeze_one(
  469. graphml_path=p,
  470. out_dir=out_dir,
  471. k_source=args.k_source,
  472. k_target=args.k_target,
  473. max_hops=args.max_hops,
  474. seed=args.seed,
  475. )
  477. print("\n[A2] DONE")
  480. if __name__ == "__main__":
  481. main()

A2_freeze_benchmark_config.py at commit e12f45d, under MIT · at the source

Overview

Authors: Oleg Dolgikh1
ORCID iDs: Oleg Dolgikh
  1. Independent Researcher, Sant Cugat del Vallès, Spain
Journal: Frontiers in computational neuroscience, volume 20, article 1813959
Dates: received 19 February 2026; accepted 15 April 2026; published online 13 May 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.3389/fncom.2026.1813959 · PMID 42211247 · PMCID PMC13212248 · OpenAlex W7161008748
Open access: gold, a free copy (OpenAlex)
Status: code verified
Methods: Connectivity, Statistics, Single-unit activity, calcium imaging
Keywords: connectome transport, decision architecture, dephasing, disorder-enhanced selectivity, mechanistically neutral model, structural graph
Topic: Spectroscopy and Quantum Chemical Studies (Atomic and Molecular Physics, and Optics, Physics and Astronomy), according to OpenAlex
Citations: not cited yet (Europe PMC); 33 references in the paper

Abstract

Biological agents face an energy-information bottleneck: inference requires rapid exploration of large hypothesis spaces, yet high-gain spiking is metabolically expensive. We propose Coherent-Resonant Netting (CRN) as a two-regime decision architecture in which a low-amplitude Stage-I transport process filters candidate routes on a structural graph before a higher-cost Stage-II commitment step. In this manuscript, we model Stage-I only, using a mechanistically neutral GKSL open-system proxy with dephasing rate κ and diagonal disorder ε. The model does not imply microscopic quantum coherence in neural tissue. In two biological connectome benchmarks, selectivity improves under partial coherence. In a compact Caenorhabditis elegans touch-circuit benchmark, the wave proxy yields a 1.39 × improvement in peak target absorption over a matched low-temperature classical baseline. In a Drosophila larva mushroom-body motif (N = 243 active nodes), selectivity shows a pronounced non-monotonic disorder-enhanced selectivity peak at intermediate ε, strongest in the native topology and strongly attenuated by degree-preserving rewiring. A permutation-based reanalysis confirms the pre-specified DES contrast (ε = 3 versus ε = 0, p = 0.010), and the effect weakens progressively with increasing dephasing, becoming non-significant in the high-κ regime. We interpret these findings as evidence for a topology-sensitive, dephasing-dependent Stage-I routing effect on biological connectomes. Broader energetic and evolutionary implications remain conditional because Stage-II commitment is not explicitly modeled here.

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 16 matches between paragraphs and lines of code.

Zenodo 18338260

License: MIT
State: the link answers, verified on 28 September 2026
Evidence: files inventoried
Size: 1 file
Software Heritage: not checked
Found in: “Data availability statement”
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Availability: 1 check, the latest on 28 September 2026: the link answers (HTTP 200)
  • 28 September 2026: the link answers (HTTP 200)
At the source: doi.org/10.5281/zenodo.18338260

ovdspb-code/crn_4.1

License: MIT
State: the link answers, verified on 28 September 2026
Evidence: files inventoried
Commit: e12f45d5f428b101784e624953ddc4aea5d4317f, 19 February 2026
Languages: Python (48), Shell (1)
Size: 384 files, 49 scripts
Software Heritage: not archived
Found in: the Zenodo archive record
Holds: README, license file, CITATION.cff, environment (requirements.txt, env/requirements.txt, R12-CROWN/requirements.txt, experiments/bridgeA_stepA1_real_connectome/CRN_bridgeA_stepA1_real/requirements_a1.txt, experiments/step6_release_candidate/CRN_step6_release_candidate/env/requirements.txt, experiments/step6_release_candidate/CRN_step6_release_candidate/steps/step4_evolutionary_selection_bundle/env/requirements.txt, experiments/step6_release_candidate/CRN_step6_release_candidate/steps/step2_repro_bundle/CRN_step2_repro_bundle/env/requirements.txt, experiments/step6_release_candidate/CRN_step6_release_candidate/steps/step3_architecture_tradeoff_bundle/CRN_step3_bundle/env/requirements.txt, experiments/step6_release_candidate/CRN_step6_release_candidate/steps/step5_consolidated_evidence_bundle/CRN_step5_consolidated_evidence_bundle/env/requirements.txt), tests, documentation
Not found: continuous integration
Tools: NumPy (45 files), SciPy (24 files), Matplotlib (22 files), pandas (18 files), NetworkX (12 files)
Availability: 1 check, the latest on 28 September 2026: the link answers
  • 28 September 2026: the link answers
51 files
At the source: github.com/ovdspb-code/CRN_4.1/tree/v4.1.1-fcn-submission

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;
  • 49 scripts, each with its path and the digest of its content;
  • 16 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

Datasets cited

Data availability statement

Datasets and supplementary exploratory artifacts are archived on Zenodo: auxiliary evolutionary game-theory dataset (https://doi.org/10.5281/zenodo.18379850), C. elegans touch-circuit artifacts (https://doi.org/10.5281/zenodo.18432680), Drosophila larva mushroom-body benchmark artifacts (https://doi.org/10.5281/zenodo.18697116), and mouse proxy artifacts (https://doi.org/10.5281/zenodo.18433186). The code used in this study is archived on Zenodo: https://doi.org/10.5281/zenodo.18338260.

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, 28 September 2026: the first record

Recorded: type, language, journal, volume, pages, dates, 1 author, 6 keywords, 33 references.

Cite

This paper

Dolgikh, O. (2026). Coherent-resonant netting: disorder-enhanced selectivity from transient wave-like dynamics on biological connectomes. Frontiers in computational neuroscience, 20, 1813959. https://doi.org/10.3389/fncom.2026.1813959

BibTeX

@article{dolgikh2026coherent,
author = {Dolgikh, Oleg},
title = {{Coherent-resonant netting: disorder-enhanced selectivity from transient wave-like dynamics on biological connectomes}},
journal = {Frontiers in computational neuroscience},
year = {2026},
month = may,
volume = {20},
pages = {1813959},
publisher = {Frontiers Media SA},
issn = {1662-5188},
doi = {10.3389/fncom.2026.1813959},
url = {https://doi.org/10.3389/fncom.2026.1813959},
pmid = {42211247},
pmcid = {PMC13212248}
}

RIS

TY - JOUR
AU - Dolgikh, Oleg
TI - Coherent-resonant netting: disorder-enhanced selectivity from transient wave-like dynamics on biological connectomes
T2 - Frontiers in computational neuroscience
J2 - Front Comput Neurosci
PY - 2026
DA - 2026/05/13
VL - 20
SP - 1813959
SN - 1662-5188
PB - Frontiers Media SA
DO - 10.3389/fncom.2026.1813959
UR - https://doi.org/10.3389/fncom.2026.1813959
LA - en
ER -

CSL-JSON

{
"id": "10.3389/fncom.2026.1813959",
"type": "article-journal",
"title": "Coherent-resonant netting: disorder-enhanced selectivity from transient wave-like dynamics on biological connectomes",
"container-title": "Frontiers in computational neuroscience",
"author": [
{
"family": "Dolgikh",
"given": "Oleg"
}
],
"container-title-short": "Front Comput Neurosci",
"volume": "20",
"page": "1813959",
"DOI": "10.3389/fncom.2026.1813959",
"PMID": "42211247",
"PMCID": "PMC13212248",
"ISSN": "1662-5188",
"publisher": "Frontiers Media SA",
"URL": "https://doi.org/10.3389/fncom.2026.1813959",
"language": "en",
"issued": {
"date-parts": [
[
2026,
5,
13
]
]
}
}

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.1007/s00422-026-01063-3 [code]
Increased firing rates monotonically expand neuronal coding bandwidth.
Journal: Biological cybernetics
In common: pandas, SciPy, Matplotlib, 1 other tool, 3 references
[2] doi:10.1038/s41598-026-52140-3 [code]
Energy-efficient information processing and eligibility-trace plasticity in the Drosophila optic lobe connectome.
Journal: Scientific reports
In common: NetworkX, pandas, SciPy, 2 other tools, 2 references
[3] doi:10.1073/pnas.2531706123 [code]
Metabolism-weighted brain connectome reveals synaptic integration and vulnerability to neurodegeneration.
Journal: Proceedings of the National Academy of Sciences of the United States of America
In common: NetworkX, pandas, SciPy, 2 other tools, 2 references
[4] doi:10.1038/s41467-026-74357-6 [code]
Hippocampo-neocortical interaction as compressive retrieval-augmented generation.
Journal: Nature communications
In common: NetworkX, pandas, SciPy, 2 other tools, 2 references
[5] doi:10.1038/s42003-026-10646-6 [code]
Energy paradox in REM sleep: balancing supply and consumption in brain metabolism.
Journal: Communications biology
In common: SciPy, Matplotlib, NumPy, 3 references
[6] doi:10.1371/journal.pcbi.1014152 [code]
Synchronization properties in C. elegans: Relating behavioral circuits to structural and functional neuronal connectivity.
Journal: PLoS computational biology
In common: NetworkX, pandas, SciPy, 2 other tools, 1 reference
[7] doi:10.1038/s41467-026-74466-2 [code]
Neuromorphic hierarchical modular reservoirs.
Journal: Nature communications
In common: NetworkX, pandas, SciPy, 2 other tools, 1 reference
[8] doi:10.1038/s41467-026-75959-w [code]
Charting higher-order models of brain function beyond pairwise interactions.
Journal: Nature communications
In common: NetworkX, pandas, SciPy, 2 other tools, 1 reference
[9] doi:10.1371/journal.pcbi.1014730 [code]
A unified model of short- and long-term plasticity: Effects on network connectivity and information capacity.
Journal: PLoS computational biology
In common: NetworkX, pandas, SciPy, 2 other tools, 1 reference
[10] doi:10.1038/s41586-026-10735-w [code]
Distributed control circuits across a brain-and-cord connectome.
Journal: Nature
In common: NetworkX, pandas, SciPy, 2 other tools, 1 reference

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.

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: questions and error reports about this paper and its code, from signed-in readers and its authors. It opens with sign-in.

Reproductions: reports from readers who ran the authors' code: what they reproduced, with which environment, commit and data. It opens with sign-in.

Activity: what happens around this paper: new versions of its record, its map's validation, discussions and reproductions. It opens with sign-in.