{"id":"375ce9c1-a1c8-4341-b328-68ce37ffb917","arxiv_id":"2608.08479","paper_version":1,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":4.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":4,"one_line_summary":"The paper presents SuperNeuroMAT, an open-source CPU SNN simulator whose matrix-based LIF update with dense and sparse modes outperforms four established simulators in runtime and memory across most tested network sizes.","lead":"SuperNeuroMAT is a Python spiking neural network simulator that uses NumPy and SciPy matrix operations to run LIF neurons in dense and sparse modes, reporting large speedups over NEST, Brian2, BindsNET, and snnTorch on CPU benchmarks. It also demonstrates the same simulator on digit classification, citation graphs, event-based vision, shortest paths, and arithmetic circuits.","discovery_kind":"extension","skeptic_critique":{"model":"deepseek-v4-flash","headline":"The cross-simulator speed claim rests on a degenerate boundary-case LIF configuration whose semantics are not demonstrated to match across frameworks, so the headline 'consistently outperforms' is not yet supported for realistic SNN workloads.","rationale":"The paper's strongest claim is the cross-simulator comparison, and its load-bearing assumption is that matching zero-threshold, memoryless, unit-delay delta semantics makes runtime and memory differences attributable to implementation efficiency. The reader's weakest_assumption identifies exactly this point, and I agree. The benchmark's chosen configuration is a boundary case: with infinite leak and zero threshold, the network reduces to a thresholded matrix-vector product, which is the operation SuperNeuroMAT is explicitly engineered to accelerate. The paper asserts semantic equivalence but provides no spike-train equality verification, and the parameterizations across frameworks are not obviously identical to SuperNeuroMAT's clamp-to-reset leak. In addition, the large timing difference between Section 6.1.1 (STDP enabled, 508 s for 10,000 fully connected neurons in dense mode) and Section 6.1.2 (7.18 s for the same configuration) strongly suggests that STDP was not part of the cross-simulator comparison, further limiting the scope of the headline claim. A concrete rerun with finite leak, positive threshold, and verified spike-train equality would settle whether the 10-215x speedups generalize. Because the reader's CONDITIONAL verdict already requires addressing benchmark equality assumptions and qualifying the headline, my stress-test does not change the verdict; it sharpens the specific test needed.","tokens_in":22294,"tokens_out":8379,"duration_ms":91316,"concrete_test":"Rerun the Section 6.1.2 benchmark at the 10,000-neuron, p=0.01 and p=1.0 cells with finite leak (lambda=0.05), positive threshold (nu=1.0), reset rho=0, unit refractory period, and the same external spike schedule, after verifying spike-train equality across NEST, Brian2, BindsNET, snnTorch, and SuperNeuroMAT. If the reported SuperNeuroMAT speedups over the other simulators drop by more than a factor of two, or if the spike trains do not match across frameworks, the headline advantage is an artifact of the degenerate infinite-leak, zero-threshold configuration rather than a general property of the simulator.","verdict_should_be":"UNCHANGED","load_bearing_attack":"The central performance claim depends entirely on the cross-simulator benchmark in Section 6.1.2. That benchmark deliberately reduces every network to zero-threshold, memoryless (infinite-leak) LIF neurons with unit-delay delta synapses. In SuperNeuroMAT's leak model, an infinite leak clamps the membrane potential back to the reset state at every step, so the dynamics collapse to a thresholded matrix-vector multiply with no temporal integration, no finite-leak memory, and no refractory interaction. This is precisely the operation that SuperNeuroMAT's dense NumPy and sparse SciPy backends are specialized for, while event-driven simulators such as NEST and Brian2 carry event-queue and per-spike object overhead that is most damaging in exactly this saturated, high-activity regime. The paper asserts that matching semantics makes differences attributable to implementation efficiency, but it reports no spike-train equivalence check, and the parameterizations actually used (BindsNET LIFNodes with 'near-zero decay', snnTorch Leaky with 'zero decay', NEST iaf_psc_delta, and a custom Brian2 equation set) are not verified to reproduce SuperNeuroMAT's clamp-to-reset leak behavior. Even granting exact semantic equality, the resulting 10-215x speedups are evidence only for this boundary configuration; they do not support 'consistently outperforms' for the finite-leak, refractory, STDP-enabled workloads used in the paper's own N-CARS, ASL-DVS, citation-network, and shortest-path examples. A related internal signal is the discrepancy between Section 6.1.1, where 10,000-neuron fully connected dense mode with STDP enabled takes 508 s, and Section 6.1.2, where the same network size and connectivity is reported at 7.18 s; this suggests STDP was disabled in the cross-simulator benchmark, so the headline speed claim may not cover learning at all.","agreement_with_reader":"agree"},"referee_report":{"model":"deepseek-v4-flash","summary":"SuperNeuroMAT is a Python/NumPy/SciPy SNN simulator that expresses LIF membrane updates (Eq. 9), spike generation (Eq. 10), refractory dynamics (Eq. 11), and STDP learning (Eqs. 12-19) as vectorized dense or sparse operations, with synaptic delays realized as chains of delay neurons. The paper claims (i) a novel matrix-based formulation that enables roughly 10,000-neuron dense and 100,000-neuron sparse simulations on commodity CPUs; (ii) consistent outperformance of NEST, Brian2, BindsNET, and snnTorch in execution speed and peak resident memory across network sizes and connection probabilities; and (iii) versatility across conventional ML (Digits, citation networks), neuromorphic vision (N-CARS, ASL-DVS), and general-purpose workloads (shortest path, 8-bit addition and multiplication). The efficiency study consists of an internal dense-versus-sparse crossover analysis (Section 6.1.1) and a cross-simulator benchmark on synthetic Erdos-Renyi graphs (Section 6.1.2) using zero-threshold, infinite-leak LIF neurons with unit-delay delta synapses. The application sections verify the shortest-path decoding against Dijkstra's algorithm and the arithmetic circuits against exact integer arithmetic.","tokens_in":22664,"tokens_out":23741,"duration_ms":214084,"significance":"If the claims are sustained, SuperNeuroMAT would be a genuinely useful contribution: a lightweight, open-source, PyPI-installable CPU simulator that combines neuroscience-style features (delay chains, refractory period, STDP) with the throughput of vectorized linear algebra, and it validates non-ML use (shortest path, arithmetic) against external ground truth with exact matches. The dense/sparse crossover analysis in Section 6.1.1 is careful and honestly reports regimes in which each mode wins. However, the headline efficiency claim rests on a boundary-case benchmark whose semantics are not verified across frameworks, the benchmark excludes the STDP operation the paper itself identifies as the dominant cost, and the STDP depression update of Eq. (17) is internally inconsistent with the stated rule. The significance is therefore conditional: it depends on re-scoping the efficiency claims to the measured regimes and correcting or verifying the learning formulation.","major_comments":[{"comment":"The cross-simulator benchmark that supports the headline efficiency claim matches all frameworks on a degenerate configuration: zero threshold, memoryless (infinite-leak) LIF neurons, unit-delay delta synapses, and, to judge from the two-orders-of-magnitude gap between the ~508 s dense runtime with STDP enabled in Section 6.1.1 and the 7.18 s dense runtime at the same size and connectivity in Section 6.1.2, STDP disabled. In SuperNeuroMAT this configuration reduces the update of Eq. (9) to a thresholded matrix-vector product with no temporal integration, no finite-leak memory, and no refractory interaction, which is precisely the operation its dense NumPy and sparse SciPy backends are specialized for; event-driven simulators such as NEST and Brian2 carry queue and per-spike object overhead that is largest in exactly this high-activity saturated regime. The assertion that matching semantics makes runtime differences attributable to implementation efficiency is not backed by a reported spike-train equivalence check across the five frameworks, and the parameterizations used (BindsNET LIFNodes with 'near-zero decay', snnTorch Leaky with 'zero decay', NEST iaf_psc_delta, and a custom Brian2 equation set) are not demonstrated to reproduce SuperNeuroMAT's clamp-to-reset leak behavior. The representativeness problem is internal to the paper: Section 5.8 identifies STDP as the dominant per-step cost (O(N^2 T_S)), and the paper's own application examples use finite leak (Section 6.2.3), refractory periods (Section 6.2.2), and 2 ms steps with fast and slow traces (Section 6.2.4), none of which is covered by the Section 6.1.2 configuration. As it stands, the 10-215x speedups support only this boundary configuration, not 'consistent' outperformance across realistic workloads; please (i) verify spike-train equivalence across frameworks, (ii) add benchmarks with finite leak, refractory periods, and STDP enabled, and (iii) scope the abstract claims to the measured regimes.","section":"6.1.2 (with 5.8, 6.1.1, 6.2.3)"},{"comment":"The abstract and Section 7 state that SuperNeuroMAT 'consistently outperforms' NEST, Brian2, BindsNET, and snnTorch on execution speed and peak resident memory 'across various network sizes and connection probabilities.' The paper's own measurements contradict this at two points. At the smallest network size, Section 6.1.2 reports that at 10 neurons NEST is 'marginally faster than SuperNeuroMAT.' At the largest scale, the same section reports that at 10,000 neurons with full connectivity SuperNeuroMAT consumes approximately the same peak memory as Brian2 and slightly more than the remaining three simulators, with the text arguing that the speed advantage 'more than compensates' for the memory shortfall. These are not minor footnotes: they fall inside the claimed domain and on the second of the two claimed metrics. The abstract and conclusion should be reworded to state the measured exceptions and the regimes in which each claim holds (for example, speed advantage for N >= 100, and memory advantage at large scale only at sparse-to-moderate connectivity).","section":"Abstract and Section 6.1.2"},{"comment":"The negative STDP update is internally inconsistent with the rule stated in Section 5.6. The text specifies that synapse (i,j) is depressed when the post-synaptic neuron j spiked before the pre-synaptic neuron i; the coincidence indicator at entry (i,j) is then s_i[t] s_j[t - t_s], i.e., an outer product of the current spike vector with the lagged spike vector (equivalently, the transpose of the potentiation outer product in Eq. (12)). Instead, Eqs. (13), (15), and (17) use the complement 1_{N x N} - s[t - t_s] s^T[t], which is equal to 1 at every entry except those exhibiting the potentiation pattern. Since the depression coefficients in Table 5 satisfy alpha^-_{ts} <= 0, this complement applies a negative update at essentially every STDP-enabled synapse at every time step, including synapses whose pre- and post-synaptic neurons have no anti-causal spiking coincidence at all. As written, Eq. (17) therefore implements a global weight decay coupled with a potentiation mask, not the causal anti-correlation rule described in the text. Because STDP is the learning mechanism behind the Digits (Section 6.2.1), citation-network (Section 6.2.2), N-CARS (Section 6.2.3), and ASL-DVS (Section 6.2.4) results, the authors should correct the derivation and report a unit-level verification (for example, analytic weight-change traces on a small two-neuron example) that the implemented update matches the stated rule.","section":"Section 5.6, Eqs. (13), (15), (17)"},{"comment":"The reported gain of 4.3 percentage points (60.7% to 65.0%) is obtained by deactivating two excitatory neurons and increasing the leak of six others from 0.05 to 0.15, where the identity of these neurons was chosen after examining spike activity associated with false positives and false negatives, and the post-intervention accuracy is then measured on the same data partition. No independent validation split is described for the selection and tuning step, so the procedure amounts to post-hoc model selection on the test set, and the 4.3-point improvement is not a valid estimate of generalization. Please perform the selection on a training subset (or use a nested validation procedure) and report accuracy on an untouched test partition, or present the intervention solely as a descriptive analysis without a generalization claim.","section":"Section 6.2.3, Approach 1"},{"comment":"The assertion that the citation-network accuracies in Table 6 (Cora 62.7%, CiteSeer 42.4%, PubMed 54.7%) are 'state-of-the-art results for spiking graph neural network models that do not incorporate features' is unsupported: no numbers from prior feature-free spiking graph methods are cited, and no topology-only baselines (for example, label propagation, degree or structural baselines, or standard GNNs such as GCN or GAT under the same feature-free constraint) are reported. Likewise, the Digits accuracy of 93% is described as 'at par with the state-of-the-art for such a two-layer SNN' without citing a comparison. Please add concrete baseline values with sources and state the experimental protocol (Planetoid splits, hyperparameters, number of runs) so that each 'state-of-the-art' or 'at par' claim is checkable.","section":"Section 6.2.2, Table 6, and Section 6.2.1"}],"minor_comments":[{"comment":"The Figure 4 caption describes the Y-axis as 'the time in seconds,' but the figure and the surrounding text plot peak resident memory in MB; please correct the caption.","section":"Figure 4 caption"},{"comment":"The notation column of the Delay row reads 'W in N^{N x N}' where the delay matrix D is intended; the symbol should be D in N^{N x N}.","section":"Table 4, Delay row"},{"comment":"No version numbers are reported for NEST, Brian2, BindsNET, snnTorch, or for NumPy/SciPy/BLAS; runtime and memory comparisons are not reproducible without these details, although the hardware description is otherwise commendably complete.","section":"Section 6.1.2"},{"comment":"The claim that the matrix-based formulation is 'unprecedented in the literature' and 'novel' is stronger than the evidence supports; tensor-based SNN libraries, including BindsNET and snnTorch which are benchmarked in this paper, already express LIF updates as vectorized matrix operations. Please soften the priority claim and attribute novelty to the specific design choices (dense/sparse auto-selection, delay chains, and the CPU-oriented engineering).","section":"Section 5.5 and Abstract"},{"comment":"The statement that BindsNET and snnTorch 'lack certain neuron or synapse parameters, for instance, synaptic delay' is not substantiated, and recent snnTorch releases support synaptic delays; please verify the claim against the current versions of both libraries.","section":"Section 2"},{"comment":"The space complexity of Eq. (19) is stated as O(S) for the sparse implementation, yet Eqs. (16)-(17) form dense N x N outer products at every time step; the total sparse space complexity does include the O(N^2 T_S) term, but the O(S) claim for the STDP update itself should be reconciled with that dense computation.","section":"Section 5.8"},{"comment":"The phrase 'as detailed in in Section 6.1' contains a duplicated word ('in in'); please correct it.","section":"Section 6, first paragraph"}],"recommendation":"major_revision","confidential_remarks":"Dear Editor: The manuscript delivers a useful, open-source CPU simulator with a clear derivation, and I have recommended major revision rather than rejection because the identified problems are fixable within the paper's scope. The two highest-risk items are (i) the internal inconsistency of the negative STDP update in Eq. (17), which undermines all the learning demonstrations unless corrected or verified, and (ii) the mismatch between the unqualified 'consistently outperforms' claim and the benchmark's boundary configuration plus the paper's own measured exceptions. The citation-network 'state-of-the-art' claim without baselines will likely draw reviewer scrutiny. I would also ask the editor to consider whether the 'unprecedented' novelty claim in Section 5.5 fits the journal's standards, since matrix-based LIF updates are standard practice in the tensor-based SNN libraries cited in the paper itself; the contribution is better framed as an engineering and systems contribution."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"SuperNeuroMAT is a real thing: a clean, open-source, pip-installable Python LIF simulator with dense and sparse backends, and the authors demo it on Digits, citation graphs, N-CARS, ASL-DVS, shortest path, and arithmetic. If you want a lightweight CPU tool for prototyping or teaching, this is worth knowing. But the headline 'consistently outperforms four established simulators' is not yet supported for realistic workloads.\n\nThe cross-simulator benchmark (Sec. 6.1.2) reduces all frameworks to zero-threshold, memoryless LIF with unit-delay delta synapses. That is essentially a thresholded matrix-vector multiply, exactly the regime where SuperNeuroMAT's NumPy/SciPy backends are strongest and where event-driven simulators like NEST and Brian2 carry the most overhead. The authors say semantics are matched but give no spike-train equivalence check, and the BindsNET/snnTorch parameterizations are not shown to reproduce SuperNeuroMAT's clamp-to-reset leak. So the 10-215x speedups apply only to this boundary case. There's also a telling internal discrepancy: 10,000 fully-connected neurons with STDP takes 508 s in Sec. 6.1.1 but 7.18 s in Sec. 6.1.2, implying STDP was off in the comparison; the speed claim probably doesn't cover learning.\n\nThe STDP equations have a real problem. Eq. 13 defines the negative update as the complement of the potentiation outer product, so depression is applied to every non-potentiated pair, not to pairs where the post-synaptic neuron fired first. That is not timing-dependent; it is global decay.\n\nOther soft spots: the 100,000-neuron claim is never demonstrated; the citation results have no baselines; the N-CARS neuron fine-tuning looks like post-hoc selection on test data.\n\nThat said, the paper is an honest engineering contribution with clear complexity analysis and a useful dense-vs-sparse crossover study. It deserves a serious referee, but the quantitative claims need to be scaled back or re-supported. Ask for: spike-train equivalence, a finite-leak benchmark, a corrected STDP rule (or a transparent statement of what it does), error bars, and citation baselines. The tool is worth having.","headline":"A genuinely useful open-source CPU SNN simulator, but the headline speed claim rests on a degenerate benchmark and the STDP rule is mis-specified.","tokens_in":23287,"tokens_out":4298,"would_cite":true,"duration_ms":41911,"reading_group":"maybe","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":[],"pacs":[],"model":"deepseek-v4-flash","headline":"The paper claims that a matrix-based formulation of LIF dynamics makes its Python SNN simulator faster and more memory-efficient than four established simulators on CPUs, while also running ML and general-purpose workloads.","keywords":["spiking neural networks","leaky integrate-and-fire","matrix-based simulation","spike-timing-dependent plasticity","neuromorphic computing","sparse matrix computation","event-based vision","CPU simulation"],"falsifier":"Re-run the Section 6.1.2 comparison at 10,000 neurons and full connectivity using finite membrane time constants, nonzero thresholds, and randomly drawn synaptic delays; if the reported runtime ranking or memory ordering changes materially, the claim that the matrix-based approach consistently outperforms the four simulators fails.","tokens_in":22109,"feed_emoji":"⚡","tokens_out":10840,"duration_ms":108528,"temperature":0.7,"pith_summary":"SuperNeuroMAT is a Python simulator that models leaky integrate-and-fire (LIF) neuron dynamics entirely as matrix and vector updates, letting one CPU compute an entire network's state in a few array operations. The paper's central claim is that this matrix-based formulation makes the simulator consistently faster and more memory-efficient than four established SNN simulators across network sizes and connection probabilities, without special hardware. A sympathetic reader would care because it suggests that ordinary laptops can simulate roughly 10,000 neurons densely and 100,000 neurons sparsely, which lowers the barrier to experimenting with spiking networks. The same simulator is also used for conventional machine learning benchmarks, neuromorphic event-based vision, and general-purpose computations such as shortest paths and binary arithmetic, arguing that one framework can span neuroscience, ML, and general workloads.","feed_headline":"Matrix-based SNN simulator claims up to 215x speedups on CPUs","feed_subtitle":"Python package runs 100,000 spiking neurons on a laptop and claims to beat four established simulators.","key_machinery":"The central object is the vectorized LIF recurrence $v[t]=v[t-1]-\\lambda+x[t]+W^T[t-1]s[t-1]$, where $v[t]$ is the membrane-potential vector, $\\lambda$ the leak vector, $x[t]$ external input, $W[t-1]$ the synaptic weight matrix, and $s[t-1]$ the previous spike vector. Around it sit the spike test $s_i[t]=1$ if $v_i[t]>\\nu_i$ and the refractory counter update $\\tau'_i[t]=\\tau_i$ on a spike, otherwise $\\max\\{0,\\tau'_i[t-1]-1\\}$. STDP is handled by forming spike-vector outer products over the learning window and adding them to the weight matrix. What this machinery does is replace per-neuron and per-synapse loops with a small number of highly optimized array operations, so each simulation time step costs $O(N^2)$ time and space in dense mode and $O(N+S)$ in sparse mode, making the CPU the bottleneck rather than Python-level bookkeeping.","core_discovery":"The discovery is that the full LIF update, including leak, input spikes, and recurrent network spikes, collapses into the vector recurrence $v[t]=v[t-1]-\\lambda+x[t]+W^T[t-1]s[t-1]$, with firing decided by the threshold test in Equation 10 and refractory periods by Equation 11. Spikes are binary vectors, so the synaptic-weight matrix multiplied by the previous spike vector delivers all incoming contributions at once. STDP learning is likewise recast as outer products $s[t-t_s]s^T[t]$ summed over the learning window, so weight updates become matrix operations rather than synapse-by-synapse loops. The authors report that this array-oriented formulation, backed by dense and sparse array libraries, simulates up to about 10,000 neurons in dense mode and 100,000 in sparse mode on standard CPUs, and that in their comparisons it finishes 100-timestep simulations of 10,000 fully connected neurons in 7.18 seconds while the slowest baseline takes over 1,500 seconds. They further claim the same codebase trains a two-layer STDP network on Digits, classifies citation-graph nodes from topology alone, learns features on event-based N-CARS and ASL-DVS data, and reproduces shortest paths and 8-bit arithmetic exactly.","pith_inferences":["If the matrix formulation, not the specific benchmark, is the source of the speed, the same equations should port almost directly to GPU array libraries; the paper only reports CPU results, so a GPU port is a natural test.","The benchmark equalizes models using zero-threshold, infinite-leak, unit-delay neurons; that degenerate configuration may be the least favorable regime for event-driven simulators, so a sweep over finite time constants and heterogeneous delays would test whether the reported speedups generalize to biologically realistic settings.","The graph and arithmetic demonstrations are small (8 nodes, 8-bit operands); trusting the general-purpose claim would be easier after stress-testing these constructions at the 100,000-neuron scale advertised for sparse mode."],"forward_implications":["At the scales tested, a single CPU node can simulate 10,000-neuron dense networks and 100,000-neuron sparse networks, so off-chip training and experimentation no longer require a GPU or an HPC allocation.","Because the 10,000-neuron, fully connected 100-timestep simulation runs in seconds rather than minutes to hours, parameter sweeps over network size, connectivity, and STDP settings become practical on a laptop.","The same update equations support both dense and sparse execution, and the simulator auto-selects the mode, so users get the faster representation without manually choosing data structures.","STDP as outer products makes learning a native, vectorized operation, which the paper demonstrates by training a two-layer network on Digits and by unsupervised feature learning on event-camera datasets.","General-purpose computations, including shortest path and 8-bit addition and multiplication, can be encoded as spike timing in the same simulator, supporting the paper's claim that one framework covers ML and non-ML workloads."],"supporting_citations":[{"why":"The discrete-event simulator provides the large-scale runtime and memory baseline that the paper's speed comparison must beat.","marker":"[27]"},{"why":"The equation-based simulator provides the code-generation baseline and one of the main runtime comparisons.","marker":"[26]"},{"why":"The PyTorch-based machine-learning simulator provides a baseline for runtime and memory across network sizes.","marker":"[31]"},{"why":"The tensor-based deep-learning simulator provides a baseline for runtime and memory in large, dense configurations.","marker":"[32]"},{"why":"The array programming library supplies the vectorized operations on which the dense execution mode is built.","marker":"[37]"},{"why":"The sparse array library supplies the sparse execution mode that handles large, sparsely connected networks.","marker":"[38]"},{"why":"The low-level linear algebra routines make the matrix-vector updates fast on CPUs.","marker":"[39]"},{"why":"Prior neuromorphic graph algorithm formulation supplies the shortest-path construction used to validate general-purpose computing.","marker":"[15]"},{"why":"Prior arithmetic-primitive encoding supplies the addition and multiplication constructions used to validate non-ML workloads.","marker":"[20]"}],"fun_headline_variants":["Matrix-based SNN simulator hits 100k neurons on a laptop","SuperNeuroMAT: fast CPU SNN simulation via matrix ops","Open-source SNN simulator outperforms four rivals by up to 215x","Python SNN simulator scales to 100k neurons without GPU","Matrix-based LIF and STDP: SNN simulator beats established tools"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The load-bearing premise is that the equalized benchmark configuration—zero threshold, infinite-leak (memoryless) LIF neurons with unit-delay delta synapses—is representative of real SNN workloads, so that the measured speed and memory differences reflect implementation efficiency rather than the artificial simplicity of the test.","fun_headline_variants_meta":{"raw":{"variants":["Matrix-based SNN simulator hits 100k neurons on a laptop","SuperNeuroMAT: fast CPU SNN simulation via matrix ops","Open-source SNN simulator outperforms four rivals by up to 215x","Python SNN simulator scales to 100k neurons without GPU","Matrix-based LIF and STDP: SNN simulator beats established tools"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000803,"raw_usage":{"total_tokens":3611,"prompt_tokens":1107,"completion_tokens":2504,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":723,"completion_tokens_details":{"reasoning_tokens":2412}},"tokens_in":723,"tokens_out":2504,"duration_ms":19024,"temperature":1.0,"reasoning_tokens":2412,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-14T04:34:52.884689+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Re-run the Section 6.1.2 comparison at 10,000 neurons and full connectivity using finite membrane time constants, nonzero thresholds, and randomly drawn synaptic delays; if the reported runtime ranking or memory ordering changes materially, the claim that the matrix-based approach consistently outperforms the four simulators fails.","supporting_citations":[{"cited_title":"Scholarpedia2(4), 1430 (2007)","cited_arxiv_id":null,"evidence_quote":"The discrete-event simulator provides the large-scale runtime and memory baseline that the paper's speed comparison must beat."},{"cited_title":"elife8, 47314 (2019)","cited_arxiv_id":null,"evidence_quote":"The equation-based simulator provides the code-generation baseline and one of the main runtime comparisons."},{"cited_title":"Frontiers in neuroinformatics12, 89 (2018)","cited_arxiv_id":null,"evidence_quote":"The PyTorch-based machine-learning simulator provides a baseline for runtime and memory across network sizes."},{"cited_title":"Proceedings of the IEEE111(9), 1016–1054 (2023)","cited_arxiv_id":null,"evidence_quote":"The tensor-based deep-learning simulator provides a baseline for runtime and memory in large, dense configurations."},{"cited_title":"Nature Methods17, 261–272 (2020) https://doi.org/10.1038/ s41592-019-0686-2","cited_arxiv_id":null,"evidence_quote":"The sparse array library supplies the sparse execution mode that handles large, sparsely connected networks."},{"cited_title":"ACM Transactions on Mathematical Software (TOMS)5(3), 308–323 (1979)","cited_arxiv_id":null,"evidence_quote":"The low-level linear algebra routines make the matrix-vector updates fast on CPUs."},{"cited_title":"In: Proceedings of the 2020 Annual Neuro-inspired Computational Elements Workshop, pp","cited_arxiv_id":null,"evidence_quote":"Prior neuromorphic graph algorithm formulation supplies the shortest-path construction used to validate general-purpose computing."},{"cited_title":"In: 2023 IEEE International Conference on Rebooting Computing (ICRC), pp","cited_arxiv_id":null,"evidence_quote":"Prior arithmetic-primitive encoding supplies the addition and multiplication constructions used to validate non-ML workloads."}],"review_version":1}