Validate isolated author LIF semantics without changing frozen models

CURRENT.md

@@ -1,55 +1,30 @@
-# 当前研究状态 — Phase 4AC
+# 当前研究状态 — Phase 4AD
 
-最新结果：**COMPLETE-SEMANTICS-AUDIT / LEARNING-NOT-ACHIEVED**。
+已按用户授权建立独立分支 `codex/lif-author-semantics-lab`。
-学习可用的总目标尚未达到，不把审计 PASS 当成学习 PASS。
+正式状态：**COMPLETE-ORACLE-VALIDATED-LAB-ONLY**。
-初始化 README/registry 保留原字节，最新结论从本页进入。
+学习仍未达到可用标准；不替换任何旧候选，不把实现检查PASS当作学习PASS。
 
-- [中文机制结论及限制](docs/progress/phase4ac-interpretation.md)
+- [关键结果、限制与下一步](docs/progress/phase4ad-interpretation.md)
-- [完整小回路/单细胞结果](docs/progress/phase4ac-lif-semantics.md)
+- [完整实验报告](docs/progress/phase4ad-author-semantics.md)
-- [预先声明的诊断方案](models/male-cns-lif/lif-semantics-audit-v1/PROTOCOL.md)
+- [实验预声明](models/male-cns-lif/author-semantics-lab-v1/PROTOCOL.md)
-- [新阶段校验清单](registry/phase4ac-lif-semantics/seal-verification.json)
+- [新产物封存核验](registry/phase4ad-author-semantics/seal-verification.json)
-- [上一轮末梢作用范围诊断](docs/progress/phase4ab-terminal-scope.md)
+- [此前全脑输入背景复核](docs/progress/feedback-context-review-20260930.md)
-- [小回路与全脑背景的只读复核](docs/progress/feedback-context-review-20260930.md)
 
-## 后续只读复核的重要限制
+## 关键发现
 
-所选五节点只贡献三个 ALLN 晚期正到达权重的 7.57%–8.99%；达到各自80%正输入需要49–52个来源。
+固定作者代码在Brian2 2.5.1实际运行。16项单元检查、10组真实回路/精度对照及其重复通过；58/58审计项通过。
-因此孤立小回路可以自持，不意味着它是全脑唯一原因。回路外输入也可能受该回路反馈影响，不是已证明独立的外源驱动。
+恢复作者完整动力学后，五节点真实回路1秒放电从1,483降到610，但后500ms仍有306次。
-对旧数据的派生分解没有新模拟或训练；正输入比例不能当因果责任比例。
+因此不能认为“修g reset/不应期就解决学习问题”；持续循环仍存在，低活跃度不是晋级条件。
-独立新模型分支尚待用户确认，不把持续目标自动当作改变冻结动力学的许可。
 
-## 新增机制证据
+下一步先做独立GPU实现的高入度/累加顺序与短时全图对照，再检验固定DoOR嗅觉输入是否保留区别；尚未开始conditioning。
+输入请求、不应期拒绝和实际放电必须分开统计。后续学习必须执行真实无调制/冻结/随机奖励对照和等待期，而非复用标签。
 
-只施加一次初始 spike，使用原有冻结动力学：
+## 冻结与服务
 
-| 真实小回路 | 1 s 内总 spike | 500–1,000 ms spike |
+原230,239项以及4AA/4AB/4AC与背景复核封存文件前后校验不变。
-|---|---:|---:|
+旧deterministic-v2五组全脑参考重新运行，事件、计数、最终电压和g精确一致。
-| 2 个 ALLN | 473 | 238 |
+base CSR、raw counts、W_syn、transmitter signs、APL参数、eligibility-v2、14,232-edge mask未修改。
-| 3 个 ALLN | 1,064 | 535 |
+只在独立实验环境安装作者版本依赖；未停用或修改ComfyUI。
-| 3 ALLN + VA6 PN + KC | 1,483 | 747 |
+没有游戏、RL、decoder、视觉输入或权重训练，没有生成新的learned candidate。
-| 真实前向边对照 | 3 | 0 |
-| 无初始刺激 | 0 | 0 |
 
-最小回路：body 11478 → 11620（235 contacts），11620 → 11478（283 contacts），两者为 lLN1_bc / ACh。
+代码、小报告、来源和校验清单进入Git；大数据及完整实验轨迹保留服务器，不等于完整异机备份。
-单次输入足以在隔离小回路中产生持续到观察期末的活动；不代表已证明全脑必要性，也不代表真实果蝇该回路必然如此。
-
-## 原作者实现与本项目适配差异
-
-固定作者代码在 spike 后清零 g，对不应期内 g 更新/输入设限，并有不同积分、阈值和刺激时序。
-本项目冻结版本明确保留 g，继续衰减/接收输入。这是建模语义差异，不是本轮发现的 GPU 回归错误。
-单细胞组件测试证明这些选择会改变响应，但真实连接强度的一次输入下，reset-only 并未改变 spike 数。
-因此 **g reset 不得直接称为学习修复**，也不能仅据放电减少自动选择新模型。
-
-## 验证与下一步
-
-7 项单元测试、17×4 单细胞 fixture、5 个真实小回路 CPU/GPU 全状态/事件精确对照通过。
-五组 deterministic-v2 全脑冻结参考 trial 精确一致。
-原快照 230,239 项及 Phase 4AA / 4AB 模型与实验前后校验无变化。
-新产物有独立 manifest/SHA-256；未训练、未生成 learned candidate。
-ComfyUI 保持驻留，不停用、不卸载、不升级依赖。
-
-后续需要明确授权的独立动力学模型分支：先验证原作者 oracle 和局部机制，再检查输入区别与学习功能。
-仍要求独立 evaluation seeds、A 对 B 的特异性、MBON/downstream readout 和完整 conditioning controls。
-不调整学习率/阈值或扩大 mask，不进入游戏、RL、decoder、视觉；不修改已冻结版本。
-
-Git 仅同步代码、小报告、官方小型源代码及校验清单。大数据/完整 spike 输出仍在服务器，不等于完整异机备份。

docs/progress/phase4ad-author-semantics.md

@@ -0,0 +1,71 @@
+# Phase 4AD 作者动力学语义实验室
+
+状态：`COMPLETE-ORACLE-VALIDATED-LAB-ONLY`。
+
+本轮仅有预声明的小回路与算子实验；没有整脑替代动力学运行、conditioning、学习成功或新学习候选。
+检查以原始事件、状态轨迹和预注册误差界限重算。缺失、失败、非有限值或初始事件丢失均不能通过；放电减少或静默本身不构成成功。
+
+核查通过 58/58 项；失败或不完整 0 项。
+冻结历史完整性：通过。
+源码与输入预注册一致性：通过。
+
+| 回路 | 语义 | 精度 | 总spikes | late spikes |
+|---|---|---|---:|---:|
+| pair | frozen | float32 | 473 | 238 |
+| pair | reset_g_only | float32 | 223 | 111 |
+| pair | refractory_gate_only | float32 | 635 | 321 |
+| pair | reset_and_refractory | float32 | 223 | 111 |
+| trio | frozen | float32 | 1064 | 535 |
+| trio | reset_g_only | float32 | 565 | 283 |
+| trio | refractory_gate_only | float32 | 1100 | 552 |
+| trio | reset_and_refractory | float32 | 469 | 235 |
+| five | frozen | float32 | 1483 | 747 |
+| five | reset_g_only | float32 | 868 | 433 |
+| five | refractory_gate_only | float32 | 1510 | 763 |
+| five | reset_and_refractory | float32 | 634 | 318 |
+| feedforward | frozen | float32 | 3 | 0 |
+| feedforward | reset_g_only | float32 | 3 | 0 |
+| feedforward | refractory_gate_only | float32 | 3 | 0 |
+| feedforward | reset_and_refractory | float32 | 3 | 0 |
+| no_input | frozen | float32 | 0 | 0 |
+| no_input | reset_g_only | float32 | 0 | 0 |
+| no_input | refractory_gate_only | float32 | 0 | 0 |
+| no_input | reset_and_refractory | float32 | 0 | 0 |
+| pair | author_complete | float64 | 213 | 106 |
+| pair | author_complete | float32 | 213 | 106 |
+| trio | author_complete | float64 | 448 | 224 |
+| trio | author_complete | float32 | 448 | 224 |
+| five | author_complete | float64 | 610 | 306 |
+| five | author_complete | float32 | 610 | 306 |
+| feedforward | author_complete | float64 | 3 | 0 |
+| feedforward | author_complete | float32 | 3 | 0 |
+| no_input | author_complete | float64 | 0 | 0 |
+| no_input | author_complete | float32 | 0 | 0 |
+
+作者Brian2与独立NumPy比较：
+
+| 实验 | 结果 | 事件一致 | 最大V/g误差 mV | 首次事件分歧step |
+|---|---|---|---:|---:|
+| author:pair:float64 | 通过 | True | 7.105427357601002e-14 | None |
+| author:pair:float32 | 通过 | True | 2.41696834564209e-05 | None |
+| author:trio:float64 | 通过 | True | 8.526512829121202e-14 | None |
+| author:trio:float32 | 通过 | True | 4.25875186920166e-05 | None |
+| author:five:float64 | 通过 | True | 3.836930773104541e-13 | None |
+| author:five:float32 | 通过 | True | 0.0002123713493347168 | None |
+| author:feedforward:float64 | 通过 | True | 3.765876499528531e-13 | None |
+| author:feedforward:float32 | 通过 | True | 0.00020179152488708496 | None |
+| author:no_input:float64 | 通过 | True | 7.105427357601002e-15 | None |
+| author:no_input:float32 | 通过 | True | 1.0728836059570312e-06 | None |
+
+float32与float64交叉比较仅记录精度影响，允许保留分歧，不能用于掩盖各自与独立oracle的失败。
+- precision_cross_record:pair：事件一致=True，最大误差=3.733467101341148e-05 mV，首次事件分歧step=None。
+- precision_cross_record:trio：事件一致=True，最大误差=3.733467101341148e-05 mV，首次事件分歧step=None。
+- precision_cross_record:five：事件一致=True，最大误差=0.00019546693161487383 mV，首次事件分歧step=None。
+- precision_cross_record:feedforward：事件一致=True，最大误差=0.0005722045887850413 mV，首次事件分歧step=None。
+- precision_cross_record:no_input：事件一致=True，最大误差=0.0 mV，首次事件分歧step=None。
+
+所有失败轨迹和错误文件原样保留；本简报没有选择获胜变体。
+小回路缺少外部整脑输入与graded APL，不能证明整脑因果必要性、生物真实性或信息保持。初始诊断seed也不是作者的感官Poisson接口。
+环境为Linux宿主，作者记录为Windows；Python补丁版本与环境差异见environment记录，不能称为二进制相同或原论文整脑复现。
+后续整脑嗅觉比较仍须核查固定输入、实际送达事件、持续活动和信息保持；可用学习仍需至少5个训练seed、独立评估、MBON/downstream的A对中性B特异性及acquisition/reversal/retention/delayed-reward对照。
+封存排除 .venv 与 __pycache__，保留环境安装报告；manifest列出payload哈希，checksums另含manifest，不存在自哈希循环。

docs/progress/phase4ad-interpretation.md

@@ -0,0 +1,54 @@
+# 独立模型分支首轮结果：实现正确，不等于学习修复
+
+用户明确授权独立新模型分支测试动力学假设。分支为 `codex/lif-author-semantics-lab`，
+模型目录 `models/male-cns-lif/author-semantics-lab-v1/`，实验目录 `experiments/phase4ad-author-semantics/`。
+Phase 1–4AC 保持原样；没有替换已有候选、训练、调学习率、扩大mask或连接游戏。
+
+## 已验证的结果
+
+正式状态 `COMPLETE-ORACLE-VALIDATED-LAB-ONLY`，58/58审计项通过。
+实际运行固定作者代码的 `create_model`，并与独立解析积分实现对照，而非仅比较两份自写程序。
+8项算子/边界fixture各测试float64与float32；5个固定真实motif各测试两种精度，分别重复。
+各精度内的spike事件、计数和不应期逐步一致，重复运行逐数组精确一致。
+五个motif的float32与float64事件也一致，但不能外推到全脑高入度累加。
+float64最大V/g差约3.84e-13 mV；float32独立实现相对Brian2最大差约2.12e-4 mV。
+
+| 真实回路 | 旧冻结模型1秒总spike | 完整作者语义总spike | 作者语义后500ms spike |
+|---|---:|---:|---:|
+| 两个ALLN | 473 | 213 | 106 |
+| 三个ALLN | 1,064 | 448 | 224 |
+| 三ALLN + VA6 PN + KC | 1,483 | 610 | 306 |
+| 前向真实边对照 | 3 | 3 | 0 |
+| 无刺激 | 0 | 0 | 0 |
+
+**持续循环没有因恢复作者语义而消失。** 放电减少不是学习成功，也没有据此挑选获胜参数。
+单独限制不应期内g更新甚至提高了这些回路的放电；不能把单一算子改动当作通用修复。
+小回路省略了大部分全脑输入和graded APL，不能证明全脑问题完全由这些连接引起。
+此前全脑背景复核显示，三个ALLN的晚期正到达权重约91%以上来自所选五节点之外；这也不是因果责任百分比。
+
+## 作者参考及边界
+
+- 官方代码：`philshiu/Drosophila_brain_model`，commit `91bdd1e7dcf193f3e7ca5a8933497fcef63b7960`，MIT。
+- [原作者论文](https://www.nature.com/articles/s41586-024-07763-9)；[固定代码版本](https://github.com/philshiu/Drosophila_brain_model/tree/91bdd1e7dcf193f3e7ca5a8933497fcef63b7960)。
+- Brian2 2.5.1，独立Linux环境；作者记录为Windows/Python3.10.11，此处Linux/Python3.10.12，不能称为二进制相同。
+- 原始g单位为volt，是加性输入状态，不是电导；reset中的局部`w=0`不会清零真实Synapses权重。
+- 原`poi`接口另做了零时长编译审计：向v加入68.75mV、150Hz、N=1，并将目标不应期置零。它不是本轮共同初始seed，也不是已验证的新嗅觉接口。
+- 安装只发生在新实验`.venv`，保存下载URL与归档SHA-256；MarkupSafe1.1.1使用源归档，其他核心包使用wheel。未改旧科学环境或ComfyUI。
+
+## 下一关
+
+1. 独立GPU实现须补足高入度、正负抵消、逐边加法顺序、非零初始g、阈值临界值与延迟队列边界测试；禁止用`g+sum(w)`擅自代替作者逐边写入。
+2. 在短时全图上对照事件及状态，再开展固定DoOR嗅觉CAL。保持既有输入请求，不顺手切换为作者的rfc=0输入接口；分别统计请求、因不应期拒绝与实际放电。
+3. CAL通过后才能使用独立seed及新odor验证。不能靠低活跃度或held-out调参授予成功。
+4. 真正conditioning须重新执行D(t)=0、frozen与随机奖励路径，并真正推进retention等待时间；旧脚本中复用基线/新建状态的检查不能替代这些端到端验证。
+5. 全部学习结论仍以MBON/downstream的刺激特异性、acquisition/reversal/retention/delayed reward为准，至少5个training seeds与独立evaluation seeds。
+
+## 完整性和保存
+
+原快照230,239项及4AA、4AB、4AC、背景复核产物前后SHA-256无变化。
+旧deterministic-v2五个全脑冻结trial重新执行，事件、计数、最终V/g逐数组相同。
+4090回归峰值已分配显存285,994,496字节；这不是新动力学全脑性能benchmark。
+新模型11个payload、新实验565个payload已独立封存，环境目录不纳入payload。
+Git同步代码、小报告和校验清单；大数据及完整状态轨迹仍在服务器，不能称为完整异机备份。
+
+详见[完整结果](phase4ad-author-semantics.md)、[封存核验](../../registry/phase4ad-author-semantics/seal-verification.json)。

models/male-cns-lif/author-semantics-lab-v1/PROTOCOL.md

@@ -0,0 +1,71 @@
+# Phase 4AD — independently authorized author-semantics laboratory
+
+Human authorization: "允许独立新模型分支测试动力学假设".
+Goal remains usable stimulus-specific learning, not reducing spike count or passing an isolated fixture.
+
+All Phase 1–4AC scientific artifacts, canonical CSR/raw counts, transmitter signs,
+W_syn=0.275, APL calibration, eligibility-v2 and the 14,232-edge plastic mask are
+read-only. No training, threshold/gain/eta search, decoder, game or visual work in
+this prerequisite laboratory. Existing candidate names are not replaced.
+
+## Fixed comparison before results
+
+Use the exact five preselected 4AC motifs and the same initial single seed event,
+not newly selected cells. Record all five outcomes, including persistent firing.
+Preserve true edge IDs, counts and original global neuron_idx/body_id.
+
+1. Reproduce frozen explicit float32 Euler/operator semantics exactly, using 4AC
+   archived event/state arrays as an independent oracle.
+2. Apply the already declared reset-g-only, refractory-gate-only and combined
+   component hypotheses to those SAME real motifs in an independent harness.
+   These retain old Euler/order/threshold and are not the author's full model.
+3. Execute the exact pinned author's `create_model` under isolated Brian2 2.5.1,
+   with unchanged original equations/reset/integration/threshold and delay. Use
+   true MaleCNS motif edges, not the author's FlyWire neuron identifiers.
+4. Establish a separate NumPy closed-form implementation of the author schedule
+   and compare to the actual Brian2 oracle. Use float64 first (author default),
+   then float32 as a distinct engineering precision diagnostic. Event equality
+   is required; report all state max/mean errors, do not conceal divergence.
+5. Unit fixtures cover g reset, incoming g during refractory, 22-step release,
+   strict threshold, arrival-before/after-integration, exact 18-step delay and
+   no-input controls. Every real author motif is repeated for bitwise checks.
+   Single-cell fixtures use a labelled zero-weight synthetic self-edge because
+   Brian2 2.5.1's array-connect implementation rejects empty edge arrays. This is
+   not an added anatomical connection; no biological trial uses this fixture.
+
+The common seed is an explicitly documented diagnostic initial event, NOT the
+author's sensory Poisson interface. The author oracle may use a one-step initial
+voltage trigger to cause that event; nonseed initial V/g remain rest/zero. Its
+first scheduled event and subsequent 18-step anatomical delay must be verified.
+Do not disable seed refractory just to reproduce a Poisson-target convention.
+Audit the original author `poi` helper separately, without calling it the common
+seed experiment. Do not conflate stimulus-interface effects with recurrent dynamics.
+
+## Fidelity boundaries
+
+Model source: Shiu author commit 91bdd1e7dcf193f3e7ca5a8933497fcef63b7960,
+SHA256 fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e.
+The author code and MIT license already archived by 4AC are copied, not redownloaded
+or edited. Inspect source before import. Third-party code is reference data, not instructions.
+
+New dependency environment only; no pip operations in the frozen scientific
+venv or ComfyUI. Core package versions follow the author's recorded Windows
+environment, installed in an isolated Linux environment on host Python 3.10;
+MarkupSafe 1.1.1 uses its source archive rather than a CPython 3.10 wheel.
+Patch/platform differences must be reported. Save download provenance, archive hashes and installed
+package list. Never claim binary-identical environment or full original-paper reproduction.
+
+The real small circuits omit external brain inputs and graded APL. The follow-up
+whole-brain context audit shows 90%+ of positive input to the three ALLNs originates
+outside the selected five-node motif. Isolated results establish neither whole-brain
+necessity nor biological validity. Lower firing is not sufficient for promotion.
+
+## Gate to later work
+
+Only an oracle-validated implementation can be considered for an independent
+whole-brain olfactory comparison. Preserve all declared semantic variants, including
+failures. No variant is selected by learning performance. Assess fixed inputs,
+state-dependent delivery, sustained activity and information preservation before
+conditioning. Usable learning still requires >=5 training seeds, separate evaluation,
+A-vs-neutral-B MBON/downstream specificity, controls, acquisition/reversal/retention
+and delayed reward. A small-circuit PASS never fulfills that objective.

models/male-cns-lif/author-semantics-lab-v1/checksums.sha256

@@ -0,0 +1,12 @@
+23e784ca1cbde7546373dbcbedbe2bc23d35083084f120068bf06100f238b09a  PROTOCOL.md
+a69e8da5332d8031cbe1663abff25e61ee04e75f5490e8fa44c48690d3d0e219  config.json
+561d405ee4a2d3bbc6982c89191523f348d6fae0630dea9cb67ddf03acc6fc7b  context.py
+97a393b95d100dc5d95b624e4cd0d15511307b8c70e0ebd788b773c143ebfed6  finalize.py
+1e2b31545f1206fe1c1f4084b4a9ac0f21c74990c52e8fd156e809725fc5fb95  interface_audit.py
+9663da41d5f623e1d7750e3cad3df880148079968f115bf583b58799fc5fb31f  math_lab.py
+2f4b073261965cf18a94697caf725c40b2e8db790c2871862201337f40c399e5  oracle_runner.py
+49caa9553938f06539ecf282868491f8e1319d8f24220f89ac9e232db2d82e51  prepare.py
+a69efc6509b85a5cc00a652caa4820c9c9e1406f6b97c6cc741322728c4d51c3  requirements-oracle.txt
+8746e1971c5a40a738e10f8f574a243c29cefa5a8b9f61a2846557ceffd1289a  run_lab.py
+fe37a48ce804e6c50f93404bfd3c23a7e54cd49061bbdfb4860315879648c73b  verify_frozen.py
+07a22bade4892adca3a4585656aa3ecce5219790b0dc8a851a12bfd7248d3769  manifest.json

models/male-cns-lif/author-semantics-lab-v1/config.json

@@ -0,0 +1,36 @@
+{
+  "name": "author-semantics-lab-v1",
+  "phase": "4AD",
+  "root": "/data/digital-drosophila",
+  "experiment": "experiments/phase4ad-author-semantics",
+  "model_directory": "models/male-cns-lif/author-semantics-lab-v1",
+  "prior_experiment": "experiments/phase4ac-lif-semantics",
+  "prior_model": "models/male-cns-lif/lif-semantics-audit-v1",
+  "human_authorization": "允许独立新模型分支测试动力学假设",
+  "dt_ms": 0.1,
+  "duration_ms": 1000.0,
+  "seed_margin_mv": 1.0,
+  "late_start_ms": 500.0,
+  "model": {
+    "dt_ms": 0.1,
+    "membrane_tau_ms": 20.0,
+    "synaptic_tau_ms": 5.0,
+    "refractory_ms": 2.2,
+    "resting_potential_mv": -52.0,
+    "reset_potential_mv": -52.0,
+    "threshold_mv": -45.0,
+    "synaptic_delay_ms": 1.8,
+    "w_syn_mv_per_anatomical_synapse": 0.275
+  },
+  "seed_node": 1381,
+  "motifs": ["pair", "trio", "five", "feedforward", "no_input"],
+  "component_policies": ["frozen", "reset_g_only", "refractory_gate_only", "reset_and_refractory"],
+  "author_precisions": ["float64", "float32"],
+  "comparison": {
+    "float64_state_max_abs_tolerance_mv": 0.00000001,
+    "float32_state_max_abs_tolerance_mv": 0.001,
+    "exact_spike_events_required_for_oracle_validation": true,
+    "precision_cross_comparison_may_diverge_but_must_be_reported": true
+  },
+  "no_training_or_candidate": true
+}

models/male-cns-lif/author-semantics-lab-v1/context.py

@@ -0,0 +1,27 @@
+import hashlib
+import json
+from pathlib import Path
+
+MODEL=Path(__file__).resolve().parent
+CFG=json.loads((MODEL/'config.json').read_text(encoding='utf-8'))
+ROOT=Path(CFG['root']);EXP=ROOT/CFG['experiment'];AC=ROOT/CFG['prior_experiment']
+
+def digest(path):
+    h=hashlib.sha256()
+    with Path(path).open('rb') as f:
+        for b in iter(lambda:f.read(8<<20),b''):h.update(b)
+    return h.hexdigest()
+
+def save(path,value):
+    path=Path(path);path.parent.mkdir(parents=True,exist_ok=True)
+    with path.open('x',encoding='utf-8') as f:json.dump(value,f,indent=2,ensure_ascii=False,allow_nan=False);f.write('\n')
+
+def source_hashes():
+    return {p.name:digest(p) for p in sorted(MODEL.iterdir()) if p.is_file() and p.name not in ('manifest.json','checksums.sha256')}
+
+def check_prereg():
+    pre=json.loads((EXP/'protocol/preregistered.json').read_text())
+    assert pre['source_hashes']==source_hashes(),'Source changed after preregistration'
+    for r in pre['input_hashes']:
+        assert digest(ROOT/r['path'])==r['sha256'],r['path']
+    return pre

models/male-cns-lif/author-semantics-lab-v1/finalize.py

@@ -0,0 +1,411 @@
+"""Seal a descriptive laboratory audit, including incomplete and failed runs.
+
+Run this with the frozen scientific environment, not the isolated Brian2 venv.
+No simulation, parameter selection, candidate promotion or old-artifact write occurs.
+"""
+from datetime import datetime, timezone
+import json
+import math
+from pathlib import Path
+import sys
+import traceback
+
+import numpy as np
+import pandas as pd
+
+from context import CFG, EXP, MODEL, ROOT, check_prereg, digest, save, source_hashes
+from prepare import frozen_integrity
+
+
+UNIT_NAMES = ("zero", "weak_excitation", "inhibition", "refractory_boundary",
+              "equal_threshold", "above_threshold", "nonzero_g_reset", "delay_18")
+EXCLUDED_PARTS = {".venv", "__pycache__"}
+SEAL_NAMES = {"manifest.json", "checksums.sha256"}
+
+
+def read_json(path):
+    with Path(path).open(encoding="utf-8") as stream:
+        return json.load(stream, parse_constant=lambda value: (_ for _ in ()).throw(
+            ValueError("Nonfinite JSON number: " + value)))
+
+
+def exception_record(error):
+    return {"type": type(error).__name__, "message": str(error),
+            "traceback": traceback.format_exc()}
+
+
+def attempt(records, name, function):
+    """Never let an earlier failed arm hide subsequent available evidence."""
+    try:
+        detail = function()
+        if not isinstance(detail, dict) or type(detail.get("pass")) is not bool:
+            raise ValueError("Check must provide an explicit Boolean pass")
+        item = {"name": name, **detail}
+    except Exception as error:
+        item = {"name": name, "pass": False, "error": exception_record(error)}
+    records.append(item)
+    return item
+
+
+def require(condition, message):
+    if not condition:
+        raise ValueError(message)
+
+
+def load_trace(directory, expected_nodes, steps, cfg, seed_node, natural_events=False):
+    events = pd.read_csv(directory / "events.csv", dtype={"step": "int64", "neuron_idx": "int64"})
+    require(list(events.columns) == ["step", "neuron_idx"], "Unexpected event columns")
+    for key in ("step", "neuron_idx"):
+        values = events[key].to_numpy()
+        require(np.isfinite(values).all() and np.equal(values, np.floor(values)).all(),
+                "Nonfinite or nonintegral event field: " + key)
+    ticks = events.step.to_numpy(np.int64)
+    nodes = events.neuron_idx.to_numpy(np.int64)
+    require(bool(np.all((ticks >= 0) & (ticks < steps))), "Event outside trial")
+    require(bool(np.all(np.diff(ticks) >= 0)), "Events not time ordered")
+    require(not events.duplicated().any(), "Duplicate event at one neuron/timestep")
+    require(bool(np.isin(nodes, expected_nodes).all()), "Event identity outside motif")
+    with np.load(directory / "state.npz", allow_pickle=False) as stored:
+        state = {key: stored[key].copy() for key in stored.files}
+    require(np.array_equal(state["nodes"], expected_nodes), "State neuron order differs")
+    history = state["history"]
+    require(history.shape == (steps, 3, len(expected_nodes)), "Incomplete state history")
+    require(all(np.isfinite(value).all() for value in state.values()), "Nonfinite state")
+    actual_counts = np.array([np.count_nonzero(nodes == node) for node in expected_nodes])
+    require(np.array_equal(state["counts"], actual_counts), "Counts disagree with raw events")
+    for index, key in enumerate(("v", "g", "ref")):
+        require(np.array_equal(state[key], history[-1, index]),
+                "Final state disagrees with history: " + key)
+    if seed_node is None and not natural_events:
+        require(len(ticks) == 0, "No-input control emitted a spike")
+    elif seed_node is not None:
+        require(np.array_equal(nodes[ticks == 0], [seed_node]),
+                "Declared initial seed event missing or duplicated")
+    late = ticks >= round(cfg["late_start_ms"] / cfg["dt_ms"])
+    per_node = [{"neuron_idx": int(node), "spikes": int(actual_counts[index]),
+                 "late_spikes": int(np.count_nonzero(late & (nodes == node))),
+                 "last_ms": float(ticks[nodes == node][-1] * cfg["dt_ms"])
+                 if actual_counts[index] else None}
+                for index, node in enumerate(expected_nodes)]
+    return {"step": ticks, "neuron_idx": nodes, **state}, per_node
+
+
+def compare_raw(actual, expected, tolerance):
+    require(math.isfinite(tolerance) and tolerance >= 0, "Invalid preregistered tolerance")
+    a = np.asarray(actual["history"], np.float64)
+    b = np.asarray(expected["history"], np.float64)
+    require(a.shape == b.shape and a.size > 0, "Incomplete comparison trajectories")
+    require(np.isfinite(a).all() and np.isfinite(b).all(), "Nonfinite comparison trajectory")
+    error = np.abs(a[:, :2] - b[:, :2])
+    exact_events = bool(np.array_equal(actual["step"], expected["step"]) and
+                        np.array_equal(actual["neuron_idx"], expected["neuron_idx"]))
+    first = None
+    if not exact_events:
+        for step in range(len(a)):
+            aa = actual["neuron_idx"][actual["step"] == step]
+            bb = expected["neuron_idx"][expected["step"] == step]
+            if not np.array_equal(aa, bb):
+                first = step
+                break
+    prefix = error if first is None else error[:first]
+    reference_exact = bool(np.array_equal(a[:, 2], b[:, 2]))
+    count_exact = bool(np.array_equal(actual["counts"], expected["counts"]))
+    maximum = float(error.max())
+    return {"exact_events": exact_events, "exact_counts": count_exact,
+            "ref_exact": reference_exact, "max_abs_mv": maximum,
+            "mean_abs_mv": float(error.mean()),
+            "same_event_prefix_max_abs_mv": float(prefix.max()) if prefix.size else None,
+            "first_event_divergence_step": first, "tolerance_mv": tolerance,
+            "pass_oracle": exact_events and count_exact and reference_exact and maximum <= tolerance}
+
+
+def comparison_record_matches(raw, stored):
+    """Only descriptive mean reduction may differ between scientific NumPy builds."""
+    if set(raw) != set(stored):
+        return False
+    return all(math.isclose(raw[key], stored[key], rel_tol=0, abs_tol=1e-12)
+               if key == "mean_abs_mv" else raw[key] == stored[key] for key in raw)
+
+
+def motif_nodes(cfg, motif):
+    with np.load(ROOT / cfg["prior_experiment"] / "motifs" / (motif + "-state.npz"),
+                 allow_pickle=False) as prior:
+        return prior["nodes"].copy()
+
+
+def check_summary_rows(table, motif, policy, precision, per_node):
+    part = table[(table.motif == motif) & (table.policy == policy) &
+                 (table.precision == precision)]
+    require(len(part) == len(per_node) and not part.neuron_idx.duplicated().any(),
+            "Missing/duplicate per-neuron summary rows")
+    require(set(part.neuron_idx) == {row["neuron_idx"] for row in per_node},
+            "Summary neuron identities differ")
+    indexed = part.set_index("neuron_idx")
+    for row in per_node:
+        current = indexed.loc[row["neuron_idx"]]
+        require(current.spikes == row["spikes"] and current.late_spikes == row["late_spikes"],
+                "Summary spike counts disagree with raw events")
+        last = current.last_ms
+        require(pd.isna(last) if row["last_ms"] is None else last == row["last_ms"],
+                "Summary last-spike time disagrees with raw events")
+
+
+def seal(root):
+    require(not any((root / name).exists() for name in SEAL_NAMES),
+            "Refusing to overwrite an existing seal: " + str(root))
+    files = []
+    for path in sorted(root.rglob("*")):
+        relative = path.relative_to(root)
+        if EXCLUDED_PARTS.intersection(relative.parts):
+            continue
+        require(not path.is_symlink(), "Unsealed symlink not permitted: " + str(path))
+        if not path.is_file() or (len(relative.parts) == 1 and path.name in SEAL_NAMES):
+            continue
+        files.append({"path": relative.as_posix(), "bytes": path.stat().st_size,
+                      "sha256": digest(path)})
+    require(bool(files), "Refusing empty artifact manifest")
+    manifest = {"schema": "sha256-artifact-manifest-v1", "root": str(root),
+                "created_utc": datetime.now(timezone.utc).isoformat(),
+                "excluded_directory_names": sorted(EXCLUDED_PARTS),
+                "self_hash_policy": "Manifest lists payload files; checksums also hashes manifest; neither hashes checksums.",
+                "files": files}
+    save(root / "manifest.json", manifest)
+    checksum_rows = files + [{"path": "manifest.json", "sha256": digest(root / "manifest.json")}]
+    with (root / "checksums.sha256").open("x", encoding="utf-8", newline="\n") as stream:
+        for row in checksum_rows:
+            stream.write(row["sha256"] + "  " + row["path"] + "\n")
+    for row in checksum_rows:
+        require(digest(root / row["path"]) == row["sha256"],
+                "Artifact changed while sealing: " + row["path"])
+
+
+def main():
+    outputs = [EXP / "audit/finalize-start.json", EXP / "audit/final-summary.json",
+               EXP / "regression/old-integrity-after.json", EXP / "regression/preregistration-after.json",
+               EXP / "REPORT.md"] + [root / name for root in (MODEL, EXP) for name in SEAL_NAMES]
+    require(not any(path.exists() for path in outputs), "Refusing reused finalization outputs")
+    save(EXP / "audit/finalize-start.json", {"timestamp_utc": datetime.now(timezone.utc).isoformat(),
+         "python": sys.version, "executable": sys.executable, "learning": False,
+         "whole_brain_alternative_run": False})
+    checks = []
+    prereg = attempt(checks, "preregistration", lambda: {"pass": True, "record": check_prereg()})
+    if prereg["pass"]:
+        cfg = prereg["record"]["config"]
+    else:
+        # Read the sealed declaration for descriptive recovery, never bless source drift.
+        try:
+            cfg = read_json(EXP / "protocol/preregistered.json")["config"]
+        except Exception:
+            cfg = CFG
+    integrity = attempt(checks, "old_frozen_integrity_after", lambda: {
+        "pass": True, "results": frozen_integrity()})
+    save(EXP / "regression/old-integrity-after.json", integrity)
+
+    def completed():
+        record = read_json(EXP / "audit/run-complete.json")
+        require(record.get("learning_achieved") is False and
+                record.get("whole_brain_alternative_run") is False, "Run scope inconsistent")
+        require(record.get("author_original_source_sha256") == digest(EXP / "external-resources/model.py"),
+                "Author source hash disagrees with run-complete record")
+        return {"pass": record.get("all_author_oracle_comparisons_pass") is True and
+                record.get("all_frozen_components_match_archive") is True, "record": record}
+    run_complete = attempt(checks, "run_complete", completed)
+
+    def frozen_five_check():
+        record = read_json(EXP / "regression/frozen-five.json")
+        trials = record.get("trials", [])
+        require(len(trials) == 5 and len({row["trial"] for row in trials}) == 5,
+                "Exactly five distinct frozen reference trials are required")
+        required = {"step", "neuron_idx", "counts", "v", "g"}
+        exact = all(set(row.get("exact", {})) == required and
+                    all(value is True for value in row["exact"].values()) for row in trials)
+        return {"pass": record.get("pass_all") is True and exact, "record": record,
+                "scope": "Old frozen runtime regression only, not a new-model dynamics gate."}
+    frozen_five = attempt(checks, "frozen_five_gpu_references", frozen_five_check)
+
+    def interface_check():
+        record = read_json(EXP / "oracle/poi-interface/audit.json")
+        flags = record.get("checks", {})
+        require(isinstance(flags, dict) and bool(flags), "Empty Poisson interface audit")
+        require(record.get("author_sha256") == digest(EXP / "external-resources/model.py"),
+                "Poisson audit source hash differs")
+        require(record.get("simulation_duration_ms") == 0 and
+                record.get("stochastic_time_steps") == 0 and
+                record.get("random_realization_tested") is False and
+                record.get("common_seed_experiment") is False, "Poisson audit scope differs")
+        for name, expected in record.get("input_hashes", {}).items():
+            require(digest(EXP / "oracle/poi-interface" / name) == expected,
+                    "Poisson fixture input changed: " + name)
+        return {"pass": record.get("gate") is True and all(value is True for value in flags.values()),
+                "record": record, "scope": "Compile-time interface audit; no Poisson realization."}
+    interface = attempt(checks, "author_poi_compile_only", interface_check)
+    outcomes = []
+    components = []
+    steps = round(cfg["duration_ms"] / cfg["dt_ms"])
+    for motif in cfg["motifs"]:
+        for policy in cfg["component_policies"]:
+            def component_check(motif=motif, policy=policy):
+                nodes = motif_nodes(cfg, motif)
+                raw, per_node = load_trace(EXP / "components" / (motif + "-" + policy), nodes,
+                                          steps, cfg, None if motif == "no_input" else cfg["seed_node"])
+                outcomes.append({"motif": motif, "policy": policy, "precision": "float32",
+                                 "neurons": per_node, "activity_is_not_a_validation_gate": True})
+                table = pd.read_csv(EXP / "components/summary.csv", float_precision="round_trip")
+                check_summary_rows(table, motif, policy, "float32", per_node)
+                if policy == "frozen":
+                    prior_dir = ROOT / cfg["prior_experiment"] / "motifs"
+                    old_events = pd.read_parquet(prior_dir / (motif + "-events.parquet"))
+                    require(np.array_equal(raw["step"], old_events.step) and
+                            np.array_equal(raw["neuron_idx"], old_events.neuron_idx),
+                            "Frozen events disagree with 4AC")
+                    with np.load(prior_dir / (motif + "-state.npz"), allow_pickle=False) as old:
+                        require(all(np.array_equal(old[key], raw[key]) for key in old.files),
+                                "Frozen states disagree with 4AC")
+                return {"pass": True, "raw_and_summary_consistent": True,
+                        "interpretation": "Artifact/finite/seed checks only; activity is descriptive."}
+            components.append(attempt(checks, "component:" + motif + ":" + policy, component_check))
+
+    unit_results = []
+    for precision in cfg["author_precisions"]:
+        for fixture in UNIT_NAMES:
+            def unit_check(precision=precision, fixture=fixture):
+                stem = fixture
+                record = read_json(EXP / "regression" / ("unit-" + stem + "-" + precision + ".json"))
+                require(record.get("fixture") == fixture and record.get("precision") == precision,
+                        "Unit identity mismatch")
+                unit_cfg = dict(cfg, duration_ms=20.0)
+                seeded = fixture in ("refractory_boundary", "above_threshold")
+                directory = EXP / "oracle" / ("unit-" + stem + "-" + precision)
+                nodes = np.array([-2, -1]) if fixture == "delay_18" else np.array([-1])
+                seed = -2 if fixture == "delay_18" else (-1 if seeded else None)
+                actual, _ = load_trace(directory / "brian-output", nodes, 200, unit_cfg, seed,
+                                       natural_events=fixture == "nonzero_g_reset")
+                independent, _ = load_trace(directory / "independent-output", nodes, 200, unit_cfg, seed,
+                                            natural_events=fixture == "nonzero_g_reset")
+                raw = compare_raw(actual, independent, float(cfg["comparison"][precision + "_state_max_abs_tolerance_mv"]))
+                stored = read_json(directory / "comparison.json")
+                require(comparison_record_matches(raw, stored) and
+                        comparison_record_matches(raw, record["comparison"]),
+                        "Unit comparison differs from raw trajectories")
+                flags = record.get("checks")
+                require(isinstance(flags, dict) and bool(flags), "Empty unit checks cannot pass")
+                return {"pass": raw["pass_oracle"] and all(value is True for value in flags.values()),
+                        "checks": flags, "raw_comparison": raw}
+            unit_results.append(attempt(checks, "unit:" + fixture + ":" + precision, unit_check))
+
+    author_results = []
+    precision_cross = []
+    for motif in cfg["motifs"]:
+        by_precision = {}
+        for precision in cfg["author_precisions"]:
+            def author_check(motif=motif, precision=precision):
+                nodes = motif_nodes(cfg, motif)
+                directory = EXP / "oracle" / (motif + "-" + precision)
+                seed = None if motif == "no_input" else cfg["seed_node"]
+                actual, per_node = load_trace(directory / "brian-output", nodes, steps, cfg, seed)
+                independent, _ = load_trace(directory / "independent-output", nodes, steps, cfg, seed)
+                by_precision[precision] = actual
+                outcomes.append({"motif": motif, "policy": "author_complete", "precision": precision,
+                                 "neurons": per_node, "activity_is_not_a_validation_gate": True})
+                raw = compare_raw(actual, independent, float(cfg["comparison"][precision + "_state_max_abs_tolerance_mv"]))
+                stored = read_json(directory / "comparison.json")
+                require(comparison_record_matches(raw, stored), "Author comparison differs from raw trajectories")
+                repeated, _ = load_trace(EXP / "oracle" / (motif + "-" + precision + "-repeat") /
+                                         "brian-output", nodes, steps, cfg, seed)
+                repeat_flags = read_json(EXP / "regression" / (motif + "-" + precision + "-repeat.json"))
+                require(set(repeat_flags) == set(actual) - {"nodes"}, "Incomplete repeat comparison fields")
+                repeat_raw = {key: bool(np.array_equal(actual[key], repeated[key])) for key in repeat_flags}
+                require(repeat_raw == repeat_flags, "Repeat flags disagree with raw arrays")
+                table = pd.read_csv(EXP / "audit/all-motif-results.csv", float_precision="round_trip")
+                check_summary_rows(table, motif, "author_complete", precision, per_node)
+                return {"pass": raw["pass_oracle"] and all(repeat_raw.values()),
+                        "raw_comparison": raw, "repeat_exact": repeat_raw}
+            author_results.append(attempt(checks, "author:" + motif + ":" + precision, author_check))
+        def cross_check(motif=motif):
+            raw = compare_raw(by_precision["float32"], by_precision["float64"],
+                              float(cfg["comparison"]["float32_state_max_abs_tolerance_mv"]))
+            stored = read_json(EXP / "regression" / (motif + "-precision-cross-comparison.json"))
+            require(comparison_record_matches(raw, stored), "Precision cross comparison differs from raw trajectories")
+            return {"pass": True, "comparison": raw,
+                    "interpretation": "Reporting consistency only; cross-precision divergence is allowed and retained."}
+        precision_cross.append(attempt(checks, "precision_cross_record:" + motif, cross_check))
+
+    retained_errors = []
+    for path in sorted(EXP.rglob("error.json")):
+        if EXCLUDED_PARTS.intersection(path.relative_to(EXP).parts):
+            continue
+        try:
+            error = read_json(path)
+        except Exception as exception:
+            error = exception_record(exception)
+        retained_errors.append({"path": path.relative_to(EXP).as_posix(), "error": error})
+    checks.append({"name": "no_recorded_oracle_errors", "pass": not retained_errors,
+                   "errors": retained_errors})
+    final_prereg = attempt(checks, "preregistration_at_seal", lambda: {"pass": True, "record": check_prereg()})
+    save(EXP / "regression/preregistration-after.json", {
+        "initial": prereg, "at_seal": final_prereg, "observed_source_hashes": source_hashes()})
+    passed = bool(checks) and all(item["pass"] for item in checks)
+    summary = {"phase": cfg.get("phase", "4AD"),
+               "status": "COMPLETE-ORACLE-VALIDATED-LAB-ONLY" if passed else "INCOMPLETE-OR-FAILED-LAB-VALIDATION",
+               "laboratory_validation_pass": passed, "checks": checks,
+               "component_checks": components, "unit_checks": unit_results,
+               "frozen_five_gpu_check": frozen_five, "author_poi_interface_check": interface,
+               "author_oracle_checks": author_results, "precision_cross_checks": precision_cross,
+               "motif_outcomes": outcomes, "run_complete_record": run_complete,
+               "whole_brain_alternative_run": False, "conditioning_run": False,
+               "learning_achieved": False, "candidate_generated": False, "selected_variant": None,
+               "goal_remains_unachieved": True,
+               "limits": ["No whole-brain or learning experiment in this protocol.",
+                          "No activity-based variant selection; silence is not a success gate.",
+                          "Isolated motifs omit external network input and graded APL.",
+                          "Author equations on MaleCNS motifs do not reproduce the original paper's full brain or sensory interface.",
+                          "Linux host and Python patch differences prevent a binary-identical author-environment claim."]}
+    save(EXP / "audit/final-summary.json", summary)
+    failures = [item for item in checks if not item["pass"]]
+    lines = ["# Phase 4AD 作者动力学语义实验室", "", "状态：`" + summary["status"] + "`。", "",
+             "本轮仅有预声明的小回路与算子实验；没有整脑替代动力学运行、conditioning、学习成功或新学习候选。",
+             "检查以原始事件、状态轨迹和预注册误差界限重算。缺失、失败、非有限值或初始事件丢失均不能通过；放电减少或静默本身不构成成功。", "",
+             f"核查通过 {sum(item['pass'] for item in checks)}/{len(checks)} 项；失败或不完整 {len(failures)} 项。",
+             "冻结历史完整性：" + ("通过。" if integrity["pass"] else "失败或未完成，详见保存的错误。"),
+             "源码与输入预注册一致性：" + ("通过。" if prereg["pass"] and final_prereg["pass"] else "失败或未完成；不得授予验证成功。"), "",
+             "| 回路 | 语义 | 精度 | 总spikes | late spikes |", "|---|---|---|---:|---:|"]
+    for row in outcomes:
+        lines.append("| {} | {} | {} | {} | {} |".format(row["motif"], row["policy"], row["precision"],
+                     sum(item["spikes"] for item in row["neurons"]), sum(item["late_spikes"] for item in row["neurons"])))
+    if not outcomes:
+        lines.append("| 无完整可读取结果 | 未执行或缺失 | — | — | — |")
+    lines.extend(["", "作者Brian2与独立NumPy比较：", "",
+                  "| 实验 | 结果 | 事件一致 | 最大V/g误差 mV | 首次事件分歧step |", "|---|---|---|---:|---:|"])
+    for item in author_results:
+        raw = item.get("raw_comparison", {})
+        lines.append("| {} | {} | {} | {} | {} |".format(item["name"], "通过" if item["pass"] else "失败/缺失",
+                     raw.get("exact_events", "未知"), raw.get("max_abs_mv", "未知"),
+                     raw.get("first_event_divergence_step", "无或未取得")))
+    lines.extend(["", "float32与float64交叉比较仅记录精度影响，允许保留分歧，不能用于掩盖各自与独立oracle的失败。"])
+    for item in precision_cross:
+        raw = item.get("comparison")
+        if raw:
+            lines.append(f"- {item['name']}：事件一致={raw['exact_events']}，最大误差={raw['max_abs_mv']} mV，首次事件分歧step={raw['first_event_divergence_step']}。")
+    if failures:
+        lines.extend(["", "失败与未完成项：", ""])
+        for item in failures:
+            detail = item.get("error", {}).get("message") or "原始条件未全部满足；完整字段见 final-summary.json。"
+            lines.append("- `" + item["name"] + "`：" + str(detail).replace("\n", " "))
+    lines.extend(["", "所有失败轨迹和错误文件原样保留；本简报没有选择获胜变体。",
+                  "小回路缺少外部整脑输入与graded APL，不能证明整脑因果必要性、生物真实性或信息保持。初始诊断seed也不是作者的感官Poisson接口。",
+                  "环境为Linux宿主，作者记录为Windows；Python补丁版本与环境差异见environment记录，不能称为二进制相同或原论文整脑复现。",
+                  "后续整脑嗅觉比较仍须核查固定输入、实际送达事件、持续活动和信息保持；可用学习仍需至少5个训练seed、独立评估、MBON/downstream的A对中性B特异性及acquisition/reversal/retention/delayed-reward对照。",
+                  "封存排除 .venv 与 __pycache__，保留环境安装报告；manifest列出payload哈希，checksums另含manifest，不存在自哈希循环。", ""])
+    with (EXP / "REPORT.md").open("x", encoding="utf-8") as stream:
+        stream.write("\n".join(lines))
+    seal(MODEL)
+    seal(EXP)
+    print(json.dumps({"status": summary["status"], "laboratory_validation_pass": passed,
+                      "failed_checks": len(failures), "learning_achieved": False,
+                      "whole_brain_alternative_run": False, "sealed": [str(MODEL), str(EXP)]},
+                     ensure_ascii=False), flush=True)
+    return 0 if passed else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

models/male-cns-lif/author-semantics-lab-v1/interface_audit.py

@@ -0,0 +1,149 @@
+"""Compile-only audit of the pinned author's sensory Poisson interface.
+
+This is separate from the common single-seed diagnostic.  Zero simulation time
+is advanced, so this audit does not draw or validate any Poisson realization.
+"""
+from __future__ import annotations
+
+import hashlib
+import types
+
+import numpy as np
+import pandas as pd
+
+from context import CFG, EXP, digest, save
+from oracle_runner import AUTHOR_COMMIT, AUTHOR_SHA256, _code_records, _environment
+
+
+def audit_author_poi() -> dict:
+    """Create the original model and poi helper, compile at t=0, and save evidence."""
+    author_path = EXP / "external-resources" / "model.py"
+    author_bytes = author_path.read_bytes()
+    source_hash = hashlib.sha256(author_bytes).hexdigest()
+    if source_hash != AUTHOR_SHA256:
+        raise ValueError("The Poisson audit requires the exact pinned author source")
+    output = EXP / "oracle" / "poi-interface"
+    output.mkdir(parents=True, exist_ok=False)
+    environment = _environment()
+    save(output / "environment.json", environment)
+    if environment["packages"]["brian2"]["actual"] != "2.5.1":
+        raise RuntimeError("The Poisson interface audit requires Brian2 2.5.1")
+
+    import brian2 as b2
+
+    preferences = {name: b2.prefs[name] for name in (
+        "codegen.target", "core.default_float_dtype", "legacy.refractory_timing")}
+    old_dt = b2.defaultclock.dt
+    try:
+        b2.start_scope()
+        b2.prefs["codegen.target"] = "numpy"
+        b2.prefs["core.default_float_dtype"] = np.float64
+        b2.prefs["legacy.refractory_timing"] = False
+        b2.defaultclock.dt = float(CFG["dt_ms"]) * b2.ms
+        author = types.ModuleType("phase4ad_poi_author_" + source_hash[:12])
+        author.__file__ = str(author_path)
+        # Execute exactly the reviewed bytes; create no bytecode beside the source.
+        exec(compile(author_bytes, str(author_path), "exec"), author.__dict__)
+        parameters = dict(author.default_params)
+
+        nodes = np.array([-2, -1], dtype=np.int32)
+        completeness = pd.DataFrame(
+            {"local_index": np.array([0, 1], dtype=np.int32)},
+            index=pd.Index(nodes, name="synthetic_global_neuron_idx"))
+        connections = pd.DataFrame({
+            "Presynaptic_Index": np.array([0], dtype=np.int32),
+            "Postsynaptic_Index": np.array([1], dtype=np.int32),
+            "Excitatory x Connectivity": np.array([1], dtype=np.int64),
+            "raw_count": np.array([1], dtype=np.int64),
+            "edge_id": np.array([-1], dtype=np.int64),
+            "source_neuron_idx": nodes[:1], "target_neuron_idx": nodes[1:],
+        })
+        comp_path = output / "completeness.csv"
+        con_path = output / "connectivity.parquet"
+        completeness.to_csv(comp_path)
+        connections.to_parquet(con_path, index=False, engine="pyarrow")
+        neu, syn, spikes = author.create_model(comp_path, con_path, parameters)
+        rfc_before = np.asarray(neu.rfc[:] / b2.ms, dtype=np.float64).copy()
+        # One excited target plus one untouched cell makes the helper's scope
+        # observable.  The optional second-rate class is not exercised here.
+        inputs, same_neu = author.poi(neu, [0], [], parameters)
+        if same_neu is not neu:
+            raise AssertionError("The author poi helper returned a different neuron group")
+        rfc_after = np.asarray(neu.rfc[:] / b2.ms, dtype=np.float64).copy()
+        before_v = np.asarray(neu.v_[:], dtype=np.float64).copy()
+        before_g = np.asarray(neu.g_[:], dtype=np.float64).copy()
+        before_w = np.asarray(syn.w_[:], dtype=np.float64).copy()
+        network = b2.Network(neu, syn, spikes, *inputs)
+        save(output / "schedule.json", {
+            "schedule": list(network.schedule),
+            "summary": str(network.scheduling_summary()),
+        })
+        network.run(0 * b2.ms, namespace={})
+        save(output / "generated-code.json", _code_records(network))
+
+        input_records = []
+        for item in inputs:
+            # PoissonInput 2.5.1 retains its on-the-fly subgroup as _group;
+            # N/rate/weight/target_var are its public read-only properties.
+            target = item._group
+            input_records.append({
+                "name": item.name, "type": type(item).__name__,
+                "target_group": target.name,
+                "target_local_start": int(target.start),
+                "target_local_stop": int(target.stop),
+                "target_global_nodes": nodes[int(target.start):int(target.stop)].tolist(),
+                "target_var": item.target_var, "N": int(item.N),
+                "rate_hz": float(item.rate / b2.Hz),
+                "weight_mv": float(item.weight / b2.mV),
+                "weight_volt": float(item.weight / b2.volt),
+                "when": item.when, "order": int(item.order),
+                "dt_ms": float(item.clock.dt / b2.ms),
+                "abstract_code": str(item.abstract_code),
+                "generated_code": [str(code.code) for code in item.code_objects],
+            })
+        expected_rfc = float(parameters["t_rfc"] / b2.ms)
+        expected_weight = float(parameters["w_syn"] * parameters["f_poi"] / b2.mV)
+        expected_rate = float(parameters["r_poi"] / b2.Hz)
+        checks = {
+            "exact_author_source": digest(author_path) == source_hash,
+            "one_poisson_input": len(input_records) == 1,
+            "initial_refractory_is_original": bool(np.array_equal(rfc_before, [expected_rfc, expected_rfc])),
+            "only_excited_target_loses_refractory": bool(np.array_equal(rfc_after, [0., expected_rfc])),
+            "actual_voltage_interface": all(r["target_var"] == "v" for r in input_records),
+            "actual_N_one": all(r["N"] == 1 for r in input_records),
+            "actual_rate_150_hz": bool(expected_rate == 150. and all(r["rate_hz"] == expected_rate for r in input_records)),
+            "actual_weight_68_75_mv": bool(np.isclose(expected_weight, 68.75, rtol=0, atol=1e-12)
+                                           and all(np.isclose(r["weight_mv"], expected_weight, rtol=0, atol=1e-12) for r in input_records)),
+            "actual_synapses_slot_order_zero": all(r["when"] == "synapses" and r["order"] == 0 for r in input_records),
+            "zero_elapsed_time": float(network.t / b2.ms) == 0.,
+            "no_recorded_spikes": len(spikes.i[:]) == 0,
+            "compile_preserves_voltage": bool(np.array_equal(before_v, np.asarray(neu.v_[:]))),
+            "compile_preserves_g": bool(np.array_equal(before_g, np.asarray(neu.g_[:]))),
+            "compile_preserves_weights": bool(np.array_equal(before_w, np.asarray(syn.w_[:]))),
+            "compile_preserves_refractory_configuration": bool(np.array_equal(rfc_after, np.asarray(neu.rfc[:] / b2.ms))),
+        }
+        result = {
+            "gate": bool(all(checks.values())), "checks": checks,
+            "author_commit": AUTHOR_COMMIT, "author_sha256": source_hash,
+            "fixture": "two synthetic nodes, one raw_count=1 connection",
+            "nodes": nodes.tolist(), "exc_local_indices": [0], "exc2_local_indices": [],
+            "rfc_before_ms": rfc_before.tolist(), "rfc_after_ms": rfc_after.tolist(),
+            "poisson_inputs": input_records,
+            "synaptic_weight_mv": np.asarray(syn.w[:] / b2.mV, dtype=np.float64).tolist(),
+            "input_hashes": {"completeness.csv": digest(comp_path), "connectivity.parquet": digest(con_path)},
+            "simulation_duration_ms": 0., "stochastic_time_steps": 0,
+            "random_realization_tested": False, "common_seed_experiment": False,
+            "interpretation": "Original poi adds 68.75 mV to voltage at 150 Hz with N=1 in the synapses slot and sets its target rfc to zero. This interface is not the common initial seed experiment.",
+            "scope": "Compile-time interface audit only; no stochastic trial, learning, or whole-brain simulation. The optional exc2 helper branch is not exercised.",
+        }
+        save(output / "audit.json", result)
+        if not result["gate"]:
+            raise AssertionError("Author Poisson interface gate failed: " + str(checks))
+        return result
+    except Exception as error:
+        save(output / "error.json", {"type": type(error).__name__, "message": str(error)})
+        raise
+    finally:
+        for name, value in preferences.items():
+            b2.prefs[name] = value
+        b2.defaultclock.dt = old_dt

models/male-cns-lif/author-semantics-lab-v1/manifest.json

@@ -0,0 +1,67 @@
+{
+  "schema": "sha256-artifact-manifest-v1",
+  "root": "/data/digital-drosophila/models/male-cns-lif/author-semantics-lab-v1",
+  "created_utc": "2026-09-29T23:19:04.144370+00:00",
+  "excluded_directory_names": [
+    ".venv",
+    "__pycache__"
+  ],
+  "self_hash_policy": "Manifest lists payload files; checksums also hashes manifest; neither hashes checksums.",
+  "files": [
+    {
+      "path": "PROTOCOL.md",
+      "bytes": 4577,
+      "sha256": "23e784ca1cbde7546373dbcbedbe2bc23d35083084f120068bf06100f238b09a"
+    },
+    {
+      "path": "config.json",
+      "bytes": 1332,
+      "sha256": "a69e8da5332d8031cbe1663abff25e61ee04e75f5490e8fa44c48690d3d0e219"
+    },
+    {
+      "path": "context.py",
+      "bytes": 1057,
+      "sha256": "561d405ee4a2d3bbc6982c89191523f348d6fae0630dea9cb67ddf03acc6fc7b"
+    },
+    {
+      "path": "finalize.py",
+      "bytes": 25910,
+      "sha256": "97a393b95d100dc5d95b624e4cd0d15511307b8c70e0ebd788b773c143ebfed6"
+    },
+    {
+      "path": "interface_audit.py",
+      "bytes": 8415,
+      "sha256": "1e2b31545f1206fe1c1f4084b4a9ac0f21c74990c52e8fd156e809725fc5fb95"
+    },
+    {
+      "path": "math_lab.py",
+      "bytes": 4533,
+      "sha256": "9663da41d5f623e1d7750e3cad3df880148079968f115bf583b58799fc5fb31f"
+    },
+    {
+      "path": "oracle_runner.py",
+      "bytes": 18548,
+      "sha256": "2f4b073261965cf18a94697caf725c40b2e8db790c2871862201337f40c399e5"
+    },
+    {
+      "path": "prepare.py",
+      "bytes": 3453,
+      "sha256": "49caa9553938f06539ecf282868491f8e1319d8f24220f89ac9e232db2d82e51"
+    },
+    {
+      "path": "requirements-oracle.txt",
+      "bytes": 453,
+      "sha256": "a69efc6509b85a5cc00a652caa4820c9c9e1406f6b97c6cc741322728c4d51c3"
+    },
+    {
+      "path": "run_lab.py",
+      "bytes": 10795,
+      "sha256": "8746e1971c5a40a738e10f8f574a243c29cefa5a8b9f61a2846557ceffd1289a"
+    },
+    {
+      "path": "verify_frozen.py",
+      "bytes": 2613,
+      "sha256": "fe37a48ce804e6c50f93404bfd3c23a7e54cd49061bbdfb4860315879648c73b"
+    }
+  ]
+}

models/male-cns-lif/author-semantics-lab-v1/math_lab.py

@@ -0,0 +1,70 @@
+"""Independent event-scheduled author equation and preserved frozen component arms."""
+import sys
+from pathlib import Path
+import numpy as np
+
+sys.path.insert(0,'/data/digital-drosophila/models/male-cns-lif/lif-semantics-audit-v1')
+from math_reference import params, state
+
+
+def component(nodes,edges,weights,config,policy,seed_node):
+    p=params(config['model']);n=len(nodes);steps=round(config['duration_ms']/config['dt_ms'])
+    ix={int(x):i for i,x in enumerate(nodes)}
+    src=np.array([ix[int(x)] for x in edges.source_neuron_idx],np.int32)
+    dst=np.array([ix[int(x)] for x in edges.target_neuron_idx],np.int32)
+    v=np.full(n,p['rest'],np.float32);g=np.zeros(n,np.float32);ref=np.zeros(n,np.int32)
+    qlen=p['delay_steps']+1;q=np.zeros((qlen,n),np.float32)
+    history=np.empty((steps,3,n),np.float32);counts=np.zeros(n,np.int32);ts=[];ns=[]
+    for t in range(steps):
+        v,g,ref,fire=state(v,g,ref,q[t%qlen],p,policy);q[t%qlen]=0
+        if t==0 and seed_node is not None:
+            k=ix[seed_node];assert not fire[k] and ref[k]==0
+            fire[k]=True;v[k]=p['reset'];ref[k]=p['ref_steps']
+            if policy in ('reset_g_only','reset_and_refractory'):g[k]=np.float32(0)
+        counts+=fire;active=np.flatnonzero(fire);ts.extend([t]*len(active));ns.extend(nodes[active].tolist())
+        selected=np.flatnonzero(fire[src]);selected=selected[np.argsort(dst[selected],kind='stable')]
+        for target in np.unique(dst[selected]):
+            acc=np.float32(0)
+            for e in selected[dst[selected]==target]:acc=np.float32(acc+weights[e])
+            slot=(t+p['delay_steps'])%qlen;q[slot,target]=np.float32(q[slot,target]+acc)
+        history[t]=v,g,ref
+    return dict(step=np.array(ts,np.int32),neuron_idx=np.array(ns,np.int32),counts=counts,v=v,g=g,ref=ref,history=history,queue=q)
+
+
+def author_numpy(nodes,edges,config,precision,seed_node,external_arrivals=None):
+    """Analytic integration in SI volts; sequential arrival writes follow spike detection."""
+    f=np.dtype(precision).type;m=config['model'];n=len(nodes);dt=config['dt_ms']
+    steps=round(config['duration_ms']/dt);rs=round(m['refractory_ms']/dt);ds=round(m['synaptic_delay_ms']/dt)
+    ix={int(x):i for i,x in enumerate(nodes)}
+    src=np.array([ix[int(x)] for x in edges.source_neuron_idx],np.int32)
+    dst=np.array([ix[int(x)] for x in edges.target_neuron_idx],np.int32)
+    weights=np.asarray(edges.raw_count.to_numpy(np.float64)*(m['w_syn_mv_per_anatomical_synapse']*.001),dtype=precision)
+    rest=m['resting_potential_mv']*.001;reset=m['reset_potential_mv']*.001;threshold=m['threshold_mv']*.001
+    v=np.full(n,rest,dtype=precision);g=np.zeros(n,dtype=precision)
+    last=np.full(n,-1000000,np.int64);counts=np.zeros(n,np.int32)
+    em=np.exp(-dt/m['membrane_tau_ms']);es=np.exp(-dt/m['synaptic_tau_ms'])
+    drive=m['synaptic_tau_ms']/(m['membrane_tau_ms']-m['synaptic_tau_ms'])*(em-es)
+    history=np.empty((steps,3,n),np.float64);queue=[[] for _ in range(ds+1)];ts=[];ns=[]
+    external=np.zeros((steps,n),dtype=precision) if external_arrivals is None else np.asarray(np.asarray(external_arrivals,np.float64)*.001,dtype=precision)
+    assert external.shape==(steps,n)
+    for t in range(steps):
+        available=(t-last)>=rs
+        # Use previous g for the coupled exact differential update, then cast to variable dtype.
+        oldg=g.copy()
+        v[available]=np.asarray(rest+em*(v[available]-rest)+drive*oldg[available],dtype=precision)
+        g[available]=np.asarray(es*oldg[available],dtype=precision)
+        if t==0 and seed_node is not None:v[ix[seed_node]]=f(threshold+config['seed_margin_mv']*.001)
+        fire=available&(v>threshold);last[fire]=t;counts+=fire
+        active=np.flatnonzero(fire);ts.extend([t]*len(active));ns.extend(nodes[active].tolist())
+        accept=available&~fire
+        due=queue[t%(ds+1)];queue[t%(ds+1)]=[]
+        for e in due:
+            if accept[dst[e]]:g[dst[e]]=f(g[dst[e]]+weights[e])
+        for j in np.flatnonzero(external[t]):
+            if accept[j]:g[j]=f(g[j]+external[t,j])
+        queue[(t+ds)%(ds+1)].extend(np.flatnonzero(fire[src]).tolist())
+        v[fire]=f(reset);g[fire]=f(0)
+        ref=np.maximum(rs-(t-last),0).astype(np.int32)
+        history[t]=np.asarray(v,np.float64)*1000,np.asarray(g,np.float64)*1000,ref
+    return dict(step=np.array(ts,np.int32),neuron_idx=np.array(ns,np.int32),counts=counts,
+        v=np.asarray(v,np.float64)*1000,g=np.asarray(g,np.float64)*1000,ref=ref,history=history,weights=np.asarray(weights,np.float64)*1000)

models/male-cns-lif/author-semantics-lab-v1/oracle_runner.py

@@ -0,0 +1,346 @@
+"""Run the pinned author's create_model in a dedicated, serial Brian2 process.
+
+This module never edits the author source or its parameters.  The caller supplies
+an exclusive output directory and the already validated, signed connectivity
+multipliers in ``raw_count``.  Global IDs are not FlyWire IDs and are mapped only
+for this small-circuit diagnostic.  Brian stores voltages in SI volts internally;
+the returned state and weights are converted to mV in the selected dtype.
+"""
+from __future__ import annotations
+
+import hashlib
+import importlib.metadata
+import json
+import platform
+import sys
+import types
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+
+AUTHOR_SHA256 = "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e"
+AUTHOR_COMMIT = "91bdd1e7dcf193f3e7ca5a8933497fcef63b7960"
+PACKAGE_PINS = {
+    "brian2": "2.5.1", "numpy": "1.22.3", "pandas": "1.4.3",
+    "scipy": "1.8.1", "pyarrow": "11.0.0", "joblib": "1.2.0",
+    "cython": "0.29.33", "jinja2": "2.11.3", "markupsafe": "1.1.1",
+    "sympy": "1.12", "mpmath": "1.3.0", "pyparsing": "3.0.9",
+    "packaging": "23.1", "setuptools": "67.8.0",
+    "python-dateutil": "2.8.2", "pytz": "2023.3", "six": "1.16.0",
+    "wheel": "0.38.4",
+}
+
+
+def _json(path: Path, value) -> None:
+    with path.open("x", encoding="utf-8") as output:
+        json.dump(value, output, indent=2, sort_keys=True, allow_nan=False)
+        output.write("\n")
+
+
+def _steps(value: float, dt: float, label: str, *, positive=False) -> int:
+    ratio = float(value) / dt
+    if not np.isfinite(ratio) or ratio < 0:
+        raise ValueError(f"{label} must be finite and nonnegative")
+    result = int(round(ratio))
+    if not np.isclose(ratio, result, rtol=0, atol=1e-9):
+        raise ValueError(f"{label} must be an integer number of dt steps")
+    if result > np.iinfo(np.int32).max or (positive and result == 0):
+        raise ValueError(f"{label} is outside the supported step range")
+    return result
+
+
+def _int_vector(values, label: str, dtype=np.int64) -> np.ndarray:
+    source = np.asarray(values)
+    if source.ndim != 1 or source.dtype.kind not in "iu":
+        raise ValueError(f"{label} must be a one-dimensional integer array")
+    limits = np.iinfo(dtype)
+    if np.any(source < limits.min) or np.any(source > limits.max):
+        raise ValueError(f"{label} is outside {np.dtype(dtype).name} range")
+    return source.astype(dtype, copy=True)
+
+
+def _environment() -> dict:
+    packages = {}
+    for name, expected in PACKAGE_PINS.items():
+        try:
+            actual = importlib.metadata.version(name)
+        except importlib.metadata.PackageNotFoundError:
+            actual = None
+        packages[name] = {"expected": expected, "actual": actual,
+                          "matches": actual == expected}
+    return {
+        "python": platform.python_version(), "author_python": "3.10.11",
+        "python_patch_matches": platform.python_version() == "3.10.11",
+        "python_executable": sys.executable, "platform": platform.platform(),
+        "author_platform": "Windows", "packages": packages,
+        "all_package_pins_match": all(p["matches"] for p in packages.values()),
+        "binary_identical_author_environment_claimed": False,
+    }
+
+
+def _code_text(value):
+    if isinstance(value, dict):
+        return {str(key): _code_text(item) for key, item in value.items()}
+    return str(value)
+
+
+def _code_records(network) -> list:
+    records = []
+    for obj in network.sorted_objects:
+        record = {"name": obj.name, "type": type(obj).__name__,
+                  "when": obj.when, "order": int(obj.order),
+                  "active": bool(obj.active)}
+        for key in ("abstract_code", "user_code"):
+            if hasattr(obj, key):
+                record[key] = _code_text(getattr(obj, key))
+        record["code_objects"] = [
+            {"name": code.name, "type": type(code).__name__,
+             "generated_code": _code_text(code.code)}
+            for code in getattr(obj, "code_objects", ())
+        ]
+        records.append(record)
+    return records
+
+
+def run_brian(author_path: Path, io_dir: Path, nodes: np.ndarray,
+              edges: pd.DataFrame, config: dict, precision: str,
+              seed_node: int | None, external_arrivals=None) -> dict:
+    """Execute an unchanged author model and return canonical end-of-tick arrays.
+
+    ``external_arrivals`` is either None or a (T, N) array in mV.  Every nonzero
+    entry gets its own SpikeGeneratorGroup source and zero-delay conditional
+    synaptic write, ordered after the anatomical synapses.  It is not direct
+    Python assignment to g.  ``seed_margin_mv`` may be zero for a strict-threshold
+    fixture; positive margins must remain representably above the threshold.
+
+    This function controls process-global Brian preferences and is not thread
+    safe.  Use only the isolated oracle environment, serially or in subprocesses.
+    A failed run keeps its exclusive inputs and an error record for diagnosis.
+    """
+    if precision not in ("float64", "float32"):
+        raise ValueError("precision must be float64 or float32")
+    dtype = np.dtype(precision)
+    nodes = _int_vector(nodes, "nodes", np.int32)
+    if not len(nodes) or np.any(np.diff(nodes.astype(np.int64)) <= 0):
+        raise ValueError("nodes must be nonempty, sorted, and unique")
+    required = ["edge_id", "source_neuron_idx", "target_neuron_idx", "raw_count"]
+    if not set(required).issubset(edges.columns):
+        raise ValueError(f"edges require columns {required}")
+    edge_ids = _int_vector(edges.edge_id, "edge_id")
+    if np.any(np.diff(edge_ids) <= 0):
+        raise ValueError("edge_id order must be canonical, increasing, and unique")
+    sources = _int_vector(edges.source_neuron_idx, "source_neuron_idx", np.int32)
+    targets = _int_vector(edges.target_neuron_idx, "target_neuron_idx", np.int32)
+    multipliers = _int_vector(edges.raw_count, "raw_count")
+    if not np.isin(sources, nodes).all() or not np.isin(targets, nodes).all():
+        raise ValueError("all edge endpoints must occur in nodes")
+    lookup = {int(node): i for i, node in enumerate(nodes)}
+    if seed_node is not None and int(seed_node) not in lookup:
+        raise ValueError("seed_node must occur in nodes")
+
+    dt_ms = float(config["dt_ms"])
+    if not np.isfinite(dt_ms) or dt_ms <= 0:
+        raise ValueError("dt_ms must be finite and positive")
+    total_steps = _steps(config["duration_ms"], dt_ms, "duration_ms", positive=True)
+    model = config["model"]
+    refractory_steps = _steps(model["refractory_ms"], dt_ms, "refractory_ms")
+    delay_steps = _steps(model["synaptic_delay_ms"], dt_ms, "synaptic_delay_ms")
+    margin_mv = float(config["seed_margin_mv"])
+    if not np.isfinite(margin_mv) or margin_mv < 0:
+        raise ValueError("seed_margin_mv must be finite and nonnegative")
+    if "dt_ms" in model and float(model["dt_ms"]) != dt_ms:
+        raise ValueError("top-level and model dt_ms disagree")
+    arrivals = None
+    if external_arrivals is not None:
+        arrivals = np.asarray(external_arrivals, dtype=np.float64)
+        if arrivals.shape != (total_steps, len(nodes)) or not np.isfinite(arrivals).all():
+            raise ValueError("external_arrivals must be finite with shape (T, N)")
+
+    author_path = Path(author_path).resolve(strict=True)
+    author_bytes = author_path.read_bytes()
+    author_hash = hashlib.sha256(author_bytes).hexdigest()
+    if author_hash != AUTHOR_SHA256:
+        raise ValueError(f"Author source hash mismatch: {author_hash}")
+    io_dir = Path(io_dir).resolve()
+    io_dir.mkdir(parents=True, exist_ok=False)
+    environment = _environment()
+    _json(io_dir / "environment.json", environment)
+    if environment["packages"]["brian2"]["actual"] != "2.5.1":
+        raise RuntimeError("The author oracle requires exactly Brian2 2.5.1")
+
+    import brian2 as b2
+
+    saved_preferences = {
+        "codegen.target": b2.prefs["codegen.target"],
+        "core.default_float_dtype": b2.prefs["core.default_float_dtype"],
+        "legacy.refractory_timing": b2.prefs["legacy.refractory_timing"],
+    }
+    saved_dt = b2.defaultclock.dt
+    try:
+        b2.start_scope()
+        b2.prefs["codegen.target"] = "numpy"
+        b2.prefs["core.default_float_dtype"] = dtype.type
+        b2.prefs["legacy.refractory_timing"] = False
+        b2.defaultclock.dt = dt_ms * b2.ms
+        # Compile the checked bytes themselves: no source rewrite or __pycache__
+        # is possible, and a subsequent file change cannot alter imported code.
+        author = types.ModuleType("phase4ad_pinned_author_" + author_hash[:12])
+        author.__file__ = str(author_path)
+        exec(compile(author_bytes, str(author_path), "exec"), author.__dict__)
+        parameters = dict(author.default_params)
+        checks = {}
+        for config_key, author_key, unit in (
+            ("membrane_tau_ms", "t_mbr", b2.ms),
+            ("synaptic_tau_ms", "tau", b2.ms),
+            ("refractory_ms", "t_rfc", b2.ms),
+            ("synaptic_delay_ms", "t_dly", b2.ms),
+            ("resting_potential_mv", "v_0", b2.mV),
+            ("reset_potential_mv", "v_rst", b2.mV),
+            ("threshold_mv", "v_th", b2.mV),
+            ("w_syn_mv_per_anatomical_synapse", "w_syn", b2.mV),
+        ):
+            expected = float(model[config_key])
+            actual = float(parameters[author_key] / unit)
+            if not np.isfinite(expected) or not np.isclose(actual, expected, rtol=0, atol=1e-12):
+                raise ValueError(f"config {config_key}={expected} differs from author {actual}")
+            checks[config_key] = {"config": expected, "author": actual}
+
+        completeness = pd.DataFrame({"local_index": np.arange(len(nodes), dtype=np.int32)},
+                                    index=pd.Index(nodes, name="global_neuron_idx"))
+        connections = pd.DataFrame({
+            "Presynaptic_Index": [lookup[int(x)] for x in sources],
+            "Postsynaptic_Index": [lookup[int(x)] for x in targets],
+            "Excitatory x Connectivity": multipliers,
+            "edge_id": edge_ids,
+            "source_neuron_idx": sources, "target_neuron_idx": targets,
+        }).astype({"Presynaptic_Index": "int32", "Postsynaptic_Index": "int32"})
+        comp_path = io_dir / "completeness.csv"
+        con_path = io_dir / "connectivity.parquet"
+        completeness.to_csv(comp_path)
+        connections.to_parquet(con_path, index=False, engine="pyarrow")
+        neu, syn, spikes = author.create_model(comp_path, con_path, parameters)
+        if np.dtype(neu.variables["v"].dtype) != dtype or np.dtype(syn.variables["w"].dtype) != dtype:
+            raise AssertionError("Brian did not allocate the requested floating-point dtype")
+        np.testing.assert_array_equal(np.asarray(syn.i[:]), connections.Presynaptic_Index)
+        np.testing.assert_array_equal(np.asarray(syn.j[:]), connections.Postsynaptic_Index)
+
+        objects = [neu, syn, spikes]
+        seed_state = {"requested_global_node": None if seed_node is None else int(seed_node),
+                      "margin_mv": margin_mv, "injections": 0}
+        if seed_node is not None:
+            seed_local = lookup[int(seed_node)]
+
+            def inject_seed():
+                if seed_state["injections"] == 0:
+                    if float(b2.defaultclock.t / b2.ms) != 0:
+                        raise AssertionError("Seed injection must occur at tick zero")
+                    neu.v[seed_local] = parameters["v_th"] + margin_mv * b2.mV
+                    applied = float(neu.v[seed_local] / b2.mV)
+                    if margin_mv > 0 and not applied > float(parameters["v_th"] / b2.mV):
+                        raise ValueError("The positive seed margin rounded away in the selected dtype")
+                    seed_state["applied_mv"] = applied
+                    seed_state["injections"] = 1
+
+            objects.append(b2.NetworkOperation(inject_seed, clock=neu.clock,
+                                               when="before_thresholds", order=0,
+                                               name="oracle_seed_injection"))
+
+        external_metadata = {"events": 0, "ordering": "after default_synapses.pre"}
+        if arrivals is not None:
+            event_ticks, event_targets = np.nonzero(arrivals)
+            event_values = arrivals[event_ticks, event_targets]
+            external_metadata["events"] = int(len(event_ticks))
+            if len(event_ticks):
+                event_ids = np.arange(len(event_ticks), dtype=np.int32)
+                external_source = b2.SpikeGeneratorGroup(
+                    len(event_ticks), indices=event_ids,
+                    times=event_ticks.astype(np.float64) * dt_ms * b2.ms,
+                    sorted=True, clock=neu.clock, name="zz_external_sources")
+                external_syn = b2.Synapses(
+                    external_source, neu, model="w : volt", on_pre="g_post += w",
+                    delay=0 * b2.ms, name="zz_external_arrivals")
+                external_syn.connect(i=event_ids, j=event_targets)
+                external_syn.w = event_values * b2.mV
+                external_syn.pre.order = int(syn.pre.order) + 1
+                if external_syn.pre.when != syn.pre.when:
+                    raise AssertionError("External and anatomical pathways must share a schedule slot")
+                objects.extend([external_source, external_syn])
+                external_metadata["pathway_order"] = int(external_syn.pre.order)
+                external_metadata["actual_weights_mv"] = np.asarray(external_syn.w[:] / b2.mV, dtype=dtype).tolist()
+            pd.DataFrame({"tick": event_ticks, "neuron_idx": nodes[event_targets],
+                          "requested_mv": event_values}).to_csv(io_dir / "external-arrivals.csv", index=False)
+
+        trace = b2.StateMonitor(neu, ["v", "g", "lastspike", "not_refractory"],
+                                record=True, when="end", name="oracle_end_state")
+        objects.append(trace)
+        network = b2.Network(*objects)
+        _json(io_dir / "run-spec.json", {
+            "author_sha256": author_hash, "author_commit": AUTHOR_COMMIT,
+            "precision": precision, "config": config, "parameter_checks": checks,
+            "dt_ms": dt_ms, "steps": total_steps, "refractory_steps": refractory_steps,
+            "delay_steps": delay_steps, "nodes": nodes.tolist(), "edge_ids": edge_ids.tolist(),
+            "seed": seed_state.copy(), "external_arrivals": external_metadata,
+            "preferences": {"codegen.target": "numpy", "legacy.refractory_timing": False,
+                            "core.default_float_dtype": precision},
+            "weight_rule": "raw_count multiplied by unchanged author w_syn; no sign inference",
+            "internal_voltage_unit": "volt", "returned_voltage_unit": "mV",
+        })
+        _json(io_dir / "schedule.json", {"schedule": list(network.schedule),
+                                        "summary": str(network.scheduling_summary())})
+        network.run(float(config["duration_ms"]) * b2.ms, namespace={})
+        _json(io_dir / "generated-code.json", _code_records(network))
+
+        ticks_float = np.asarray(spikes.t[:] / b2.ms, dtype=np.float64) / dt_ms
+        ticks = np.rint(ticks_float).astype(np.int32)
+        if not np.allclose(ticks_float, ticks, rtol=0, atol=1e-6):
+            raise AssertionError("Spike timestamps do not lie on the configured integer clock")
+        event_nodes = nodes[np.asarray(spikes.i[:], dtype=np.int32)]
+        order = np.lexsort((event_nodes, ticks))
+        ticks, event_nodes = ticks[order], event_nodes[order]
+        counts = np.asarray(spikes.count[:], dtype=np.int32).copy()
+        if int(counts.sum()) != len(ticks):
+            raise AssertionError("SpikeMonitor counts disagree with event records")
+        trace_ticks = np.asarray(trace.t[:] / b2.ms, dtype=np.float64) / dt_ms
+        if trace_ticks.shape != (total_steps,) or not np.allclose(
+                trace_ticks, np.arange(total_steps), rtol=0, atol=1e-6):
+            raise AssertionError("End-state trace has the wrong tick range")
+        voltage = np.asarray(trace.v / b2.mV, dtype=dtype).T.copy()
+        conductance = np.asarray(trace.g / b2.mV, dtype=dtype).T.copy()
+        last_spike_ms = np.asarray(trace.lastspike / b2.ms, dtype=np.float64).T
+        seen = np.isfinite(last_spike_ms) & (last_spike_ms >= 0)
+        # Brian's never-spiked sentinel can be far outside int32.  Convert only
+        # real nonnegative timestamps, then compute an end-of-tick countdown.
+        last_ticks = np.zeros(last_spike_ms.shape, dtype=np.int64)
+        last_ticks[seen] = np.rint(last_spike_ms[seen] / dt_ms).astype(np.int64)
+        elapsed = np.arange(total_steps, dtype=np.int64)[:, None] - last_ticks
+        ref = np.where(seen, np.maximum(refractory_steps - elapsed, 0), 0).astype(np.int32)
+        available = np.asarray(trace.not_refractory, dtype=bool).T
+        if not np.array_equal(available, ref == 0):
+            raise AssertionError("Recorded refractory flag disagrees with the integer countdown")
+        history = np.stack([voltage, conductance, ref.astype(dtype)], axis=1)
+        if not np.isfinite(history).all():
+            raise AssertionError("Nonfinite author state")
+        if seed_node is not None:
+            seed_state["spiked_at_zero"] = bool(np.any((ticks == 0) & (event_nodes == seed_node)))
+            if seed_state["injections"] != 1 or (margin_mv > 0 and not seed_state["spiked_at_zero"]):
+                raise AssertionError("The common initial seed event was not produced exactly once")
+        _json(io_dir / "seed.json", seed_state)
+        weights = np.asarray(syn.w[:] / b2.mV, dtype=dtype).copy()
+        _json(io_dir / "actual-weights.json", {
+            "edge_id": edge_ids.tolist(), "weights_mv": weights.tolist(),
+            "weights_volt": np.asarray(syn.w_[:], dtype=np.float64).tolist(),
+        })
+        if hashlib.sha256(author_path.read_bytes()).hexdigest() != author_hash:
+            raise AssertionError("Author source changed during execution")
+        return {"step": ticks, "neuron_idx": event_nodes, "counts": counts,
+                "v": voltage[-1].copy(), "g": conductance[-1].copy(),
+                "ref": ref[-1].copy(), "history": history, "weights": weights}
+    except Exception as error:
+        _json(io_dir / "error.json", {"type": type(error).__name__, "message": str(error)})
+        raise
+    finally:
+        for name, value in saved_preferences.items():
+            b2.prefs[name] = value
+        b2.defaultclock.dt = saved_dt

models/male-cns-lif/author-semantics-lab-v1/prepare.py

@@ -0,0 +1,56 @@
+"""Predeclare and verify old inputs before executing any alternative dynamics."""
+import ast
+from datetime import datetime, timezone
+import importlib.metadata
+import json
+import platform
+from pathlib import Path
+import shutil
+import subprocess
+import sys
+from context import CFG,ROOT,EXP,MODEL,AC,digest,save,source_hashes
+
+
+def frozen_integrity():
+    sys.path.insert(0,str(ROOT/CFG['prior_model']))
+    import audit_semantics as old
+    result=old.integrity()
+    for p in (ROOT/CFG['prior_model'],AC,ROOT/'registry/feedback-context-review-20260930'):
+        result[str(p.relative_to(ROOT))]=old.manifest_check(p,digest)
+    assert all(x['pass'] for x in result.values())
+    return result
+
+
+def main():
+    assert (MODEL/'oracle_runner.py').is_file()
+    assert not (EXP/'protocol').exists(),'Refusing reused experiment protocol'
+    for d in ('protocol','external-resources','inputs','components','oracle','regression','audit','performance'):(EXP/d).mkdir()
+    source=AC/'external-resources/model.py'
+    assert digest(source)=='fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e'
+    tree=ast.parse(source.read_text())
+    assert all(isinstance(x,(ast.Import,ast.ImportFrom,ast.Assign,ast.FunctionDef,ast.Expr)) for x in tree.body)
+    inputs=[source,AC/'external-resources/LICENSE',AC/'external-resources/environment_full.yml',
+        AC/'audit/selected-real-edges.csv',AC/'audit/selected-metadata.parquet',ROOT/CFG['prior_model']/'math_reference.py']
+    for name in CFG['motifs']:
+        inputs.extend([AC/'motifs'/f'{name}-edges.csv',AC/'motifs'/f'{name}-events.parquet',AC/'motifs'/f'{name}-state.npz'])
+    save(EXP/'protocol/preregistered.json',dict(config=CFG,timestamp_utc=datetime.now(timezone.utc).isoformat(),
+        source_hashes=source_hashes(),input_hashes=[dict(path=str(p.relative_to(ROOT)),sha256=digest(p),bytes=p.stat().st_size) for p in inputs],
+        parent_commit=subprocess.check_output(['git','-C',str(ROOT),'rev-parse','HEAD'],text=True).strip(),
+        pre_model_execution=True))
+    save(EXP/'regression/old-integrity-before.json',frozen_integrity())
+    for name in ('model.py','LICENSE','environment_full.yml'):
+        dst=EXP/'external-resources'/name
+        with (AC/'external-resources'/name).open('rb') as src,dst.open('xb') as out:shutil.copyfileobj(src,out)
+        assert digest(dst)==digest(AC/'external-resources'/name)
+    versions={n:importlib.metadata.version(n) for n in ('numpy','pandas','pyarrow','torch','scipy')}
+    save(EXP/'environment/frozen-scientific-environment.json',dict(python=sys.version,executable=sys.executable,
+        platform=platform.platform(),package_versions=versions))
+    save(EXP/'environment/bootstrap-notes.json',dict(isolated_venv_only=True,existing_environments_modified=False,
+        initial_install_failure='New venv pip22.0.2 lacks --report; upgraded ONLY new venv pip to author-pinned23.0.1 before installing',
+        MarkupSafe='Author-pinned1.1.1 used PyPI source distribution and legacy setup.py because no CPython3.10 wheel; other requested core packages used wheels',
+        author_environment='Windows conda CPython3.10.11',actual_environment='Linux CPython3.10.12; not binary-identical',
+        package_download_provenance='install-report.json contains HTTPS PyPI archive URLs and SHA256 for packages'))
+    print('PREPARED: old integrity PASS; independent model hypotheses preregistered',flush=True)
+
+
+if __name__=='__main__':main()

models/male-cns-lif/author-semantics-lab-v1/requirements-oracle.txt

@@ -0,0 +1,20 @@
+# Package versions in the pinned author's environment_full.yml, Linux wheels.
+# The host Python patch is recorded separately; this is not the author's Windows binary environment.
+brian2==2.5.1
+numpy==1.22.3
+pandas==1.4.3
+scipy==1.8.1
+pyarrow==11.0.0
+joblib==1.2.0
+cython==0.29.33
+jinja2==2.11.3
+markupsafe==1.1.1
+sympy==1.12
+mpmath==1.3.0
+pyparsing==3.0.9
+packaging==23.1
+setuptools==67.8.0
+python-dateutil==2.8.2
+pytz==2023.3
+six==1.16.0
+wheel==0.38.4

models/male-cns-lif/author-semantics-lab-v1/run_lab.py

@@ -0,0 +1,158 @@
+"""Run fixed component arms and independent author oracle, preserving divergences."""
+import importlib.metadata
+import json
+from pathlib import Path
+import platform
+import sys
+import subprocess
+import time
+import numpy as np
+import pandas as pd
+from context import CFG,ROOT,EXP,MODEL,AC,digest,save,check_prereg
+from math_lab import component,author_numpy
+from oracle_runner import run_brian,PACKAGE_PINS
+
+
+def save_result(where,result,nodes):
+    where.mkdir(parents=True,exist_ok=False)
+    pd.DataFrame(dict(step=result['step'],neuron_idx=result['neuron_idx'])).to_csv(where/'events.csv',index=False)
+    np.savez_compressed(where/'state.npz',nodes=nodes,**{k:v for k,v in result.items() if k not in ('step','neuron_idx')})
+
+
+def compare(actual,expected,precision):
+    event=bool(np.array_equal(actual['step'],expected['step']) and np.array_equal(actual['neuron_idx'],expected['neuron_idx']))
+    a=np.asarray(actual['history'],np.float64);b=np.asarray(expected['history'],np.float64)
+    assert a.shape==b.shape
+    errs=np.abs(a[:,:2]-b[:,:2])
+    # Describe numerical prefix separately from post-event-divergence trajectories.
+    first=None
+    for t in range(len(a)):
+        aa=actual['neuron_idx'][actual['step']==t];bb=expected['neuron_idx'][expected['step']==t]
+        if not np.array_equal(aa,bb):first=t;break
+    prefix=errs[:first] if first is not None else errs
+    tol=CFG['comparison'][precision+'_state_max_abs_tolerance_mv']
+    return dict(exact_events=event,exact_counts=bool(np.array_equal(actual['counts'],expected['counts'])),
+        ref_exact=bool(np.array_equal(a[:,2],b[:,2])),max_abs_mv=float(errs.max()),mean_abs_mv=float(errs.mean()),
+        same_event_prefix_max_abs_mv=float(prefix.max()) if prefix.size else None,
+        first_event_divergence_step=first,tolerance_mv=tol,
+        pass_oracle=bool(event and errs.max()<=tol and np.array_equal(a[:,2],b[:,2])))
+
+
+def oracle_trial(name,nodes,edges,cfg,precision,seed,external=None):
+    io=EXP/'oracle'/(name+'-'+precision)
+    result=run_brian(EXP/'external-resources/model.py',io,nodes,edges,cfg,precision,seed,external)
+    independent=author_numpy(nodes,edges,cfg,precision,seed,external)
+    comparison=compare(result,independent,precision)
+    save(io/'comparison.json',comparison)
+    save_result(io/'brian-output',result,nodes);save_result(io/'independent-output',independent,nodes)
+    assert np.isfinite(result['history']).all() and np.isfinite(independent['history']).all()
+    return result,comparison
+
+
+def unit_fixtures():
+    rows=[];nodes=np.array([-1],np.int32)
+    # Brian2 2.5.1 calls max/min on connect arrays and rejects zero-length arrays.
+    # An explicitly synthetic zero-weight self-edge is inert, not an anatomical edge.
+    inert=pd.DataFrame(dict(edge_id=[-1],source_neuron_idx=[-1],target_neuron_idx=[-1],raw_count=[0]),dtype='int64')
+    for precision in CFG['author_precisions']:
+        # Synthetic fixture indices are negative and are not MaleCNS body IDs.
+        c=dict(CFG,duration_ms=20.0)
+        cases={}
+        a=np.zeros((200,1));cases['zero']=(a,None,1.0)
+        a=np.zeros((200,1));a[0,0]=1.;cases['weak_excitation']=(a,None,1.0)
+        a=np.zeros((200,1));a[0,0]=-1.;cases['inhibition']=(a,None,1.0)
+        a=np.zeros((200,1));a[[0,21,22,23],0]=.1;cases['refractory_boundary']=(a,-1,1.0)
+        a=np.zeros((200,1));cases['equal_threshold']=(a,-1,0.0)
+        a=np.zeros((200,1));cases['above_threshold']=(a,-1,1.0)
+        a=np.zeros((200,1));a[0,0]=2000.;cases['nonzero_g_reset']=(a,None,1.0)
+        for name,(arr,seed,margin) in cases.items():
+            cfg=dict(c,seed_margin_mv=margin)
+            r,cmp=oracle_trial('unit-'+name,nodes,inert,cfg,precision,seed,arr)
+            h=r['history'];events=r['step'];checks={}
+            if name=='zero':checks={'no_events':len(events)==0,'g_zero':bool(np.all(h[:,1]==0)),
+                'rest_stationary':bool(np.max(np.abs(h[:,0]-CFG['model']['resting_potential_mv']))<1e-3)}
+            elif name in ('weak_excitation','inhibition'):
+                checks={'no_events':len(events)==0,'arrival_at_zero':bool(h[0,1,0]>0 if name=='weak_excitation' else h[0,1,0]<0),
+                    'integration_next_step':bool(h[1,0,0]>h[0,0,0] if name=='weak_excitation' else h[1,0,0]<h[0,0,0])}
+            elif name=='refractory_boundary':checks={'one_seed':np.array_equal(events,[0]),'reject_through_21':bool(np.all(h[:22,1]==0)),
+                'accept_at_22':bool(h[22,1,0]>0),'release_at_22':bool(h[21,2,0]==1 and h[22,2,0]==0),'reset_g_at_zero':h[0,1,0]==0}
+            elif name=='equal_threshold':checks={'strict_threshold_no_event':len(events)==0}
+            elif name=='nonzero_g_reset':checks={'natural_spike_at_1':np.array_equal(events,[1]),
+                'nonzero_g_before_spike':bool(h[0,1,0]>1999),'zero_g_after_spike':bool(np.all(h[1:,1,0]==0))}
+            else:checks={'single_seed':np.array_equal(events,[0]),'reset_g':bool(h[0,1,0]==0)}
+            row=dict(fixture=name,precision=precision,checks={k:bool(v) for k,v in checks.items()},comparison=cmp)
+            rows.append(row);save(EXP/'regression'/('unit-'+name+'-'+precision+'.json'),row)
+            print(json.dumps(dict(unit=name,precision=precision,checks=all(checks.values()),oracle=cmp)),flush=True)
+        delay_nodes=np.array([-2,-1],np.int32)
+        weak_edge=pd.DataFrame(dict(edge_id=[-1],source_neuron_idx=[-2],target_neuron_idx=[-1],raw_count=[1]),dtype='int64')
+        r,cmp=oracle_trial('unit-delay_18',delay_nodes,weak_edge,c,precision,-2)
+        h=r['history'];checks=dict(one_seed=np.array_equal(r['step'],[0]),
+            zero_before_arrival=bool(np.all(h[:18,1,1]==0)),arrival_at_18=bool(h[18,1,1]>0),
+            first_voltage_effect_at_19=bool(h[19,0,1]>h[18,0,1]))
+        row=dict(fixture='delay_18',precision=precision,checks=checks,comparison=cmp)
+        rows.append(row);save(EXP/'regression'/('unit-delay_18-'+precision+'.json'),row)
+    save(EXP/'regression/unit-fixtures.json',rows)
+    # Unit oracle failures prevent real author-motif execution; preserve all failed traces.
+    assert all(all(r['checks'].values()) and r['comparison']['pass_oracle'] for r in rows),'Author operator unit gate failed'
+
+
+def main():
+    check_prereg();assert not (EXP/'audit/run-start.json').exists(),'Refusing overwritten run'
+    assert all(importlib.metadata.version(n)==v for n,v in PACKAGE_PINS.items()),'Dependency-pin mismatch'
+    save(EXP/'environment/installed-packages.json',json.loads(subprocess.check_output([sys.executable,'-m','pip','list','--format=json'],text=True)))
+    save(EXP/'audit/run-start.json',dict(python=sys.version,platform=platform.platform(),
+        packages={n:importlib.metadata.version(n) for n in ('brian2','numpy','pandas','scipy','pyarrow','sympy','cython')},
+        codegen='numpy',learning=False,user_authorized_new_model_hypotheses=True))
+    t0=time.perf_counter();rows=[];validations=[]
+    for name in CFG['motifs']:
+        edges=pd.read_csv(AC/'motifs'/f'{name}-edges.csv').sort_values('edge_id')
+        old=np.load(AC/'motifs'/f'{name}-state.npz');nodes=old['nodes'];seed=None if name=='no_input' else CFG['seed_node']
+        weights=edges.raw_count.to_numpy(np.float32)*np.float32(CFG['model']['w_syn_mv_per_anatomical_synapse'])
+        for policy in CFG['component_policies']:
+            r=component(nodes,edges,weights,CFG,policy,seed)
+            assert np.isfinite(r['history']).all()
+            if policy=='frozen':
+                ev=pd.read_parquet(AC/'motifs'/f'{name}-events.parquet')
+                eq={k:bool(np.array_equal(old[k],r[k])) for k in old.files if k!='nodes'}
+                eq['events']=bool(np.array_equal(ev.step,r['step']) and np.array_equal(ev.neuron_idx,r['neuron_idx']))
+                assert all(eq.values()),eq
+                validations.append(dict(motif=name,frozen_vs_4AC_exact=eq))
+            save_result(EXP/'components'/(name+'-'+policy),r,nodes)
+            late=r['step']>=round(CFG['late_start_ms']/CFG['dt_ms'])
+            for node in nodes:
+                select=r['neuron_idx']==node
+                rows.append(dict(motif=name,policy=policy,precision='float32',neuron_idx=int(node),spikes=int(select.sum()),
+                    late_spikes=int((select&late).sum()),last_ms=float(r['step'][select][-1]*CFG['dt_ms']) if select.any() else None))
+    pd.DataFrame(rows).to_csv(EXP/'components/summary.csv',index=False)
+    save(EXP/'regression/frozen-components.json',validations)
+    unit_fixtures()
+    from interface_audit import audit_author_poi
+    audit_author_poi()
+    ors=[]
+    for name in CFG['motifs']:
+        edges=pd.read_csv(AC/'motifs'/f'{name}-edges.csv').sort_values('edge_id')
+        nodes=np.load(AC/'motifs'/f'{name}-state.npz')['nodes'];seed=None if name=='no_input' else CFG['seed_node'];by_precision={}
+        for precision in CFG['author_precisions']:
+            r,cmp=oracle_trial(name,nodes,edges,CFG,precision,seed);by_precision[precision]=r
+            repeat=run_brian(EXP/'external-resources/model.py',EXP/'oracle'/(name+'-'+precision+'-repeat'),nodes,edges,CFG,precision,seed)
+            exact_repeat={k:bool(np.array_equal(r[k],repeat[k])) for k in r}
+            save_result(EXP/'oracle'/(name+'-'+precision+'-repeat')/'brian-output',repeat,nodes)
+            save(EXP/'regression'/(name+'-'+precision+'-repeat.json'),exact_repeat)
+            assert all(exact_repeat.values()),exact_repeat
+            late=r['step']>=round(CFG['late_start_ms']/CFG['dt_ms'])
+            for node in nodes:
+                chosen=r['neuron_idx']==node
+                rows.append(dict(motif=name,policy='author_complete',precision=precision,neuron_idx=int(node),
+                    spikes=int(chosen.sum()),late_spikes=int((chosen&late).sum()),last_ms=float(r['step'][chosen][-1]*CFG['dt_ms']) if chosen.any() else None))
+            ors.append(dict(motif=name,precision=precision,comparison=cmp))
+            print(json.dumps(dict(motif=name,precision=precision,events=len(r['step']),late=int(late.sum()),oracle=cmp)),flush=True)
+        save(EXP/'regression'/(name+'-precision-cross-comparison.json'),compare(by_precision['float32'],by_precision['float64'],'float32'))
+    pd.DataFrame(rows).to_csv(EXP/'audit/all-motif-results.csv',index=False)
+    save(EXP/'regression/author-motifs.json',ors)
+    save(EXP/'performance/summary.json',dict(wall_seconds=time.perf_counter()-t0,backend='CPU NumPy + Brian2',not_runtime_benchmark=True))
+    save(EXP/'audit/run-complete.json',dict(all_author_oracle_comparisons_pass=all(x['comparison']['pass_oracle'] for x in ors),
+        all_frozen_components_match_archive=True,learning_achieved=False,whole_brain_alternative_run=False,
+        author_original_source_sha256=digest(EXP/'external-resources/model.py')))
+
+
+if __name__=='__main__':main()

models/male-cns-lif/author-semantics-lab-v1/verify_frozen.py

@@ -0,0 +1,47 @@
+"""Unchanged deterministic-v2 five-trial regression; old outputs are read only."""
+import os
+import sys
+import time
+import numpy as np
+import pandas as pd
+import yaml
+from context import ROOT,EXP,CFG,save,check_prereg
+
+
+def main():
+    check_prereg()
+    assert not (EXP/'regression/frozen-five.json').exists()
+    runtime=ROOT/'models/male-cns-lif/runtime-v2-deterministic-candidate'
+    # Discover the exact prior-audit runtime path from its immutable config.
+    prior=yaml.safe_load((ROOT/CFG['prior_model']/'config.yaml').read_text())
+    runtime=ROOT/prior['runtime'];pc=yaml.safe_load((runtime/'phase4p.yaml').read_text())
+    sys.path.insert(0,str(ROOT/'models/male-cns-lif/terminal-scope-diagnostic-v1'))
+    from diagnostic import queues
+    queues()
+    os.environ['CUDA_VISIBLE_DEVICES']=pc['device']['visible_gpu_uuid']
+    os.environ['CUDA_HOME']='/usr/local/cuda';os.environ['MAX_JOBS']='2';os.environ['TORCH_CUDA_ARCH_LIST']='8.9'
+    os.environ['PATH']=str(ROOT/'models/male-cns-lif/.venv/bin')+':/usr/local/cuda/bin:'+os.environ['PATH']
+    sys.path.insert(0,str(ROOT/'models/male-cns-lif'));sys.path.insert(0,str(runtime))
+    import torch,phase4p
+    free,total=torch.cuda.mem_get_info();assert free>2*1024**3
+    torch.cuda.reset_peak_memory_stats();t0=time.perf_counter()
+    rt=phase4p.CanonicalRuntime(pc,runtime,EXP)
+    rows=[]
+    for spec in pc['reference_trials']:
+        queues();base=ROOT/'experiments/phase4p-deterministic-runtime/phase4c-v2/reference'/spec['name']
+        ev=pd.read_parquet(base/'spike-events.parquet')
+        expected=dict(step=ev.step.to_numpy(),neuron_idx=ev.neuron_idx.to_numpy(),
+            counts=np.load(base/'per-neuron-spike-counts.int32.npy'),
+            v=np.load(base/'final-voltage.float32.npy'),g=np.load(base/'final-g.float32.npy'))
+        r=rt.run(np.flatnonzero(rt.pops[spec['population']]),spec['rate_hz'],spec['seed'],spec['duration_ms'])
+        eq={k:bool(np.array_equal(r[k],v)) for k,v in expected.items()}
+        row=dict(trial=spec['name'],exact=eq,wall_seconds=r['metrics']['wall_seconds'])
+        rows.append(row);save(EXP/'regression'/('frozen-'+spec['name']+'.json'),row)
+        print(row,flush=True)
+    save(EXP/'regression/frozen-five.json',dict(pass_all=all(all(x['exact'].values()) for x in rows),trials=rows,
+        oracle='frozen deterministic-v2, NOT author Brian2',wall_seconds=time.perf_counter()-t0,
+        peak_allocated_vram=int(torch.cuda.max_memory_allocated()),gpu=torch.cuda.get_device_name(),comfyui_modified=False))
+    assert all(all(x['exact'].values()) for x in rows)
+
+
+if __name__=='__main__':main()

registry/phase4ad-author-semantics/evidence/REPORT.md

@@ -0,0 +1,71 @@
+# Phase 4AD 作者动力学语义实验室
+
+状态：`COMPLETE-ORACLE-VALIDATED-LAB-ONLY`。
+
+本轮仅有预声明的小回路与算子实验；没有整脑替代动力学运行、conditioning、学习成功或新学习候选。
+检查以原始事件、状态轨迹和预注册误差界限重算。缺失、失败、非有限值或初始事件丢失均不能通过；放电减少或静默本身不构成成功。
+
+核查通过 58/58 项；失败或不完整 0 项。
+冻结历史完整性：通过。
+源码与输入预注册一致性：通过。
+
+| 回路 | 语义 | 精度 | 总spikes | late spikes |
+|---|---|---|---:|---:|
+| pair | frozen | float32 | 473 | 238 |
+| pair | reset_g_only | float32 | 223 | 111 |
+| pair | refractory_gate_only | float32 | 635 | 321 |
+| pair | reset_and_refractory | float32 | 223 | 111 |
+| trio | frozen | float32 | 1064 | 535 |
+| trio | reset_g_only | float32 | 565 | 283 |
+| trio | refractory_gate_only | float32 | 1100 | 552 |
+| trio | reset_and_refractory | float32 | 469 | 235 |
+| five | frozen | float32 | 1483 | 747 |
+| five | reset_g_only | float32 | 868 | 433 |
+| five | refractory_gate_only | float32 | 1510 | 763 |
+| five | reset_and_refractory | float32 | 634 | 318 |
+| feedforward | frozen | float32 | 3 | 0 |
+| feedforward | reset_g_only | float32 | 3 | 0 |
+| feedforward | refractory_gate_only | float32 | 3 | 0 |
+| feedforward | reset_and_refractory | float32 | 3 | 0 |
+| no_input | frozen | float32 | 0 | 0 |
+| no_input | reset_g_only | float32 | 0 | 0 |
+| no_input | refractory_gate_only | float32 | 0 | 0 |
+| no_input | reset_and_refractory | float32 | 0 | 0 |
+| pair | author_complete | float64 | 213 | 106 |
+| pair | author_complete | float32 | 213 | 106 |
+| trio | author_complete | float64 | 448 | 224 |
+| trio | author_complete | float32 | 448 | 224 |
+| five | author_complete | float64 | 610 | 306 |
+| five | author_complete | float32 | 610 | 306 |
+| feedforward | author_complete | float64 | 3 | 0 |
+| feedforward | author_complete | float32 | 3 | 0 |
+| no_input | author_complete | float64 | 0 | 0 |
+| no_input | author_complete | float32 | 0 | 0 |
+
+作者Brian2与独立NumPy比较：
+
+| 实验 | 结果 | 事件一致 | 最大V/g误差 mV | 首次事件分歧step |
+|---|---|---|---:|---:|
+| author:pair:float64 | 通过 | True | 7.105427357601002e-14 | None |
+| author:pair:float32 | 通过 | True | 2.41696834564209e-05 | None |
+| author:trio:float64 | 通过 | True | 8.526512829121202e-14 | None |
+| author:trio:float32 | 通过 | True | 4.25875186920166e-05 | None |
+| author:five:float64 | 通过 | True | 3.836930773104541e-13 | None |
+| author:five:float32 | 通过 | True | 0.0002123713493347168 | None |
+| author:feedforward:float64 | 通过 | True | 3.765876499528531e-13 | None |
+| author:feedforward:float32 | 通过 | True | 0.00020179152488708496 | None |
+| author:no_input:float64 | 通过 | True | 7.105427357601002e-15 | None |
+| author:no_input:float32 | 通过 | True | 1.0728836059570312e-06 | None |
+
+float32与float64交叉比较仅记录精度影响，允许保留分歧，不能用于掩盖各自与独立oracle的失败。
+- precision_cross_record:pair：事件一致=True，最大误差=3.733467101341148e-05 mV，首次事件分歧step=None。
+- precision_cross_record:trio：事件一致=True，最大误差=3.733467101341148e-05 mV，首次事件分歧step=None。
+- precision_cross_record:five：事件一致=True，最大误差=0.00019546693161487383 mV，首次事件分歧step=None。
+- precision_cross_record:feedforward：事件一致=True，最大误差=0.0005722045887850413 mV，首次事件分歧step=None。
+- precision_cross_record:no_input：事件一致=True，最大误差=0.0 mV，首次事件分歧step=None。
+
+所有失败轨迹和错误文件原样保留；本简报没有选择获胜变体。
+小回路缺少外部整脑输入与graded APL，不能证明整脑因果必要性、生物真实性或信息保持。初始诊断seed也不是作者的感官Poisson接口。
+环境为Linux宿主，作者记录为Windows；Python补丁版本与环境差异见environment记录，不能称为二进制相同或原论文整脑复现。
+后续整脑嗅觉比较仍须核查固定输入、实际送达事件、持续活动和信息保持；可用学习仍需至少5个训练seed、独立评估、MBON/downstream的A对中性B特异性及acquisition/reversal/retention/delayed-reward对照。
+封存排除 .venv 与 __pycache__，保留环境安装报告；manifest列出payload哈希，checksums另含manifest，不存在自哈希循环。

registry/phase4ad-author-semantics/evidence/audit/all-motif-results.csv

@@ -0,0 +1,121 @@
+motif,policy,precision,neuron_idx,spikes,late_spikes,last_ms
+pair,frozen,float32,1381,237,119,999.3000000000001
+pair,frozen,float32,1511,236,119,997.5
+pair,reset_g_only,float32,1381,112,56,999.0
+pair,reset_g_only,float32,1511,111,55,994.9000000000001
+pair,refractory_gate_only,float32,1381,318,161,999.1
+pair,refractory_gate_only,float32,1511,317,160,997.5
+pair,reset_and_refractory,float32,1381,112,56,999.0
+pair,reset_and_refractory,float32,1511,111,55,994.9000000000001
+trio,frozen,float32,1197,355,179,999.3000000000001
+trio,frozen,float32,1381,355,178,997.8000000000001
+trio,frozen,float32,1511,354,178,997.4000000000001
+trio,reset_g_only,float32,1197,188,94,995.4000000000001
+trio,reset_g_only,float32,1381,189,95,998.7
+trio,reset_g_only,float32,1511,188,94,996.1
+trio,refractory_gate_only,float32,1197,369,185,998.3000000000001
+trio,refractory_gate_only,float32,1381,367,184,999.1
+trio,refractory_gate_only,float32,1511,364,183,997.2
+trio,reset_and_refractory,float32,1197,156,78,995.3000000000001
+trio,reset_and_refractory,float32,1381,157,79,999.6
+trio,reset_and_refractory,float32,1511,156,78,997.5
+five,frozen,float32,1197,370,185,998.8000000000001
+five,frozen,float32,1381,369,185,997.4000000000001
+five,frozen,float32,1511,367,186,999.5
+five,frozen,float32,82312,80,41,990.3000000000001
+five,frozen,float32,133666,297,150,999.5
+five,reset_g_only,float32,1197,249,125,996.2
+five,reset_g_only,float32,1381,211,104,999.2
+five,reset_g_only,float32,1511,209,104,996.5
+five,reset_g_only,float32,82312,33,17,994.9000000000001
+five,reset_g_only,float32,133666,166,83,996.7
+five,refractory_gate_only,float32,1197,372,188,998.0
+five,refractory_gate_only,float32,1381,375,191,998.6
+five,refractory_gate_only,float32,1511,371,187,997.5
+five,refractory_gate_only,float32,82312,85,43,991.9000000000001
+five,refractory_gate_only,float32,133666,307,154,997.7
+five,reset_and_refractory,float32,1197,165,82,995.7
+five,reset_and_refractory,float32,1381,166,83,999.8000000000001
+five,reset_and_refractory,float32,1511,165,83,997.5
+five,reset_and_refractory,float32,82312,15,8,972.7
+five,reset_and_refractory,float32,133666,123,62,993.0
+feedforward,frozen,float32,1197,1,0,10.0
+feedforward,frozen,float32,1381,1,0,0.0
+feedforward,frozen,float32,1511,1,0,4.9
+feedforward,frozen,float32,82312,0,0,
+feedforward,frozen,float32,133666,0,0,
+feedforward,reset_g_only,float32,1197,1,0,10.0
+feedforward,reset_g_only,float32,1381,1,0,0.0
+feedforward,reset_g_only,float32,1511,1,0,4.9
+feedforward,reset_g_only,float32,82312,0,0,
+feedforward,reset_g_only,float32,133666,0,0,
+feedforward,refractory_gate_only,float32,1197,1,0,10.0
+feedforward,refractory_gate_only,float32,1381,1,0,0.0
+feedforward,refractory_gate_only,float32,1511,1,0,4.9
+feedforward,refractory_gate_only,float32,82312,0,0,
+feedforward,refractory_gate_only,float32,133666,0,0,
+feedforward,reset_and_refractory,float32,1197,1,0,10.0
+feedforward,reset_and_refractory,float32,1381,1,0,0.0
+feedforward,reset_and_refractory,float32,1511,1,0,4.9
+feedforward,reset_and_refractory,float32,82312,0,0,
+feedforward,reset_and_refractory,float32,133666,0,0,
+no_input,frozen,float32,1197,0,0,
+no_input,frozen,float32,1381,0,0,
+no_input,frozen,float32,1511,0,0,
+no_input,frozen,float32,82312,0,0,
+no_input,frozen,float32,133666,0,0,
+no_input,reset_g_only,float32,1197,0,0,
+no_input,reset_g_only,float32,1381,0,0,
+no_input,reset_g_only,float32,1511,0,0,
+no_input,reset_g_only,float32,82312,0,0,
+no_input,reset_g_only,float32,133666,0,0,
+no_input,refractory_gate_only,float32,1197,0,0,
+no_input,refractory_gate_only,float32,1381,0,0,
+no_input,refractory_gate_only,float32,1511,0,0,
+no_input,refractory_gate_only,float32,82312,0,0,
+no_input,refractory_gate_only,float32,133666,0,0,
+no_input,reset_and_refractory,float32,1197,0,0,
+no_input,reset_and_refractory,float32,1381,0,0,
+no_input,reset_and_refractory,float32,1511,0,0,
+no_input,reset_and_refractory,float32,82312,0,0,
+no_input,reset_and_refractory,float32,133666,0,0,
+pair,author_complete,float64,1381,107,53,996.4000000000001
+pair,author_complete,float64,1511,106,53,992.1
+pair,author_complete,float32,1381,107,53,996.4000000000001
+pair,author_complete,float32,1511,106,53,992.1
+trio,author_complete,float64,1197,149,74,994.8000000000001
+trio,author_complete,float64,1381,150,75,999.3000000000001
+trio,author_complete,float64,1511,149,75,997.0
+trio,author_complete,float32,1197,149,74,994.8000000000001
+trio,author_complete,float32,1381,150,75,999.3000000000001
+trio,author_complete,float32,1511,149,75,997.0
+five,author_complete,float64,1197,159,79,995.2
+five,author_complete,float64,1381,160,80,999.5
+five,author_complete,float64,1511,159,80,997.4000000000001
+five,author_complete,float64,82312,13,7,992.4000000000001
+five,author_complete,float64,133666,119,60,996.0
+five,author_complete,float32,1197,159,79,995.2
+five,author_complete,float32,1381,160,80,999.5
+five,author_complete,float32,1511,159,80,997.4000000000001
+five,author_complete,float32,82312,13,7,992.4000000000001
+five,author_complete,float32,133666,119,60,996.0
+feedforward,author_complete,float64,1197,1,0,10.4
+feedforward,author_complete,float64,1381,1,0,0.0
+feedforward,author_complete,float64,1511,1,0,5.1000000000000005
+feedforward,author_complete,float64,82312,0,0,
+feedforward,author_complete,float64,133666,0,0,
+feedforward,author_complete,float32,1197,1,0,10.4
+feedforward,author_complete,float32,1381,1,0,0.0
+feedforward,author_complete,float32,1511,1,0,5.1000000000000005
+feedforward,author_complete,float32,82312,0,0,
+feedforward,author_complete,float32,133666,0,0,
+no_input,author_complete,float64,1197,0,0,
+no_input,author_complete,float64,1381,0,0,
+no_input,author_complete,float64,1511,0,0,
+no_input,author_complete,float64,82312,0,0,
+no_input,author_complete,float64,133666,0,0,
+no_input,author_complete,float32,1197,0,0,
+no_input,author_complete,float32,1381,0,0,
+no_input,author_complete,float32,1511,0,0,
+no_input,author_complete,float32,82312,0,0,
+no_input,author_complete,float32,133666,0,0,

registry/phase4ad-author-semantics/evidence/audit/finalize-start.json

@@ -0,0 +1,7 @@
+{
+  "timestamp_utc": "2026-09-29T23:18:24.492697+00:00",
+  "python": "3.10.12 (main, Aug 31 2026, 10:18:17) [GCC 11.4.0]",
+  "executable": "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+  "learning": false,
+  "whole_brain_alternative_run": false
+}

registry/phase4ad-author-semantics/evidence/audit/run-complete.json

@@ -0,0 +1,7 @@
+{
+  "all_author_oracle_comparisons_pass": true,
+  "all_frozen_components_match_archive": true,
+  "learning_achieved": false,
+  "whole_brain_alternative_run": false,
+  "author_original_source_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e"
+}

registry/phase4ad-author-semantics/evidence/audit/run-start.json

@@ -0,0 +1,16 @@
+{
+  "python": "3.10.12 (main, Aug 31 2026, 10:18:17) [GCC 11.4.0]",
+  "platform": "Linux-5.15.0-194-generic-x86_64-with-glibc2.35",
+  "packages": {
+    "brian2": "2.5.1",
+    "numpy": "1.22.3",
+    "pandas": "1.4.3",
+    "scipy": "1.8.1",
+    "pyarrow": "11.0.0",
+    "sympy": "1.12",
+    "cython": "0.29.33"
+  },
+  "codegen": "numpy",
+  "learning": false,
+  "user_authorized_new_model_hypotheses": true
+}

registry/phase4ad-author-semantics/evidence/checksums.sha256

@@ -0,0 +1,566 @@
+98eeae824607e83d0b35483a7d5ac586aebe68044e2457188040086e62e78b42  REPORT.md
+0b653f7362ec7b506766e78b78efaa82914df201844cdc71f6d70556d46204b5  audit/all-motif-results.csv
+2037a37dcf74e28831676ca1583d07272dd2546540a95096db6623f2eafe1a87  audit/final-summary.json
+b4fbf4a99a33b67af1329609591f7b553e41e99d760a0cf0e6f04fd1b3b33454  audit/finalize-start.json
+3d5333dede7b368a94de91e206cd35cdf7e89614ac528fb00126178386a2d8b7  audit/run-complete.json
+9480e2e1c299aeb6b6136eb7c1fdb0a733da5eadce3e32d674c3f89c1abd50c1  audit/run-start.json
+7535cfeec9d160eb597a2a09930cd8d1a55a7c0f561f1b5907f68eb53e1453dd  components/feedforward-frozen/events.csv
+6a24c8d2ad476e2250af49172be12de9d43346bc84f043b19d012fa0c53d2fba  components/feedforward-frozen/state.npz
+7535cfeec9d160eb597a2a09930cd8d1a55a7c0f561f1b5907f68eb53e1453dd  components/feedforward-refractory_gate_only/events.csv
+7b9f9d9c4da0a6019c89da75365c995d641bd6f1ffd4741befcb28fa1ae5c8b2  components/feedforward-refractory_gate_only/state.npz
+7535cfeec9d160eb597a2a09930cd8d1a55a7c0f561f1b5907f68eb53e1453dd  components/feedforward-reset_and_refractory/events.csv
+62b256fe806d17a345168593466f31410cc318099a812102cd38bd78735b9427  components/feedforward-reset_and_refractory/state.npz
+7535cfeec9d160eb597a2a09930cd8d1a55a7c0f561f1b5907f68eb53e1453dd  components/feedforward-reset_g_only/events.csv
+62b256fe806d17a345168593466f31410cc318099a812102cd38bd78735b9427  components/feedforward-reset_g_only/state.npz
+5cf5375573658738a15ef51adc56f283c212e00b20668c3015b8f7542a483240  components/five-frozen/events.csv
+15095ada05014741f6b6576c2d12d1a8f1ae482ae6f012d5e2be346c796baf4b  components/five-frozen/state.npz
+e31b6aa017bdd4bef6725aedb6c1ac40bd9f52e4e59d5fe1a1e11b31ef6825dd  components/five-refractory_gate_only/events.csv
+949ba5fdae4b3bb3a3d86a9cadc2967ff313272668b00af6cf5734c6fb0eff67  components/five-refractory_gate_only/state.npz
+5e9104d52c7573c6a22fbe823d500f53e86d41f04e929f177e92f0eebc1c1e46  components/five-reset_and_refractory/events.csv
+8c123230afb9a7a648dc2e5f726c03f4efd1adbe4dfa10409a668496ba2e4c92  components/five-reset_and_refractory/state.npz
+dfc35561b3c565297e5cf0c88db7438cf5787dac0f0c0cda21d17c2423d99233  components/five-reset_g_only/events.csv
+41da696d2f01e833d6c9f8450f34f45e54c85cf47ef778414c1a3dd4db2d5ddd  components/five-reset_g_only/state.npz
+7629aa69f016398dea6007af19edce7566ebf6f480c75e8af176821c20bbd801  components/no_input-frozen/events.csv
+a74134da72381d0dbff10bb5143691add6081487dede488a939bb0a4dbf5c20e  components/no_input-frozen/state.npz
+7629aa69f016398dea6007af19edce7566ebf6f480c75e8af176821c20bbd801  components/no_input-refractory_gate_only/events.csv
+a74134da72381d0dbff10bb5143691add6081487dede488a939bb0a4dbf5c20e  components/no_input-refractory_gate_only/state.npz
+7629aa69f016398dea6007af19edce7566ebf6f480c75e8af176821c20bbd801  components/no_input-reset_and_refractory/events.csv
+a74134da72381d0dbff10bb5143691add6081487dede488a939bb0a4dbf5c20e  components/no_input-reset_and_refractory/state.npz
+7629aa69f016398dea6007af19edce7566ebf6f480c75e8af176821c20bbd801  components/no_input-reset_g_only/events.csv
+a74134da72381d0dbff10bb5143691add6081487dede488a939bb0a4dbf5c20e  components/no_input-reset_g_only/state.npz
+85269a9465c20d11da108514d8541d8be7c2e105915bbb312205af4cb79b6b4c  components/pair-frozen/events.csv
+924774344956dd5a530c3d00c8103fe4d1b584837d5e91f05b60094540a78897  components/pair-frozen/state.npz
+227d89de52ad6a1cf890a194bd5f560865eb551332ad85947532841fa37e13d3  components/pair-refractory_gate_only/events.csv
+16a00fbdb18bf782c511df1cc3cce617ea1fada9f713b647c604f4a5861c8876  components/pair-refractory_gate_only/state.npz
+9d9a0ccc139e8edef78fb6e34d1f2de2514a6b3f8902454356afbc8cd6f5fdc8  components/pair-reset_and_refractory/events.csv
+f195ee84569db48e70924a805caa11f72bdab2065401d5b50c5adff5896564dc  components/pair-reset_and_refractory/state.npz
+9d9a0ccc139e8edef78fb6e34d1f2de2514a6b3f8902454356afbc8cd6f5fdc8  components/pair-reset_g_only/events.csv
+f195ee84569db48e70924a805caa11f72bdab2065401d5b50c5adff5896564dc  components/pair-reset_g_only/state.npz
+b20d807010ac88a7bef7165196c58715bfb94aa852db9f62bd4bf07e2760d52f  components/summary.csv
+4ea00ec307cf37524126d5e91c5916cb393b3eebd3b76fdb1aad8619de131c02  components/trio-frozen/events.csv
+46c8a495ee1358a6173a2eebebe9ce2d6481b27f10e0c56cf9602c7969cd8702  components/trio-frozen/state.npz
+3784ade444b9d85739c3e795b20b40ac5c16b294caa4d1a59be13388e31b8332  components/trio-refractory_gate_only/events.csv
+2278ec172f905f6e6beef62beda868b2171bae07f60b5a1c270693aa5357028c  components/trio-refractory_gate_only/state.npz
+50a9639d41cfdb8a2e53c132276223656118b80ececaaa18d1a0951cb4147e58  components/trio-reset_and_refractory/events.csv
+754164fa014a08999f56d6ea73830bf6fe92600b9e99b8c9d497ec935b9fd2ed  components/trio-reset_and_refractory/state.npz
+f55c81f358a41a9bad9836d2a2de4964072b914d6d9cef32f225eadf941a94b7  components/trio-reset_g_only/events.csv
+a646d329fc8526d59f836fd0c51e970b65866c85b3e167c68bcce87e16e128e4  components/trio-reset_g_only/state.npz
+aa7d319154306833890ca93542252f78996e96b080e55a9337d7f2da222a7445  environment/bootstrap-notes.json
+5acd7aa5a1825e5c053e9f4166f58cd9ec04129ed88f00afcdab2aa6ca204ca5  environment/frozen-scientific-environment.json
+e2e9301ade63e6ca44635f5b28271a4368b8e2393b1bd935e57e173f685c6f9c  environment/install-report.json
+0175910c6265813bfd8cf7e2dcaed5a7decabb85072894a04b2c642a222ac298  environment/installed-packages.json
+3621f6d6476189190e2960fa43f11b275ba4eca848fdac50a1ba2925de6223e8  external-resources/LICENSE
+402fcef4968c99397b0e908b3323ab9e6ef86af5583e46e6427f96f3d1091adf  external-resources/environment_full.yml
+fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e  external-resources/model.py
+6d915bc355cb804bce5146e1e9b8b68d7e94703024a718baaba54239f131b266  gpu-reference/extension-build/.ninja_deps
+cf068429fad6783a4f8fd56e8280f76f870abebc0bc4d3796df2895e75e50c3c  gpu-reference/extension-build/.ninja_log
+c570f72b9a2f486e104ed3bf5b1b9f2ccc729ecab02046cd62389d629fb4f48f  gpu-reference/extension-build/build.ninja
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  gpu-reference/extension-build/lock
+57f59f634cc8e3b03f4674a3ddb11ec933ab124feb0b9fa89d08fe26e60fcb7e  gpu-reference/extension-build/male_cns_lif_deterministic_v2_ext.so
+38680c6d618e1d4f26cf361a018de024ba148cf2c90bbfdde65fb8167643f5ba  gpu-reference/extension-build/phase4p_ext.cuda.o
+27d284f6a369221a931251b5a03ce133cc8231a97942567d4efafbfb45483811  gpu-reference/extension-build/phase4p_ext.o
+ca5c82cc34d586d84bb93f4ebdbfba0d1d91578a61d79c271225a44cd5b76376  gpu-reference/extension.json
+fce02b56f14b171ff3e5e38de15c700a6281d405a9802b859065f04292c61d2c  oracle/feedforward-float32/actual-weights.json
+953b4c2f26e2846de67b40b22a19c2f59b29ff6fb56339925a01f110c6c1705e  oracle/feedforward-float32/brian-output/events.csv
+e1f07d0a74694edf97b75da62c8fc35371cd65c85828f90c418385498eccab7a  oracle/feedforward-float32/brian-output/state.npz
+f29dddd95d78ae0906b6902d6acd82454ca0cc3d652374728f5b8125849b23a5  oracle/feedforward-float32/comparison.json
+301ae4572c658aa307fc998e009377e9c82467d97d66aa1ac4b3f518385ec5a5  oracle/feedforward-float32/completeness.csv
+627406997fa994afffa6c4df18cc584c43f4161b389a6669c2ceb64e5ae9dcd1  oracle/feedforward-float32/connectivity.parquet
+e048a4bb7d8508a47abafa3174336ddb1173191e6cb2a6e62207a07e287201f4  oracle/feedforward-float32/environment.json
+c65430d57ed21024c267316d854123ccc14cde79f7acb9ba9c34b1ce4e20665f  oracle/feedforward-float32/generated-code.json
+953b4c2f26e2846de67b40b22a19c2f59b29ff6fb56339925a01f110c6c1705e  oracle/feedforward-float32/independent-output/events.csv
+1a6f4be5a8418a74ea559bf96e587795c41fe987e147d49c28ac5759633e6c70  oracle/feedforward-float32/independent-output/state.npz
+7528f0de24d434d08024d011adae364ac60e0211e2d0b176d655bd015c22e0c8  oracle/feedforward-float32/run-spec.json
+d3183a588eff0f4824dd5680af6401e35370fa7e74268ae0700ba5522e6d278d  oracle/feedforward-float32/schedule.json
+335b295513fed2a617775adf590894234644c8bdf7268851434737d94e146208  oracle/feedforward-float32/seed.json
+fce02b56f14b171ff3e5e38de15c700a6281d405a9802b859065f04292c61d2c  oracle/feedforward-float32-repeat/actual-weights.json
+953b4c2f26e2846de67b40b22a19c2f59b29ff6fb56339925a01f110c6c1705e  oracle/feedforward-float32-repeat/brian-output/events.csv
+e1f07d0a74694edf97b75da62c8fc35371cd65c85828f90c418385498eccab7a  oracle/feedforward-float32-repeat/brian-output/state.npz
+301ae4572c658aa307fc998e009377e9c82467d97d66aa1ac4b3f518385ec5a5  oracle/feedforward-float32-repeat/completeness.csv
+627406997fa994afffa6c4df18cc584c43f4161b389a6669c2ceb64e5ae9dcd1  oracle/feedforward-float32-repeat/connectivity.parquet
+e048a4bb7d8508a47abafa3174336ddb1173191e6cb2a6e62207a07e287201f4  oracle/feedforward-float32-repeat/environment.json
+77e30078f96559ccfddb3b75bd3aaf3c76a137c0c045aa986c0348518ed1ac9f  oracle/feedforward-float32-repeat/generated-code.json
+7528f0de24d434d08024d011adae364ac60e0211e2d0b176d655bd015c22e0c8  oracle/feedforward-float32-repeat/run-spec.json
+d3183a588eff0f4824dd5680af6401e35370fa7e74268ae0700ba5522e6d278d  oracle/feedforward-float32-repeat/schedule.json
+335b295513fed2a617775adf590894234644c8bdf7268851434737d94e146208  oracle/feedforward-float32-repeat/seed.json
+5ae7652487b5fb80bb88586fe94344d8bc83ec046189e9385338d0bfd2323457  oracle/feedforward-float64/actual-weights.json
+953b4c2f26e2846de67b40b22a19c2f59b29ff6fb56339925a01f110c6c1705e  oracle/feedforward-float64/brian-output/events.csv
+968e7990aa8a734a63ee61fef198ad6ae8372f6c676722c67e52c3708a428f71  oracle/feedforward-float64/brian-output/state.npz
+317ab6c723ce928c1f019b85a833134400254991e49a9845a8f051b854963020  oracle/feedforward-float64/comparison.json
+301ae4572c658aa307fc998e009377e9c82467d97d66aa1ac4b3f518385ec5a5  oracle/feedforward-float64/completeness.csv
+627406997fa994afffa6c4df18cc584c43f4161b389a6669c2ceb64e5ae9dcd1  oracle/feedforward-float64/connectivity.parquet
+e048a4bb7d8508a47abafa3174336ddb1173191e6cb2a6e62207a07e287201f4  oracle/feedforward-float64/environment.json
+b8fcc2d1cb77b83b28fdbf6af1097556fdae8cc73508a5f1c6a58efa3ed4573c  oracle/feedforward-float64/generated-code.json
+953b4c2f26e2846de67b40b22a19c2f59b29ff6fb56339925a01f110c6c1705e  oracle/feedforward-float64/independent-output/events.csv
+2e3c2dd8d569277706a471f8a7b0bee8af4d58f7c728b85df38addae526bcaa5  oracle/feedforward-float64/independent-output/state.npz
+f374b342910fab0110369cb5b9b2daf53e40e4c50b881a027fcafb5a5d00d532  oracle/feedforward-float64/run-spec.json
+d3183a588eff0f4824dd5680af6401e35370fa7e74268ae0700ba5522e6d278d  oracle/feedforward-float64/schedule.json
+ea838909a3dcfabd586cf4181eb6788ed791472fc5f64556fc5e88004906d242  oracle/feedforward-float64/seed.json
+5ae7652487b5fb80bb88586fe94344d8bc83ec046189e9385338d0bfd2323457  oracle/feedforward-float64-repeat/actual-weights.json
+953b4c2f26e2846de67b40b22a19c2f59b29ff6fb56339925a01f110c6c1705e  oracle/feedforward-float64-repeat/brian-output/events.csv
+968e7990aa8a734a63ee61fef198ad6ae8372f6c676722c67e52c3708a428f71  oracle/feedforward-float64-repeat/brian-output/state.npz
+301ae4572c658aa307fc998e009377e9c82467d97d66aa1ac4b3f518385ec5a5  oracle/feedforward-float64-repeat/completeness.csv
+627406997fa994afffa6c4df18cc584c43f4161b389a6669c2ceb64e5ae9dcd1  oracle/feedforward-float64-repeat/connectivity.parquet
+e048a4bb7d8508a47abafa3174336ddb1173191e6cb2a6e62207a07e287201f4  oracle/feedforward-float64-repeat/environment.json
+f7e9a9b47c364eb2ffe7691be257c6b06aa3f80f1f3eb4658e75b54636278efd  oracle/feedforward-float64-repeat/generated-code.json
+f374b342910fab0110369cb5b9b2daf53e40e4c50b881a027fcafb5a5d00d532  oracle/feedforward-float64-repeat/run-spec.json
+d3183a588eff0f4824dd5680af6401e35370fa7e74268ae0700ba5522e6d278d  oracle/feedforward-float64-repeat/schedule.json
+ea838909a3dcfabd586cf4181eb6788ed791472fc5f64556fc5e88004906d242  oracle/feedforward-float64-repeat/seed.json
+87c7305d5b8ffcd9f117485921900ace6ad76e9629e44bd5fde5d0fcad9ff4da  oracle/five-float32/actual-weights.json
+80b2ac9efc7aa1db0ed7e8922f8e9d464c4a2417248be1435454316c47f00ee2  oracle/five-float32/brian-output/events.csv
+55580de4130341e93379ebd2ea8065dfa9b86a1d64df6010f3908457c5f98818  oracle/five-float32/brian-output/state.npz
+a66d6a4fbcc48be5208800e6b6ad0fa69c1604b242821bb74e562c77a5e67d3f  oracle/five-float32/comparison.json
+301ae4572c658aa307fc998e009377e9c82467d97d66aa1ac4b3f518385ec5a5  oracle/five-float32/completeness.csv
+43ea5a3c6c53315e9265863a6f05b3e6d8e9b9f299aef665e8bbe9c46f9eb2ce  oracle/five-float32/connectivity.parquet
+e048a4bb7d8508a47abafa3174336ddb1173191e6cb2a6e62207a07e287201f4  oracle/five-float32/environment.json
+b80159b10b6e2822bdb83230d2a6f56213836992d15e3facd3c9f10789a9aaf6  oracle/five-float32/generated-code.json
+80b2ac9efc7aa1db0ed7e8922f8e9d464c4a2417248be1435454316c47f00ee2  oracle/five-float32/independent-output/events.csv
+027def19ce4441508a7736ee1185469c6714c8eb3cb1e2b37e189da7c6bec597  oracle/five-float32/independent-output/state.npz
+303346fc360a675c71c0598e3a99bf5a6a6f5bc2aafbe4889668333c4183357c  oracle/five-float32/run-spec.json
+d3183a588eff0f4824dd5680af6401e35370fa7e74268ae0700ba5522e6d278d  oracle/five-float32/schedule.json
+335b295513fed2a617775adf590894234644c8bdf7268851434737d94e146208  oracle/five-float32/seed.json
+87c7305d5b8ffcd9f117485921900ace6ad76e9629e44bd5fde5d0fcad9ff4da  oracle/five-float32-repeat/actual-weights.json
+80b2ac9efc7aa1db0ed7e8922f8e9d464c4a2417248be1435454316c47f00ee2  oracle/five-float32-repeat/brian-output/events.csv
+55580de4130341e93379ebd2ea8065dfa9b86a1d64df6010f3908457c5f98818  oracle/five-float32-repeat/brian-output/state.npz
+301ae4572c658aa307fc998e009377e9c82467d97d66aa1ac4b3f518385ec5a5  oracle/five-float32-repeat/completeness.csv
+43ea5a3c6c53315e9265863a6f05b3e6d8e9b9f299aef665e8bbe9c46f9eb2ce  oracle/five-float32-repeat/connectivity.parquet
+e048a4bb7d8508a47abafa3174336ddb1173191e6cb2a6e62207a07e287201f4  oracle/five-float32-repeat/environment.json
+b3e1a32ea67bcbb51205dbdb80c88d127e42328b965102c695820877b9857e43  oracle/five-float32-repeat/generated-code.json
+303346fc360a675c71c0598e3a99bf5a6a6f5bc2aafbe4889668333c4183357c  oracle/five-float32-repeat/run-spec.json
+d3183a588eff0f4824dd5680af6401e35370fa7e74268ae0700ba5522e6d278d  oracle/five-float32-repeat/schedule.json
+335b295513fed2a617775adf590894234644c8bdf7268851434737d94e146208  oracle/five-float32-repeat/seed.json
+7cf304b269ed2c25edb9040b91c2ed10d1f335b6be59b819f5f23ede2ae6757c  oracle/five-float64/actual-weights.json
+80b2ac9efc7aa1db0ed7e8922f8e9d464c4a2417248be1435454316c47f00ee2  oracle/five-float64/brian-output/events.csv
+a59c994e53f70fb895b1009b9b074e32aa0aa51b9419848e96e54aa71cdd046d  oracle/five-float64/brian-output/state.npz
+b6b9e1736743bb4f282ecd354e83e027f506ee4583e7cb7c070b9ba60d99253a  oracle/five-float64/comparison.json
+301ae4572c658aa307fc998e009377e9c82467d97d66aa1ac4b3f518385ec5a5  oracle/five-float64/completeness.csv
+43ea5a3c6c53315e9265863a6f05b3e6d8e9b9f299aef665e8bbe9c46f9eb2ce  oracle/five-float64/connectivity.parquet
+e048a4bb7d8508a47abafa3174336ddb1173191e6cb2a6e62207a07e287201f4  oracle/five-float64/environment.json
+fc6c228a1f24c65b5172799dfaa2568cdb615db639226022e10cced292099fe2  oracle/five-float64/generated-code.json
+80b2ac9efc7aa1db0ed7e8922f8e9d464c4a2417248be1435454316c47f00ee2  oracle/five-float64/independent-output/events.csv
+938e04a8a4594297405f5f2bd28b4bd3f7c7bdb45172c4000c239bf867e95d6e  oracle/five-float64/independent-output/state.npz
+101e0cf3fb3fb2ce75e8f0cb6526285f66026317a5e550716363c1d1ff928265  oracle/five-float64/run-spec.json
+d3183a588eff0f4824dd5680af6401e35370fa7e74268ae0700ba5522e6d278d  oracle/five-float64/schedule.json
+ea838909a3dcfabd586cf4181eb6788ed791472fc5f64556fc5e88004906d242  oracle/five-float64/seed.json
+7cf304b269ed2c25edb9040b91c2ed10d1f335b6be59b819f5f23ede2ae6757c  oracle/five-float64-repeat/actual-weights.json
+80b2ac9efc7aa1db0ed7e8922f8e9d464c4a2417248be1435454316c47f00ee2  oracle/five-float64-repeat/brian-output/events.csv
+a59c994e53f70fb895b1009b9b074e32aa0aa51b9419848e96e54aa71cdd046d  oracle/five-float64-repeat/brian-output/state.npz
+301ae4572c658aa307fc998e009377e9c82467d97d66aa1ac4b3f518385ec5a5  oracle/five-float64-repeat/completeness.csv
+43ea5a3c6c53315e9265863a6f05b3e6d8e9b9f299aef665e8bbe9c46f9eb2ce  oracle/five-float64-repeat/connectivity.parquet
+e048a4bb7d8508a47abafa3174336ddb1173191e6cb2a6e62207a07e287201f4  oracle/five-float64-repeat/environment.json
+a0f43549be169ed0ab0b8193779e79f45b140a43ca19e73062d3617ab98e6abb  oracle/five-float64-repeat/generated-code.json
+101e0cf3fb3fb2ce75e8f0cb6526285f66026317a5e550716363c1d1ff928265  oracle/five-float64-repeat/run-spec.json
+d3183a588eff0f4824dd5680af6401e35370fa7e74268ae0700ba5522e6d278d  oracle/five-float64-repeat/schedule.json
+ea838909a3dcfabd586cf4181eb6788ed791472fc5f64556fc5e88004906d242  oracle/five-float64-repeat/seed.json
+87c7305d5b8ffcd9f117485921900ace6ad76e9629e44bd5fde5d0fcad9ff4da  oracle/no_input-float32/actual-weights.json
+7629aa69f016398dea6007af19edce7566ebf6f480c75e8af176821c20bbd801  oracle/no_input-float32/brian-output/events.csv
+14c95cbc13ff15e775adb758dc57b7cf0658def99dc554facff8f4f4030c3630  oracle/no_input-float32/brian-output/state.npz
+e7ac75d3c7853ec3526b7dc1bdd7f94ccba58b4392c2a704ac4bc25b34130ce5  oracle/no_input-float32/comparison.json
+301ae4572c658aa307fc998e009377e9c82467d97d66aa1ac4b3f518385ec5a5  oracle/no_input-float32/completeness.csv
+43ea5a3c6c53315e9265863a6f05b3e6d8e9b9f299aef665e8bbe9c46f9eb2ce  oracle/no_input-float32/connectivity.parquet
+e048a4bb7d8508a47abafa3174336ddb1173191e6cb2a6e62207a07e287201f4  oracle/no_input-float32/environment.json
+51391a395fd7e4608f1b17621601e3ffbe251a18f719623e5d5267ffd070deab  oracle/no_input-float32/generated-code.json
+7629aa69f016398dea6007af19edce7566ebf6f480c75e8af176821c20bbd801  oracle/no_input-float32/independent-output/events.csv
+59f38c3dea1c88fcc492614dffc36cdc8771b6cb1904d82e2834262026808a15  oracle/no_input-float32/independent-output/state.npz
+c23e196bc4701ec1c085fe9d6eb81167bfa3300181de8390bc6d6be22374e5d9  oracle/no_input-float32/run-spec.json
+a0ae45ec1bd5e9ad66296742ebb857263b1bde14ca260bbba260b570d359dcd5  oracle/no_input-float32/schedule.json
+77d0534413e66efb896580996b934bc368c90e1fa65d19c0dd6e5e36d8eda830  oracle/no_input-float32/seed.json
+87c7305d5b8ffcd9f117485921900ace6ad76e9629e44bd5fde5d0fcad9ff4da  oracle/no_input-float32-repeat/actual-weights.json
+7629aa69f016398dea6007af19edce7566ebf6f480c75e8af176821c20bbd801  oracle/no_input-float32-repeat/brian-output/events.csv
+14c95cbc13ff15e775adb758dc57b7cf0658def99dc554facff8f4f4030c3630  oracle/no_input-float32-repeat/brian-output/state.npz
+301ae4572c658aa307fc998e009377e9c82467d97d66aa1ac4b3f518385ec5a5  oracle/no_input-float32-repeat/completeness.csv
+43ea5a3c6c53315e9265863a6f05b3e6d8e9b9f299aef665e8bbe9c46f9eb2ce  oracle/no_input-float32-repeat/connectivity.parquet
+e048a4bb7d8508a47abafa3174336ddb1173191e6cb2a6e62207a07e287201f4  oracle/no_input-float32-repeat/environment.json
+bee4c08cf69cb20302b0a4dea5ea76fe44bc6ae32ac869cd4c415a8719efb6b3  oracle/no_input-float32-repeat/generated-code.json
+c23e196bc4701ec1c085fe9d6eb81167bfa3300181de8390bc6d6be22374e5d9  oracle/no_input-float32-repeat/run-spec.json
+a0ae45ec1bd5e9ad66296742ebb857263b1bde14ca260bbba260b570d359dcd5  oracle/no_input-float32-repeat/schedule.json
+77d0534413e66efb896580996b934bc368c90e1fa65d19c0dd6e5e36d8eda830  oracle/no_input-float32-repeat/seed.json
+7cf304b269ed2c25edb9040b91c2ed10d1f335b6be59b819f5f23ede2ae6757c  oracle/no_input-float64/actual-weights.json
+7629aa69f016398dea6007af19edce7566ebf6f480c75e8af176821c20bbd801  oracle/no_input-float64/brian-output/events.csv
+e9ca16e82b3fa11b6ce38f258d15a3c5d2666c4b8ac2c05e481ae2c6462666c1  oracle/no_input-float64/brian-output/state.npz
+34382539f3576746462c29b584d5c3efbcc827f434e5c55d399c58e0fe5212f7  oracle/no_input-float64/comparison.json
+301ae4572c658aa307fc998e009377e9c82467d97d66aa1ac4b3f518385ec5a5  oracle/no_input-float64/completeness.csv
+43ea5a3c6c53315e9265863a6f05b3e6d8e9b9f299aef665e8bbe9c46f9eb2ce  oracle/no_input-float64/connectivity.parquet
+e048a4bb7d8508a47abafa3174336ddb1173191e6cb2a6e62207a07e287201f4  oracle/no_input-float64/environment.json
+70ea4ff3fd649f4303c189e58980b7c0aa628694c3cedfcb37aa2ccae1d6c079  oracle/no_input-float64/generated-code.json
+7629aa69f016398dea6007af19edce7566ebf6f480c75e8af176821c20bbd801  oracle/no_input-float64/independent-output/events.csv
+27070591642beb87f800b700c4b6fe7ea474a2e5a9b1b3ed82cd6de0e854d501  oracle/no_input-float64/independent-output/state.npz
+9de22a53132abac0de19554f76a0737cb81b62bea257813962b75dbd633b8978  oracle/no_input-float64/run-spec.json
+a0ae45ec1bd5e9ad66296742ebb857263b1bde14ca260bbba260b570d359dcd5  oracle/no_input-float64/schedule.json
+77d0534413e66efb896580996b934bc368c90e1fa65d19c0dd6e5e36d8eda830  oracle/no_input-float64/seed.json
+7cf304b269ed2c25edb9040b91c2ed10d1f335b6be59b819f5f23ede2ae6757c  oracle/no_input-float64-repeat/actual-weights.json
+7629aa69f016398dea6007af19edce7566ebf6f480c75e8af176821c20bbd801  oracle/no_input-float64-repeat/brian-output/events.csv
+e9ca16e82b3fa11b6ce38f258d15a3c5d2666c4b8ac2c05e481ae2c6462666c1  oracle/no_input-float64-repeat/brian-output/state.npz
+301ae4572c658aa307fc998e009377e9c82467d97d66aa1ac4b3f518385ec5a5  oracle/no_input-float64-repeat/completeness.csv
+43ea5a3c6c53315e9265863a6f05b3e6d8e9b9f299aef665e8bbe9c46f9eb2ce  oracle/no_input-float64-repeat/connectivity.parquet
+e048a4bb7d8508a47abafa3174336ddb1173191e6cb2a6e62207a07e287201f4  oracle/no_input-float64-repeat/environment.json
+3db565a7f030aafed20764a918587a86fab4ba509c223e58027bc2e12b5bb8a5  oracle/no_input-float64-repeat/generated-code.json
+9de22a53132abac0de19554f76a0737cb81b62bea257813962b75dbd633b8978  oracle/no_input-float64-repeat/run-spec.json
+a0ae45ec1bd5e9ad66296742ebb857263b1bde14ca260bbba260b570d359dcd5  oracle/no_input-float64-repeat/schedule.json
+77d0534413e66efb896580996b934bc368c90e1fa65d19c0dd6e5e36d8eda830  oracle/no_input-float64-repeat/seed.json
+3056ff61f015cfa9572b32d18aeebf0e79a877c6c37a1b429c90e385bba08d07  oracle/pair-float32/actual-weights.json
+0c40dff2cecdd85cb64a03156c3ca7b538ba2046756844ab84b26db830d0e7bd  oracle/pair-float32/brian-output/events.csv
+e559d89af8d1ca4774fa5f53446381a4b9b55d88e52ea3b3baaaf68d2de3fce7  oracle/pair-float32/brian-output/state.npz
+3e53a79835ecc9e5306577e20a7952a36844407750be7455d2ccd53a49823ee5  oracle/pair-float32/comparison.json
+5af02939034e66e7a8e7c361555203906d69bbba0042b1ab549041db1626f02b  oracle/pair-float32/completeness.csv
+1072f50d478d1890de7602c48f6a7f1b89e11a665a173e7a705a5fab3b3f8771  oracle/pair-float32/connectivity.parquet
+e048a4bb7d8508a47abafa3174336ddb1173191e6cb2a6e62207a07e287201f4  oracle/pair-float32/environment.json
+8c1278d8e1e4b028900e0353f7f9800300dad618be28e028714c7c1889a64099  oracle/pair-float32/generated-code.json
+0c40dff2cecdd85cb64a03156c3ca7b538ba2046756844ab84b26db830d0e7bd  oracle/pair-float32/independent-output/events.csv
+fcaee342515e8a92a46ee1df7b63a83f38fa950a77bc12d173930f91136dbcba  oracle/pair-float32/independent-output/state.npz
+be400c1c9248322775cb9bb2c23a8ab4b4bb536f220c955806f194718191b6de  oracle/pair-float32/run-spec.json
+d3183a588eff0f4824dd5680af6401e35370fa7e74268ae0700ba5522e6d278d  oracle/pair-float32/schedule.json
+335b295513fed2a617775adf590894234644c8bdf7268851434737d94e146208  oracle/pair-float32/seed.json
+3056ff61f015cfa9572b32d18aeebf0e79a877c6c37a1b429c90e385bba08d07  oracle/pair-float32-repeat/actual-weights.json
+0c40dff2cecdd85cb64a03156c3ca7b538ba2046756844ab84b26db830d0e7bd  oracle/pair-float32-repeat/brian-output/events.csv
+e559d89af8d1ca4774fa5f53446381a4b9b55d88e52ea3b3baaaf68d2de3fce7  oracle/pair-float32-repeat/brian-output/state.npz
+5af02939034e66e7a8e7c361555203906d69bbba0042b1ab549041db1626f02b  oracle/pair-float32-repeat/completeness.csv
+1072f50d478d1890de7602c48f6a7f1b89e11a665a173e7a705a5fab3b3f8771  oracle/pair-float32-repeat/connectivity.parquet
+e048a4bb7d8508a47abafa3174336ddb1173191e6cb2a6e62207a07e287201f4  oracle/pair-float32-repeat/environment.json
+110a0b1d596da82dfad41024ac1b00ab636b0e5e927a7108782af257b21ae3c2  oracle/pair-float32-repeat/generated-code.json
+be400c1c9248322775cb9bb2c23a8ab4b4bb536f220c955806f194718191b6de  oracle/pair-float32-repeat/run-spec.json
+d3183a588eff0f4824dd5680af6401e35370fa7e74268ae0700ba5522e6d278d  oracle/pair-float32-repeat/schedule.json
+335b295513fed2a617775adf590894234644c8bdf7268851434737d94e146208  oracle/pair-float32-repeat/seed.json
+8a3f9d74c53e9cf8eb01c82be313c29b5f82efe15e2a23aba463f6de3a36a791  oracle/pair-float64/actual-weights.json
+0c40dff2cecdd85cb64a03156c3ca7b538ba2046756844ab84b26db830d0e7bd  oracle/pair-float64/brian-output/events.csv
+df0486fc1a7865b85d88dfcb41170233dac2063af28246b6c5043903a4a817ca  oracle/pair-float64/brian-output/state.npz
+15a03555e6cd6f5df21587c3ce23a75c7ec6a112bc20153e53a8286a1801060e  oracle/pair-float64/comparison.json
+5af02939034e66e7a8e7c361555203906d69bbba0042b1ab549041db1626f02b  oracle/pair-float64/completeness.csv
+1072f50d478d1890de7602c48f6a7f1b89e11a665a173e7a705a5fab3b3f8771  oracle/pair-float64/connectivity.parquet
+e048a4bb7d8508a47abafa3174336ddb1173191e6cb2a6e62207a07e287201f4  oracle/pair-float64/environment.json
+8c1278d8e1e4b028900e0353f7f9800300dad618be28e028714c7c1889a64099  oracle/pair-float64/generated-code.json
+0c40dff2cecdd85cb64a03156c3ca7b538ba2046756844ab84b26db830d0e7bd  oracle/pair-float64/independent-output/events.csv
+b3e98ff351b1a3290371de6e95628ed4026c34bf59720ba4b63d04fdcb879e48  oracle/pair-float64/independent-output/state.npz
+a54ed0bc7bafe0d45f951255cdda987a5e4e2433a98cac45c1c3b4f9141d7c65  oracle/pair-float64/run-spec.json
+d3183a588eff0f4824dd5680af6401e35370fa7e74268ae0700ba5522e6d278d  oracle/pair-float64/schedule.json
+ea838909a3dcfabd586cf4181eb6788ed791472fc5f64556fc5e88004906d242  oracle/pair-float64/seed.json
+8a3f9d74c53e9cf8eb01c82be313c29b5f82efe15e2a23aba463f6de3a36a791  oracle/pair-float64-repeat/actual-weights.json
+0c40dff2cecdd85cb64a03156c3ca7b538ba2046756844ab84b26db830d0e7bd  oracle/pair-float64-repeat/brian-output/events.csv
+df0486fc1a7865b85d88dfcb41170233dac2063af28246b6c5043903a4a817ca  oracle/pair-float64-repeat/brian-output/state.npz
+5af02939034e66e7a8e7c361555203906d69bbba0042b1ab549041db1626f02b  oracle/pair-float64-repeat/completeness.csv
+1072f50d478d1890de7602c48f6a7f1b89e11a665a173e7a705a5fab3b3f8771  oracle/pair-float64-repeat/connectivity.parquet
+e048a4bb7d8508a47abafa3174336ddb1173191e6cb2a6e62207a07e287201f4  oracle/pair-float64-repeat/environment.json
+86fd33e9730c1d4675224eaff6ecc4feaf9808e58f51c93e7df252c821998736  oracle/pair-float64-repeat/generated-code.json
+a54ed0bc7bafe0d45f951255cdda987a5e4e2433a98cac45c1c3b4f9141d7c65  oracle/pair-float64-repeat/run-spec.json
+d3183a588eff0f4824dd5680af6401e35370fa7e74268ae0700ba5522e6d278d  oracle/pair-float64-repeat/schedule.json
+ea838909a3dcfabd586cf4181eb6788ed791472fc5f64556fc5e88004906d242  oracle/pair-float64-repeat/seed.json
+4a8bf9f0e2c4954cea97b7c6eebebf422196641047c31935017d81268ab576f5  oracle/poi-interface/audit.json
+06e601b217fdbc48eee57eac01cc9a9fa649ec2a1810a2e212efcd3e4b632303  oracle/poi-interface/completeness.csv
+34f12d50889ccf2e637d913a0f3c4104d49032a6a67f9c3fbcd52e68ce95d701  oracle/poi-interface/connectivity.parquet
+1e7bcd97221db01bba542320601325572330ffe2a867607d3105d0417c2850ae  oracle/poi-interface/environment.json
+eb11dd4b866c1fb80ec414b55335e1263fc041cddc46d098d523c6fd52c297ef  oracle/poi-interface/generated-code.json
+eac8d994e23c5fbb5fff6b537f24d759b0000793d9fd7938669e45b1242b0410  oracle/poi-interface/schedule.json
+d1fe988c385189af8d4ea1879eb7f863115a35f881a06f3d4c61b6cb2357eb6d  oracle/trio-float32/actual-weights.json
+7ae48f3fb283fda9f19b47215e23b6f8fe7b2f0265e400b5620acf98fed9c053  oracle/trio-float32/brian-output/events.csv
+5cfe47ae0e456407c1c26a04c6a29b2daaa5fa2a264a4275b12d674dcd5ca027  oracle/trio-float32/brian-output/state.npz
+29510d4a5da61d412f4a5b852c793744983bc9b5a761fd3d175e8b7d5178777d  oracle/trio-float32/comparison.json
+e8795d5efb2eebefaae419c6df6d18d3cea3c390d9df7987f55823f5a860169e  oracle/trio-float32/completeness.csv
+22570cdceb09128d4bde46fd75897af776f7d91d89b8581d13133f55779f1e91  oracle/trio-float32/connectivity.parquet
+e048a4bb7d8508a47abafa3174336ddb1173191e6cb2a6e62207a07e287201f4  oracle/trio-float32/environment.json
+795226925d44b77912780f62a0881256e964a80baf362dfcf3173643ca417bbe  oracle/trio-float32/generated-code.json
+7ae48f3fb283fda9f19b47215e23b6f8fe7b2f0265e400b5620acf98fed9c053  oracle/trio-float32/independent-output/events.csv
+60645b816f9ba7f5ff6a5ab91bff6c070546d07ef2f0565b1f7cff77b5d47145  oracle/trio-float32/independent-output/state.npz
+391b9abfa2f300cc624185f4fe87bea1ed9417921c40ce4f71e7a9ed19777662  oracle/trio-float32/run-spec.json
+d3183a588eff0f4824dd5680af6401e35370fa7e74268ae0700ba5522e6d278d  oracle/trio-float32/schedule.json
+335b295513fed2a617775adf590894234644c8bdf7268851434737d94e146208  oracle/trio-float32/seed.json
+d1fe988c385189af8d4ea1879eb7f863115a35f881a06f3d4c61b6cb2357eb6d  oracle/trio-float32-repeat/actual-weights.json
+7ae48f3fb283fda9f19b47215e23b6f8fe7b2f0265e400b5620acf98fed9c053  oracle/trio-float32-repeat/brian-output/events.csv
+5cfe47ae0e456407c1c26a04c6a29b2daaa5fa2a264a4275b12d674dcd5ca027  oracle/trio-float32-repeat/brian-output/state.npz
+e8795d5efb2eebefaae419c6df6d18d3cea3c390d9df7987f55823f5a860169e  oracle/trio-float32-repeat/completeness.csv
+22570cdceb09128d4bde46fd75897af776f7d91d89b8581d13133f55779f1e91  oracle/trio-float32-repeat/connectivity.parquet
+e048a4bb7d8508a47abafa3174336ddb1173191e6cb2a6e62207a07e287201f4  oracle/trio-float32-repeat/environment.json
+fc6c228a1f24c65b5172799dfaa2568cdb615db639226022e10cced292099fe2  oracle/trio-float32-repeat/generated-code.json
+391b9abfa2f300cc624185f4fe87bea1ed9417921c40ce4f71e7a9ed19777662  oracle/trio-float32-repeat/run-spec.json
+d3183a588eff0f4824dd5680af6401e35370fa7e74268ae0700ba5522e6d278d  oracle/trio-float32-repeat/schedule.json
+335b295513fed2a617775adf590894234644c8bdf7268851434737d94e146208  oracle/trio-float32-repeat/seed.json
+21ab46d0419138b16b0407d31b4acde4a25f7016beb9e65a0c3a358707ee8565  oracle/trio-float64/actual-weights.json
+7ae48f3fb283fda9f19b47215e23b6f8fe7b2f0265e400b5620acf98fed9c053  oracle/trio-float64/brian-output/events.csv
+fc2be53c305f1b7d08934aa4a8550bc125bbf5a42a31cab7cb21f74e253d45b0  oracle/trio-float64/brian-output/state.npz
+a7c9b2a63b57539e5ac0eefcc2943558b617f67afa3841873e95ca2e44d7db0b  oracle/trio-float64/comparison.json
+e8795d5efb2eebefaae419c6df6d18d3cea3c390d9df7987f55823f5a860169e  oracle/trio-float64/completeness.csv
+22570cdceb09128d4bde46fd75897af776f7d91d89b8581d13133f55779f1e91  oracle/trio-float64/connectivity.parquet
+e048a4bb7d8508a47abafa3174336ddb1173191e6cb2a6e62207a07e287201f4  oracle/trio-float64/environment.json
+9b0f5455ef57b378efa1099b79d8285fe8f6d41a480ada58e57c2748b8cba02f  oracle/trio-float64/generated-code.json
+7ae48f3fb283fda9f19b47215e23b6f8fe7b2f0265e400b5620acf98fed9c053  oracle/trio-float64/independent-output/events.csv
+83cf9d1a3e9e73b5f2a95a52cbc005a56ccb893e4990c4bc06f7c9393577788c  oracle/trio-float64/independent-output/state.npz
+2d3c683e78db15aa7ee8aea0ac79ed51f44dacc8618b3419bb591811060d2cf1  oracle/trio-float64/run-spec.json
+d3183a588eff0f4824dd5680af6401e35370fa7e74268ae0700ba5522e6d278d  oracle/trio-float64/schedule.json
+ea838909a3dcfabd586cf4181eb6788ed791472fc5f64556fc5e88004906d242  oracle/trio-float64/seed.json
+21ab46d0419138b16b0407d31b4acde4a25f7016beb9e65a0c3a358707ee8565  oracle/trio-float64-repeat/actual-weights.json
+7ae48f3fb283fda9f19b47215e23b6f8fe7b2f0265e400b5620acf98fed9c053  oracle/trio-float64-repeat/brian-output/events.csv
+fc2be53c305f1b7d08934aa4a8550bc125bbf5a42a31cab7cb21f74e253d45b0  oracle/trio-float64-repeat/brian-output/state.npz
+e8795d5efb2eebefaae419c6df6d18d3cea3c390d9df7987f55823f5a860169e  oracle/trio-float64-repeat/completeness.csv
+22570cdceb09128d4bde46fd75897af776f7d91d89b8581d13133f55779f1e91  oracle/trio-float64-repeat/connectivity.parquet
+e048a4bb7d8508a47abafa3174336ddb1173191e6cb2a6e62207a07e287201f4  oracle/trio-float64-repeat/environment.json
+795226925d44b77912780f62a0881256e964a80baf362dfcf3173643ca417bbe  oracle/trio-float64-repeat/generated-code.json
+2d3c683e78db15aa7ee8aea0ac79ed51f44dacc8618b3419bb591811060d2cf1  oracle/trio-float64-repeat/run-spec.json
+d3183a588eff0f4824dd5680af6401e35370fa7e74268ae0700ba5522e6d278d  oracle/trio-float64-repeat/schedule.json
+ea838909a3dcfabd586cf4181eb6788ed791472fc5f64556fc5e88004906d242  oracle/trio-float64-repeat/seed.json
+db73a9c3923de0e57985b46613bf87bf599fcdd11541bb9576bc239838c8062b  oracle/unit-above_threshold-float32/actual-weights.json
+cfad3e3ae7578e64365753675ead4358495da79ee379d78e192172b50a688023  oracle/unit-above_threshold-float32/brian-output/events.csv
+367bda1dee3a6bd6c9e04afab7ef93f835cabd9329f7eb7d5b51adab2e5e07d9  oracle/unit-above_threshold-float32/brian-output/state.npz
+e7ac75d3c7853ec3526b7dc1bdd7f94ccba58b4392c2a704ac4bc25b34130ce5  oracle/unit-above_threshold-float32/comparison.json
+6798ede76e783a56766ebb676a851519cce260486155c8ea3a9c306903d95466  oracle/unit-above_threshold-float32/completeness.csv
+27046e66bff85457b7945c5646ae0ac6f94d59065846dee47cfe90aacaee9ec1  oracle/unit-above_threshold-float32/connectivity.parquet
+e048a4bb7d8508a47abafa3174336ddb1173191e6cb2a6e62207a07e287201f4  oracle/unit-above_threshold-float32/environment.json
+c5982c3d7ddbb031347cb389692bd9e78b4d851732d4192ca8d9db1f5ce31128  oracle/unit-above_threshold-float32/external-arrivals.csv
+8c1278d8e1e4b028900e0353f7f9800300dad618be28e028714c7c1889a64099  oracle/unit-above_threshold-float32/generated-code.json
+cfad3e3ae7578e64365753675ead4358495da79ee379d78e192172b50a688023  oracle/unit-above_threshold-float32/independent-output/events.csv
+255a185d372d457eaf15e2512db78751f0d994fd6a3969bd3b5e3095ef6628bb  oracle/unit-above_threshold-float32/independent-output/state.npz
+05cc155e6979dea2f1aad7cf64fad64e2cb2f8e6b3578d6bc1948b27c8bda779  oracle/unit-above_threshold-float32/run-spec.json
+d3183a588eff0f4824dd5680af6401e35370fa7e74268ae0700ba5522e6d278d  oracle/unit-above_threshold-float32/schedule.json
+a6f4b88a4b799a7ac2b91764d632dbf3e05b16535a9c5ab64ad59092902db88e  oracle/unit-above_threshold-float32/seed.json
+db73a9c3923de0e57985b46613bf87bf599fcdd11541bb9576bc239838c8062b  oracle/unit-above_threshold-float64/actual-weights.json
+cfad3e3ae7578e64365753675ead4358495da79ee379d78e192172b50a688023  oracle/unit-above_threshold-float64/brian-output/events.csv
+d2796957a5a007cf0fb8a491565fca7017109ca792207bf88e7885a2d139da8e  oracle/unit-above_threshold-float64/brian-output/state.npz
+34382539f3576746462c29b584d5c3efbcc827f434e5c55d399c58e0fe5212f7  oracle/unit-above_threshold-float64/comparison.json
+6798ede76e783a56766ebb676a851519cce260486155c8ea3a9c306903d95466  oracle/unit-above_threshold-float64/completeness.csv
+27046e66bff85457b7945c5646ae0ac6f94d59065846dee47cfe90aacaee9ec1  oracle/unit-above_threshold-float64/connectivity.parquet
+e048a4bb7d8508a47abafa3174336ddb1173191e6cb2a6e62207a07e287201f4  oracle/unit-above_threshold-float64/environment.json
+c5982c3d7ddbb031347cb389692bd9e78b4d851732d4192ca8d9db1f5ce31128  oracle/unit-above_threshold-float64/external-arrivals.csv
+260ff4764dbbad4c87966c46d61f804b146c9c3b98ab50db2bd135aa33086050  oracle/unit-above_threshold-float64/generated-code.json
+cfad3e3ae7578e64365753675ead4358495da79ee379d78e192172b50a688023  oracle/unit-above_threshold-float64/independent-output/events.csv
+aadd0c427beb534c78f62d64459ad2403981654d4c6df18d3d0538c0a867a010  oracle/unit-above_threshold-float64/independent-output/state.npz
+caabe9c7956d99f38f6cdc7f08bc81501186998221f4f9fb6c2d77fa68e9398b  oracle/unit-above_threshold-float64/run-spec.json
+d3183a588eff0f4824dd5680af6401e35370fa7e74268ae0700ba5522e6d278d  oracle/unit-above_threshold-float64/schedule.json
+05b71129e058b3685e2913a4ea737a387b407b09f521670ec4b00d19c9e3eac5  oracle/unit-above_threshold-float64/seed.json
+c9b7702f929fe1e2a3d5bdaa673994de0db223fff4e09b52e7c5759c2b972e32  oracle/unit-delay_18-float32/actual-weights.json
+10b1b3eda316d86e0df6180a7e00c914528fcb0949728895ba25605d11e409b3  oracle/unit-delay_18-float32/brian-output/events.csv
+bf6177ae609e33c81f46afb499da962aa82ea493b172377d690e5842e42a9017  oracle/unit-delay_18-float32/brian-output/state.npz
+37f394b3a181d7f99431910bba73c4b11d83379bb33525e5f93aad4903121c3f  oracle/unit-delay_18-float32/comparison.json
+843dba272f8f33a966eb902023ed2851be0f0316ea02245d48b613f72b38785b  oracle/unit-delay_18-float32/completeness.csv
+e69f1527a0dcdb8de465ae38a9264124ac14e96277daab69c178f6ef5e987555  oracle/unit-delay_18-float32/connectivity.parquet
+e048a4bb7d8508a47abafa3174336ddb1173191e6cb2a6e62207a07e287201f4  oracle/unit-delay_18-float32/environment.json
+1628ba80041d8f31231e9c809ab0fcb48062bb957ec98d3f8b5d4b0e6bb78137  oracle/unit-delay_18-float32/generated-code.json
+10b1b3eda316d86e0df6180a7e00c914528fcb0949728895ba25605d11e409b3  oracle/unit-delay_18-float32/independent-output/events.csv
+46abab9351e62c525c17fef31edbefc400e8322362188ea1c9d9c20fcf1d0f30  oracle/unit-delay_18-float32/independent-output/state.npz
+250f049da54ebe5be709647d7f5eff2bb16faf9931980bfbfdc45de75612953b  oracle/unit-delay_18-float32/run-spec.json
+d3183a588eff0f4824dd5680af6401e35370fa7e74268ae0700ba5522e6d278d  oracle/unit-delay_18-float32/schedule.json
+242b26859a24e2fcc60597f50c28f4a52f08edfd42c38100c5964576cbc37ccc  oracle/unit-delay_18-float32/seed.json
+213ee768839567d5f119ae77d914541359f91a5a206ab6c7bf1a8293a29cc816  oracle/unit-delay_18-float64/actual-weights.json
+10b1b3eda316d86e0df6180a7e00c914528fcb0949728895ba25605d11e409b3  oracle/unit-delay_18-float64/brian-output/events.csv
+5f112e5aae8ee0e74347d508397ad2d4f7ec2ad149f4c00ea65ecf41c632d1cb  oracle/unit-delay_18-float64/brian-output/state.npz
+1a4ff3495394f915ef545e4e76101b0bd51a31bc93a3b566c6ba0f8273ba51ba  oracle/unit-delay_18-float64/comparison.json
+843dba272f8f33a966eb902023ed2851be0f0316ea02245d48b613f72b38785b  oracle/unit-delay_18-float64/completeness.csv
+e69f1527a0dcdb8de465ae38a9264124ac14e96277daab69c178f6ef5e987555  oracle/unit-delay_18-float64/connectivity.parquet
+e048a4bb7d8508a47abafa3174336ddb1173191e6cb2a6e62207a07e287201f4  oracle/unit-delay_18-float64/environment.json
+b754c9b23e259086e1b17bf3a2179a7f22acecec2eaf39b82bc48df31178dc08  oracle/unit-delay_18-float64/generated-code.json
+10b1b3eda316d86e0df6180a7e00c914528fcb0949728895ba25605d11e409b3  oracle/unit-delay_18-float64/independent-output/events.csv
+0e2389bb9a8c4f1a5be9f5cda11bcdb977839d608cacd7eff0249a0af3e8e180  oracle/unit-delay_18-float64/independent-output/state.npz
+bab3876796fe01fd3c21a252d18de06bd1e2c3d9db8ceab600b28c7f5f6580ae  oracle/unit-delay_18-float64/run-spec.json
+d3183a588eff0f4824dd5680af6401e35370fa7e74268ae0700ba5522e6d278d  oracle/unit-delay_18-float64/schedule.json
+5084ab20be7af7ed30622b8e72f679fb89d3de638ce8f4af4c7c0c24a1d45a29  oracle/unit-delay_18-float64/seed.json
+db73a9c3923de0e57985b46613bf87bf599fcdd11541bb9576bc239838c8062b  oracle/unit-equal_threshold-float32/actual-weights.json
+7629aa69f016398dea6007af19edce7566ebf6f480c75e8af176821c20bbd801  oracle/unit-equal_threshold-float32/brian-output/events.csv
+e0b133b9473e529e9a6d29c5cd236f9b9f4a88dc17b11317386d829d7d3b83ac  oracle/unit-equal_threshold-float32/brian-output/state.npz
+950e79516e1d611cc30336d2ec02ef99c9511fce58dfe1eb4edc92aedddff8f7  oracle/unit-equal_threshold-float32/comparison.json
+6798ede76e783a56766ebb676a851519cce260486155c8ea3a9c306903d95466  oracle/unit-equal_threshold-float32/completeness.csv
+27046e66bff85457b7945c5646ae0ac6f94d59065846dee47cfe90aacaee9ec1  oracle/unit-equal_threshold-float32/connectivity.parquet
+e048a4bb7d8508a47abafa3174336ddb1173191e6cb2a6e62207a07e287201f4  oracle/unit-equal_threshold-float32/environment.json
+c5982c3d7ddbb031347cb389692bd9e78b4d851732d4192ca8d9db1f5ce31128  oracle/unit-equal_threshold-float32/external-arrivals.csv
+86fd33e9730c1d4675224eaff6ecc4feaf9808e58f51c93e7df252c821998736  oracle/unit-equal_threshold-float32/generated-code.json
+7629aa69f016398dea6007af19edce7566ebf6f480c75e8af176821c20bbd801  oracle/unit-equal_threshold-float32/independent-output/events.csv
+e0511cd2618ec1229697e25a46cc0f69c31522317f02188c6fde3ccdfb21b8b4  oracle/unit-equal_threshold-float32/independent-output/state.npz
+fac5e0aa0191b2c1588aab61ae63bd33506f9e1388025be1147eece5c1a7201e  oracle/unit-equal_threshold-float32/run-spec.json
+d3183a588eff0f4824dd5680af6401e35370fa7e74268ae0700ba5522e6d278d  oracle/unit-equal_threshold-float32/schedule.json
+478668928b9024183568ba20f423f1f81eb9da3a2ad3427ce9bd55ed27779602  oracle/unit-equal_threshold-float32/seed.json
+db73a9c3923de0e57985b46613bf87bf599fcdd11541bb9576bc239838c8062b  oracle/unit-equal_threshold-float64/actual-weights.json
+7629aa69f016398dea6007af19edce7566ebf6f480c75e8af176821c20bbd801  oracle/unit-equal_threshold-float64/brian-output/events.csv
+20d649e7f7cc7bc9b231ff0d5cd86474d71bb45ad1965d1fcc6cd44fe9b10fcc  oracle/unit-equal_threshold-float64/brian-output/state.npz
+92164ae71a1399241866df040a559c7c1a9b8fca9327bcb009665a6bf8eeef4a  oracle/unit-equal_threshold-float64/comparison.json
+6798ede76e783a56766ebb676a851519cce260486155c8ea3a9c306903d95466  oracle/unit-equal_threshold-float64/completeness.csv
+27046e66bff85457b7945c5646ae0ac6f94d59065846dee47cfe90aacaee9ec1  oracle/unit-equal_threshold-float64/connectivity.parquet
+e048a4bb7d8508a47abafa3174336ddb1173191e6cb2a6e62207a07e287201f4  oracle/unit-equal_threshold-float64/environment.json
+c5982c3d7ddbb031347cb389692bd9e78b4d851732d4192ca8d9db1f5ce31128  oracle/unit-equal_threshold-float64/external-arrivals.csv
+b754c9b23e259086e1b17bf3a2179a7f22acecec2eaf39b82bc48df31178dc08  oracle/unit-equal_threshold-float64/generated-code.json
+7629aa69f016398dea6007af19edce7566ebf6f480c75e8af176821c20bbd801  oracle/unit-equal_threshold-float64/independent-output/events.csv
+39bb07a9f2a71652ead9cb5cd1d82626b367d9f77f28a2890f29813d6abd531c  oracle/unit-equal_threshold-float64/independent-output/state.npz
+048c7994f12ce279353916c6e0770aa942c4d265953a73f2fbdcfc823899c68d  oracle/unit-equal_threshold-float64/run-spec.json
+d3183a588eff0f4824dd5680af6401e35370fa7e74268ae0700ba5522e6d278d  oracle/unit-equal_threshold-float64/schedule.json
+2fce02c931341034076747847551dd7c463a5afbca82f53aac1ea5262da25546  oracle/unit-equal_threshold-float64/seed.json
+db73a9c3923de0e57985b46613bf87bf599fcdd11541bb9576bc239838c8062b  oracle/unit-inhibition-float32/actual-weights.json
+7629aa69f016398dea6007af19edce7566ebf6f480c75e8af176821c20bbd801  oracle/unit-inhibition-float32/brian-output/events.csv
+e17bb1325b04dd6a39587a15f5be9de3a898369643de9d8ac0d8cb8f50fa0655  oracle/unit-inhibition-float32/brian-output/state.npz
+00dc58085703002b0c7828f8626b7a4c0a67ccb780e9934b1a6027278e160147  oracle/unit-inhibition-float32/comparison.json
+6798ede76e783a56766ebb676a851519cce260486155c8ea3a9c306903d95466  oracle/unit-inhibition-float32/completeness.csv
+27046e66bff85457b7945c5646ae0ac6f94d59065846dee47cfe90aacaee9ec1  oracle/unit-inhibition-float32/connectivity.parquet
+e048a4bb7d8508a47abafa3174336ddb1173191e6cb2a6e62207a07e287201f4  oracle/unit-inhibition-float32/environment.json
+cdb3b47045c3e08a5e7f91d835e9b974267e8c39aa5c0b6f01848d02fddc9121  oracle/unit-inhibition-float32/external-arrivals.csv
+24049d57fb087bbf6a32304d9a5a21ad9015d7c07dd5a42f94d5856e24648910  oracle/unit-inhibition-float32/generated-code.json
+7629aa69f016398dea6007af19edce7566ebf6f480c75e8af176821c20bbd801  oracle/unit-inhibition-float32/independent-output/events.csv
+7606a26a9237ce3a3a1b93549e9a9e9489c4bd0f209fdcfaadad20bdfd71b025  oracle/unit-inhibition-float32/independent-output/state.npz
+2be318173be5d8ab53909c92b7a10158dd792342f23706755bacd93b99d6304c  oracle/unit-inhibition-float32/run-spec.json
+fed340d7ab41bbb7a1a18d125c8a2fb0129c1eeea1967ade86725f1e7753d116  oracle/unit-inhibition-float32/schedule.json
+77d0534413e66efb896580996b934bc368c90e1fa65d19c0dd6e5e36d8eda830  oracle/unit-inhibition-float32/seed.json
+db73a9c3923de0e57985b46613bf87bf599fcdd11541bb9576bc239838c8062b  oracle/unit-inhibition-float64/actual-weights.json
+7629aa69f016398dea6007af19edce7566ebf6f480c75e8af176821c20bbd801  oracle/unit-inhibition-float64/brian-output/events.csv
+bb92d8189c4899d878f3ba14981a0d3e5d9e533ed193a4ac46d7ae96b5b8ed2b  oracle/unit-inhibition-float64/brian-output/state.npz
+9b5906fd6915f910df0c46bd171cb693bc3be927321585f298ce5bf41c675dd1  oracle/unit-inhibition-float64/comparison.json
+6798ede76e783a56766ebb676a851519cce260486155c8ea3a9c306903d95466  oracle/unit-inhibition-float64/completeness.csv
+27046e66bff85457b7945c5646ae0ac6f94d59065846dee47cfe90aacaee9ec1  oracle/unit-inhibition-float64/connectivity.parquet
+e048a4bb7d8508a47abafa3174336ddb1173191e6cb2a6e62207a07e287201f4  oracle/unit-inhibition-float64/environment.json
+cdb3b47045c3e08a5e7f91d835e9b974267e8c39aa5c0b6f01848d02fddc9121  oracle/unit-inhibition-float64/external-arrivals.csv
+f7353d7fd8f7c017924959f0db57b3a7101b72b65f0bcb4fe8ba5bf02f7c8cb3  oracle/unit-inhibition-float64/generated-code.json
+7629aa69f016398dea6007af19edce7566ebf6f480c75e8af176821c20bbd801  oracle/unit-inhibition-float64/independent-output/events.csv
+0ba4c1b5727aa46dc66855cc9d61bfce3f19c2af046ff41b4e1fd3594565a455  oracle/unit-inhibition-float64/independent-output/state.npz
+1618df58c1883b6a34f4f247fa2a4dac41d29391f405efb8813d49d49ae9aab9  oracle/unit-inhibition-float64/run-spec.json
+fed340d7ab41bbb7a1a18d125c8a2fb0129c1eeea1967ade86725f1e7753d116  oracle/unit-inhibition-float64/schedule.json
+77d0534413e66efb896580996b934bc368c90e1fa65d19c0dd6e5e36d8eda830  oracle/unit-inhibition-float64/seed.json
+db73a9c3923de0e57985b46613bf87bf599fcdd11541bb9576bc239838c8062b  oracle/unit-nonzero_g_reset-float32/actual-weights.json
+d8885a4d083fff2f22fad52be2eaf08adc23e25015dafded0fedc16cf36a4cb1  oracle/unit-nonzero_g_reset-float32/brian-output/events.csv
+b1397ec47218beb84a911a3df7461c2b5a34ae827b0321e9420f7840bc2dd946  oracle/unit-nonzero_g_reset-float32/brian-output/state.npz
+a67c8fb6afb8cca2f58f0710a9c78720ddbbe78994fb230a4a55f42270c8fd49  oracle/unit-nonzero_g_reset-float32/comparison.json
+6798ede76e783a56766ebb676a851519cce260486155c8ea3a9c306903d95466  oracle/unit-nonzero_g_reset-float32/completeness.csv
+27046e66bff85457b7945c5646ae0ac6f94d59065846dee47cfe90aacaee9ec1  oracle/unit-nonzero_g_reset-float32/connectivity.parquet
+e048a4bb7d8508a47abafa3174336ddb1173191e6cb2a6e62207a07e287201f4  oracle/unit-nonzero_g_reset-float32/environment.json
+997f7e35a6eb1a267ccef4c8794c72e7d0d119a7d5328bffb271e05602555651  oracle/unit-nonzero_g_reset-float32/external-arrivals.csv
+3fb96b24ee1b80fecd16b80dbee70762cf917583a27ca3574393dd9571268708  oracle/unit-nonzero_g_reset-float32/generated-code.json
+d8885a4d083fff2f22fad52be2eaf08adc23e25015dafded0fedc16cf36a4cb1  oracle/unit-nonzero_g_reset-float32/independent-output/events.csv
+c22b4ca49e3b3f3b1226d75dbfd7f5c8e59a7cc8f27ce5b31e5683b77b88d05d  oracle/unit-nonzero_g_reset-float32/independent-output/state.npz
+4782f44e07a5e6e99502c733fb77cf1bf8f3b767e9b87914347d07165a035b7b  oracle/unit-nonzero_g_reset-float32/run-spec.json
+fed340d7ab41bbb7a1a18d125c8a2fb0129c1eeea1967ade86725f1e7753d116  oracle/unit-nonzero_g_reset-float32/schedule.json
+77d0534413e66efb896580996b934bc368c90e1fa65d19c0dd6e5e36d8eda830  oracle/unit-nonzero_g_reset-float32/seed.json
+db73a9c3923de0e57985b46613bf87bf599fcdd11541bb9576bc239838c8062b  oracle/unit-nonzero_g_reset-float64/actual-weights.json
+d8885a4d083fff2f22fad52be2eaf08adc23e25015dafded0fedc16cf36a4cb1  oracle/unit-nonzero_g_reset-float64/brian-output/events.csv
+c7e06817d1c24d8f5b190e7ad900f560b62b695f3e2f3f60b81f87de32f95efd  oracle/unit-nonzero_g_reset-float64/brian-output/state.npz
+34382539f3576746462c29b584d5c3efbcc827f434e5c55d399c58e0fe5212f7  oracle/unit-nonzero_g_reset-float64/comparison.json
+6798ede76e783a56766ebb676a851519cce260486155c8ea3a9c306903d95466  oracle/unit-nonzero_g_reset-float64/completeness.csv
+27046e66bff85457b7945c5646ae0ac6f94d59065846dee47cfe90aacaee9ec1  oracle/unit-nonzero_g_reset-float64/connectivity.parquet
+e048a4bb7d8508a47abafa3174336ddb1173191e6cb2a6e62207a07e287201f4  oracle/unit-nonzero_g_reset-float64/environment.json
+997f7e35a6eb1a267ccef4c8794c72e7d0d119a7d5328bffb271e05602555651  oracle/unit-nonzero_g_reset-float64/external-arrivals.csv
+b5921dbc5e709b3405a4b1ed1521f834bb0a4999d154f5e6f772a290aaaa8de7  oracle/unit-nonzero_g_reset-float64/generated-code.json
+d8885a4d083fff2f22fad52be2eaf08adc23e25015dafded0fedc16cf36a4cb1  oracle/unit-nonzero_g_reset-float64/independent-output/events.csv
+4d372bb8e51307731fa7339822838c3580c64ee1dd4d4f3ad8ad0420258bd1b8  oracle/unit-nonzero_g_reset-float64/independent-output/state.npz
+916cdd2cd038a2ae1e79681ebfeeb83af185407cf2b1b87583cc50f4164c4808  oracle/unit-nonzero_g_reset-float64/run-spec.json
+fed340d7ab41bbb7a1a18d125c8a2fb0129c1eeea1967ade86725f1e7753d116  oracle/unit-nonzero_g_reset-float64/schedule.json
+77d0534413e66efb896580996b934bc368c90e1fa65d19c0dd6e5e36d8eda830  oracle/unit-nonzero_g_reset-float64/seed.json
+db73a9c3923de0e57985b46613bf87bf599fcdd11541bb9576bc239838c8062b  oracle/unit-refractory_boundary-float32/actual-weights.json
+cfad3e3ae7578e64365753675ead4358495da79ee379d78e192172b50a688023  oracle/unit-refractory_boundary-float32/brian-output/events.csv
+1a096b2af8c95436307c5368107a197bd30614a55a5f48b22cc15cdcab231c05  oracle/unit-refractory_boundary-float32/brian-output/state.npz
+704e19a55381a72ef05e90655d079152bf96893b54cb2aaf8413ffa6a97cb32c  oracle/unit-refractory_boundary-float32/comparison.json
+6798ede76e783a56766ebb676a851519cce260486155c8ea3a9c306903d95466  oracle/unit-refractory_boundary-float32/completeness.csv
+27046e66bff85457b7945c5646ae0ac6f94d59065846dee47cfe90aacaee9ec1  oracle/unit-refractory_boundary-float32/connectivity.parquet
+e048a4bb7d8508a47abafa3174336ddb1173191e6cb2a6e62207a07e287201f4  oracle/unit-refractory_boundary-float32/environment.json
+f9298feb0fed9c1e4cfb4a01313d436437fa9cdacb03bc9f67cf4299dc76df86  oracle/unit-refractory_boundary-float32/external-arrivals.csv
+608de56c02e7febe4cdcdaa8c17faded84b9fa187d6f08eb7c393c9fb07f9be3  oracle/unit-refractory_boundary-float32/generated-code.json
+cfad3e3ae7578e64365753675ead4358495da79ee379d78e192172b50a688023  oracle/unit-refractory_boundary-float32/independent-output/events.csv
+aef84b2be80bd1c41edad68cfc6610e31fc306e67bb8f8eec4677a65b9dab37e  oracle/unit-refractory_boundary-float32/independent-output/state.npz
+23f4baa792e2a02933f40b2c37392eab2bb6e56b0ab8395b1183f2c5a0f11fa1  oracle/unit-refractory_boundary-float32/run-spec.json
+9cef827c7fcf9c050b60ec311a0e6bcdfc311c2f2689ad2437c61fa6085d7388  oracle/unit-refractory_boundary-float32/schedule.json
+a6f4b88a4b799a7ac2b91764d632dbf3e05b16535a9c5ab64ad59092902db88e  oracle/unit-refractory_boundary-float32/seed.json
+db73a9c3923de0e57985b46613bf87bf599fcdd11541bb9576bc239838c8062b  oracle/unit-refractory_boundary-float64/actual-weights.json
+cfad3e3ae7578e64365753675ead4358495da79ee379d78e192172b50a688023  oracle/unit-refractory_boundary-float64/brian-output/events.csv
+cfb31ac1d31ae1dfda4b1c8de4e194ca2a6678d3188e650112617c19b183a017  oracle/unit-refractory_boundary-float64/brian-output/state.npz
+718e19524ef625c1f7920b78f11f64b18dc2f49c12ed32f5eceb70108085e316  oracle/unit-refractory_boundary-float64/comparison.json
+6798ede76e783a56766ebb676a851519cce260486155c8ea3a9c306903d95466  oracle/unit-refractory_boundary-float64/completeness.csv
+27046e66bff85457b7945c5646ae0ac6f94d59065846dee47cfe90aacaee9ec1  oracle/unit-refractory_boundary-float64/connectivity.parquet
+e048a4bb7d8508a47abafa3174336ddb1173191e6cb2a6e62207a07e287201f4  oracle/unit-refractory_boundary-float64/environment.json
+f9298feb0fed9c1e4cfb4a01313d436437fa9cdacb03bc9f67cf4299dc76df86  oracle/unit-refractory_boundary-float64/external-arrivals.csv
+3ccb5eecdcdbbc850e60d8209d263e5b4764630323d8109695308c3c4cf7b539  oracle/unit-refractory_boundary-float64/generated-code.json
+cfad3e3ae7578e64365753675ead4358495da79ee379d78e192172b50a688023  oracle/unit-refractory_boundary-float64/independent-output/events.csv
+1eabc0d77607ccefd7bcc893f863a6f3dc6b4e77fb01e1ece25c05c749278dc7  oracle/unit-refractory_boundary-float64/independent-output/state.npz
+89b378f4d00fd6431724acb74a1aa156a659d57fe5bb04ed140cd995b3843a64  oracle/unit-refractory_boundary-float64/run-spec.json
+9cef827c7fcf9c050b60ec311a0e6bcdfc311c2f2689ad2437c61fa6085d7388  oracle/unit-refractory_boundary-float64/schedule.json
+05b71129e058b3685e2913a4ea737a387b407b09f521670ec4b00d19c9e3eac5  oracle/unit-refractory_boundary-float64/seed.json
+db73a9c3923de0e57985b46613bf87bf599fcdd11541bb9576bc239838c8062b  oracle/unit-weak_excitation-float32/actual-weights.json
+7629aa69f016398dea6007af19edce7566ebf6f480c75e8af176821c20bbd801  oracle/unit-weak_excitation-float32/brian-output/events.csv
+dbc70d2acac1e00394f5997eea123503406ad816b65eb735824cc0b8dd8b35d7  oracle/unit-weak_excitation-float32/brian-output/state.npz
+0ae4a6f8661f1413a315b181e1c23ea71159075c2d2e31f7e3af270a92682231  oracle/unit-weak_excitation-float32/comparison.json
+6798ede76e783a56766ebb676a851519cce260486155c8ea3a9c306903d95466  oracle/unit-weak_excitation-float32/completeness.csv
+27046e66bff85457b7945c5646ae0ac6f94d59065846dee47cfe90aacaee9ec1  oracle/unit-weak_excitation-float32/connectivity.parquet
+e048a4bb7d8508a47abafa3174336ddb1173191e6cb2a6e62207a07e287201f4  oracle/unit-weak_excitation-float32/environment.json
+ea42121e82562a2dbfe3c5824556db9579c107749339c5e3b47f118b12249d8a  oracle/unit-weak_excitation-float32/external-arrivals.csv
+b5921dbc5e709b3405a4b1ed1521f834bb0a4999d154f5e6f772a290aaaa8de7  oracle/unit-weak_excitation-float32/generated-code.json
+7629aa69f016398dea6007af19edce7566ebf6f480c75e8af176821c20bbd801  oracle/unit-weak_excitation-float32/independent-output/events.csv
+93ce0a2838dab0c652f6ec2fb8c96992c42fd2d1e041eb589eb8987fab2498eb  oracle/unit-weak_excitation-float32/independent-output/state.npz
+fa4c5b573d984a526abe9d7abc497575e7fafe53a7fc3c9e76d4741fa0c2efbd  oracle/unit-weak_excitation-float32/run-spec.json
+fed340d7ab41bbb7a1a18d125c8a2fb0129c1eeea1967ade86725f1e7753d116  oracle/unit-weak_excitation-float32/schedule.json
+77d0534413e66efb896580996b934bc368c90e1fa65d19c0dd6e5e36d8eda830  oracle/unit-weak_excitation-float32/seed.json
+db73a9c3923de0e57985b46613bf87bf599fcdd11541bb9576bc239838c8062b  oracle/unit-weak_excitation-float64/actual-weights.json
+7629aa69f016398dea6007af19edce7566ebf6f480c75e8af176821c20bbd801  oracle/unit-weak_excitation-float64/brian-output/events.csv
+4591217f7526896243c0e3e8310a8f885e72ffad6bda56559a7edc8fbce1c0c3  oracle/unit-weak_excitation-float64/brian-output/state.npz
+f39862589647cc0cfca90de10aebad6265a9ea94c533915991c700403cec8b60  oracle/unit-weak_excitation-float64/comparison.json
+6798ede76e783a56766ebb676a851519cce260486155c8ea3a9c306903d95466  oracle/unit-weak_excitation-float64/completeness.csv
+27046e66bff85457b7945c5646ae0ac6f94d59065846dee47cfe90aacaee9ec1  oracle/unit-weak_excitation-float64/connectivity.parquet
+e048a4bb7d8508a47abafa3174336ddb1173191e6cb2a6e62207a07e287201f4  oracle/unit-weak_excitation-float64/environment.json
+ea42121e82562a2dbfe3c5824556db9579c107749339c5e3b47f118b12249d8a  oracle/unit-weak_excitation-float64/external-arrivals.csv
+023b8cdde1fea892e40cd5e58e75bed9d7febcd670a6c749882deb04c7d84132  oracle/unit-weak_excitation-float64/generated-code.json
+7629aa69f016398dea6007af19edce7566ebf6f480c75e8af176821c20bbd801  oracle/unit-weak_excitation-float64/independent-output/events.csv
+4c0b86fcae0498e9e510a3333bf919a33e0b8bd19fb0d0a37aed4e102a5e61e6  oracle/unit-weak_excitation-float64/independent-output/state.npz
+3ae45d37b147e6dd3a5bd596b8757e4909cbb0c1386d30e94becfd1ae331d90c  oracle/unit-weak_excitation-float64/run-spec.json
+fed340d7ab41bbb7a1a18d125c8a2fb0129c1eeea1967ade86725f1e7753d116  oracle/unit-weak_excitation-float64/schedule.json
+77d0534413e66efb896580996b934bc368c90e1fa65d19c0dd6e5e36d8eda830  oracle/unit-weak_excitation-float64/seed.json
+db73a9c3923de0e57985b46613bf87bf599fcdd11541bb9576bc239838c8062b  oracle/unit-zero-float32/actual-weights.json
+7629aa69f016398dea6007af19edce7566ebf6f480c75e8af176821c20bbd801  oracle/unit-zero-float32/brian-output/events.csv
+4e1d81697ef3df005548a1cb5891dce91fdfbee6c8cfc9586fff98c8a406e72e  oracle/unit-zero-float32/brian-output/state.npz
+e7ac75d3c7853ec3526b7dc1bdd7f94ccba58b4392c2a704ac4bc25b34130ce5  oracle/unit-zero-float32/comparison.json
+6798ede76e783a56766ebb676a851519cce260486155c8ea3a9c306903d95466  oracle/unit-zero-float32/completeness.csv
+27046e66bff85457b7945c5646ae0ac6f94d59065846dee47cfe90aacaee9ec1  oracle/unit-zero-float32/connectivity.parquet
+e048a4bb7d8508a47abafa3174336ddb1173191e6cb2a6e62207a07e287201f4  oracle/unit-zero-float32/environment.json
+c5982c3d7ddbb031347cb389692bd9e78b4d851732d4192ca8d9db1f5ce31128  oracle/unit-zero-float32/external-arrivals.csv
+daea9555d1ba0effb445e581ad4c74741d57b85ad6477907ff579a0957dc7242  oracle/unit-zero-float32/generated-code.json
+7629aa69f016398dea6007af19edce7566ebf6f480c75e8af176821c20bbd801  oracle/unit-zero-float32/independent-output/events.csv
+6f45ddfec94ada6a8747f5addc1f9f4a51d737739e245c7dc10739bf7e18cfc3  oracle/unit-zero-float32/independent-output/state.npz
+521bb565556d8daee043b995415ac154e9e63af899c2266b023e031acc27eef6  oracle/unit-zero-float32/run-spec.json
+a0ae45ec1bd5e9ad66296742ebb857263b1bde14ca260bbba260b570d359dcd5  oracle/unit-zero-float32/schedule.json
+77d0534413e66efb896580996b934bc368c90e1fa65d19c0dd6e5e36d8eda830  oracle/unit-zero-float32/seed.json
+db73a9c3923de0e57985b46613bf87bf599fcdd11541bb9576bc239838c8062b  oracle/unit-zero-float64/actual-weights.json
+7629aa69f016398dea6007af19edce7566ebf6f480c75e8af176821c20bbd801  oracle/unit-zero-float64/brian-output/events.csv
+08b144e5f87768b33642885391e00812222ef69ed15282fbc525c986e058dda9  oracle/unit-zero-float64/brian-output/state.npz
+34382539f3576746462c29b584d5c3efbcc827f434e5c55d399c58e0fe5212f7  oracle/unit-zero-float64/comparison.json
+6798ede76e783a56766ebb676a851519cce260486155c8ea3a9c306903d95466  oracle/unit-zero-float64/completeness.csv
+27046e66bff85457b7945c5646ae0ac6f94d59065846dee47cfe90aacaee9ec1  oracle/unit-zero-float64/connectivity.parquet
+e048a4bb7d8508a47abafa3174336ddb1173191e6cb2a6e62207a07e287201f4  oracle/unit-zero-float64/environment.json
+c5982c3d7ddbb031347cb389692bd9e78b4d851732d4192ca8d9db1f5ce31128  oracle/unit-zero-float64/external-arrivals.csv
+659f799403ba4fec6b169b25f70a96477681c3d79b70b54687792c29149eb96a  oracle/unit-zero-float64/generated-code.json
+7629aa69f016398dea6007af19edce7566ebf6f480c75e8af176821c20bbd801  oracle/unit-zero-float64/independent-output/events.csv
+d5c77d7a0fe8023a11635ab793f30a6c8e419211aea3707deddda9b2c38c6f8b  oracle/unit-zero-float64/independent-output/state.npz
+d4852ae58f33a87ac68f3efea658b432833e41921dd6914b12c3e153a870f3aa  oracle/unit-zero-float64/run-spec.json
+a0ae45ec1bd5e9ad66296742ebb857263b1bde14ca260bbba260b570d359dcd5  oracle/unit-zero-float64/schedule.json
+77d0534413e66efb896580996b934bc368c90e1fa65d19c0dd6e5e36d8eda830  oracle/unit-zero-float64/seed.json
+78bc80361a72f4620b39dc0363a1c2d13cff756f2cf920f879dcdf9b7ba8e3d1  performance/summary.json
+dd3c72b63544c8ec63e6b0f5eb4291a34f225537d63d56912998377de9cfd20e  protocol/preregistered.json
+ef1016ca89aad6a53209927015a423c6a7bff49bb2dc271e98ba90cd4b22a274  regression/author-motifs.json
+5762a442ecb94319bed0f35b8e64adbf9d122f938c99b1249107adfd1e717cb7  regression/feedforward-float32-repeat.json
+5762a442ecb94319bed0f35b8e64adbf9d122f938c99b1249107adfd1e717cb7  regression/feedforward-float64-repeat.json
+f428f9d3f572e8f66bce255f348861e1e1994973bdb7f5d3206924195d829383  regression/feedforward-precision-cross-comparison.json
+5762a442ecb94319bed0f35b8e64adbf9d122f938c99b1249107adfd1e717cb7  regression/five-float32-repeat.json
+5762a442ecb94319bed0f35b8e64adbf9d122f938c99b1249107adfd1e717cb7  regression/five-float64-repeat.json
+8aa2658f0be118fcfa9bafb8b07fedcb3713842aab31da5d360c1092bf73a600  regression/five-precision-cross-comparison.json
+520d9d9fcc26f6041113f9d94b0690a487cb89d38aa5eb9888857abdfed19ea4  regression/frozen-auditory-100hz.json
+bf6d4a709ad9020de4007f44addec2cd38b7598c4dcd58bf7cbf31b41d2807bd  regression/frozen-auditory-10hz.json
+7e2e4f200f40ef1f5df3736176344c3a300533cb12f3cfb8022845ce312701ca  regression/frozen-components.json
+331153e43e8b49d53c370b4990f11c3d956a5a869cb3c5331e5e216f93a694cb  regression/frozen-five.json
+800a8f2e6e5ab44608919b73a4fcfe2b35b9007418fa7cf0f4ae8e93d1fbc1fa  regression/frozen-gustatory-50hz.json
+98fb62ea14694a0df78c673c3c76728d62a4036835c82f03eb2e7f2c17bf4625  regression/frozen-mechanosensory-50hz.json
+9284aa8d73c36e6a0441320a9511cec65099bcf7ffd772f982e62e78ab8a3666  regression/frozen-olfactory-50hz.json
+5762a442ecb94319bed0f35b8e64adbf9d122f938c99b1249107adfd1e717cb7  regression/no_input-float32-repeat.json
+5762a442ecb94319bed0f35b8e64adbf9d122f938c99b1249107adfd1e717cb7  regression/no_input-float64-repeat.json
+76f106dbc71d81822f8711e5970da7876fe76416a14a185d7915e8480381c544  regression/no_input-precision-cross-comparison.json
+242b02c49b613d2cff475f570083b0521460c840dca51c17902f7df40e052581  regression/old-integrity-after.json
+0347f6273992fa842ea4f9526492362ac9774ad1194c8367b0632e7367987116  regression/old-integrity-before.json
+5762a442ecb94319bed0f35b8e64adbf9d122f938c99b1249107adfd1e717cb7  regression/pair-float32-repeat.json
+5762a442ecb94319bed0f35b8e64adbf9d122f938c99b1249107adfd1e717cb7  regression/pair-float64-repeat.json
+69c2960eb018b5d4957aea01ff60ceae6df8785315a239b07ab432b7a205a541  regression/pair-precision-cross-comparison.json
+f4a10cd026bb3e3e2d84f3fa26125462fdd09d2fedf2198f89faa7ba4bb065a3  regression/preregistration-after.json
+5762a442ecb94319bed0f35b8e64adbf9d122f938c99b1249107adfd1e717cb7  regression/trio-float32-repeat.json
+5762a442ecb94319bed0f35b8e64adbf9d122f938c99b1249107adfd1e717cb7  regression/trio-float64-repeat.json
+ffa52f9ff04c4887c714cf1dc69159263a3cce02be605e0830f945ece22de508  regression/trio-precision-cross-comparison.json
+e3326d69d3fb00d5d6d5b2d7764426ad0a1c02b7bf7fa067dd2866e78574aedd  regression/unit-above_threshold-float32.json
+c4720e6d20648b3292b7693a27782a755b65bc9ac40df1240c5f9c804d4c60ec  regression/unit-above_threshold-float64.json
+5fe18868d3780d899ec9fe97630e019d70420023f367109cf015b984d18478f7  regression/unit-delay_18-float32.json
+7cde7f95e04a3870fe6b42a99493f2cba5cf8e6b20ca01d7a39d6eca02a829d9  regression/unit-delay_18-float64.json
+3ff0b4c36f7f672a0110378f85d12dd144451b4210f7cc647d77df12187ff9fe  regression/unit-equal_threshold-float32.json
+3b2ed15b07ea2422e184764006054c23d5a80810c3bbfa6ce6fee5ff2f42a7a0  regression/unit-equal_threshold-float64.json
+d8c24f386628b3c4186017a93b1f8a30c754a8da1ad2f787318cc564e297e958  regression/unit-fixtures.json
+f18d377531f46ff53d572c649a0c5308203d207af25071190e5fe8414594c0dd  regression/unit-inhibition-float32.json
+fe463e5e1de6dd528b31b09d3fd20b4e454ff4f6346dbd974ab9638fab3dc6b6  regression/unit-inhibition-float64.json
+45e62f5ca365ac7f40a74cf23094de1a8dc4f576d2ba7d56cc8866037921ea22  regression/unit-nonzero_g_reset-float32.json
+1b04dd164e00670c3f36bc17bb5d8e974703c94296d0b12f93de06de792d417f  regression/unit-nonzero_g_reset-float64.json
+cf3b2e0230e50b25e96c39b425aefafab780b01817377c0ce1e7e2aa20c43a30  regression/unit-refractory_boundary-float32.json
+57837e95ae73d376794a8fbb615ced5f412b4c43f7f31c56f08d65d66f74ca7b  regression/unit-refractory_boundary-float64.json
+97d17aa7336ed7c51e557fbc94c673773e94aa1dd5fc9069708964051086b995  regression/unit-weak_excitation-float32.json
+912f3ca442d089ed6e920bc0c00a8e30a1d62f34ee7a22b2f2b5e6f0544a3706  regression/unit-weak_excitation-float64.json
+cb42c0c2025e86b4006bb9e2aa6e893f0185be55c3baa77bddece09ed691e938  regression/unit-zero-float32.json
+4cc37c186bd7f6e6579840e516c840ae607581041b2d6da66971da611304e1d9  regression/unit-zero-float64.json
+c939d3977a1883e86108c1e3edd25619118cec61e5c7712ae4dfa2893a73c0ca  manifest.json

registry/phase4ad-author-semantics/evidence/components/feedforward-frozen/events.csv

@@ -0,0 +1,4 @@
+step,neuron_idx
+0,1381
+49,1511
+100,1197

registry/phase4ad-author-semantics/evidence/components/feedforward-refractory_gate_only/events.csv

@@ -0,0 +1,4 @@
+step,neuron_idx
+0,1381
+49,1511
+100,1197

registry/phase4ad-author-semantics/evidence/components/feedforward-reset_and_refractory/events.csv

@@ -0,0 +1,4 @@
+step,neuron_idx
+0,1381
+49,1511
+100,1197

registry/phase4ad-author-semantics/evidence/components/feedforward-reset_g_only/events.csv

@@ -0,0 +1,4 @@
+step,neuron_idx
+0,1381
+49,1511
+100,1197

registry/phase4ad-author-semantics/evidence/components/five-reset_and_refractory/events.csv

@@ -0,0 +1,635 @@
+step,neuron_idx
+0,1381
+45,1197
+49,1511
+77,1381
+88,133666
+96,1197
+116,1511
+135,1381
+157,1197
+165,133666
+178,1511
+198,1381
+212,1197
+237,1511
+250,133666
+258,1381
+277,1197
+295,1511
+318,1381
+328,133666
+339,1197
+358,1511
+377,1381
+399,1197
+407,133666
+420,1511
+440,1381
+454,1197
+479,1511
+492,133666
+500,1381
+519,1197
+537,1511
+560,1381
+570,133666
+581,1197
+600,1511
+619,1381
+641,1197
+649,133666
+662,1511
+682,1381
+682,82312
+696,1197
+721,1511
+734,133666
+742,1381
+761,1197
+779,1511
+802,1381
+812,133666
+823,1197
+842,1511
+861,1381
+883,1197
+891,133666
+904,1511
+924,1381
+938,1197
+963,1511
+976,133666
+984,1381
+1003,1197
+1021,1511
+1044,1381
+1054,133666
+1065,1197
+1084,1511
+1103,1381
+1125,1197
+1133,133666
+1146,1511
+1166,1381
+1180,1197
+1205,1511
+1218,133666
+1226,1381
+1245,1197
+1263,1511
+1286,1381
+1296,133666
+1307,1197
+1326,1511
+1332,82312
+1345,1381
+1367,1197
+1375,133666
+1388,1511
+1408,1381
+1422,1197
+1447,1511
+1460,133666
+1468,1381
+1487,1197
+1505,1511
+1528,1381
+1538,133666
+1549,1197
+1568,1511
+1587,1381
+1609,1197
+1617,133666
+1630,1511
+1650,1381
+1664,1197
+1689,1511
+1702,133666
+1710,1381
+1729,1197
+1747,1511
+1770,1381
+1780,133666
+1791,1197
+1810,1511
+1829,1381
+1851,1197
+1859,133666
+1872,1511
+1892,1381
+1906,1197
+1931,1511
+1944,133666
+1952,1381
+1971,1197
+1983,82312
+1989,1511
+2012,1381
+2022,133666
+2033,1197
+2052,1511
+2071,1381
+2093,1197
+2101,133666
+2114,1511
+2134,1381
+2148,1197
+2173,1511
+2186,133666
+2194,1381
+2213,1197
+2231,1511
+2254,1381
+2264,133666
+2275,1197
+2294,1511
+2313,1381
+2335,1197
+2343,133666
+2356,1511
+2376,1381
+2390,1197
+2415,1511
+2428,133666
+2436,1381
+2455,1197
+2473,1511
+2496,1381
+2506,133666
+2517,1197
+2536,1511
+2555,1381
+2577,1197
+2585,133666
+2598,1511
+2618,1381
+2618,82312
+2632,1197
+2657,1511
+2670,133666
+2678,1381
+2697,1197
+2715,1511
+2738,1381
+2748,133666
+2759,1197
+2778,1511
+2797,1381
+2819,1197
+2827,133666
+2840,1511
+2860,1381
+2874,1197
+2899,1511
+2912,133666
+2920,1381
+2939,1197
+2957,1511
+2980,1381
+2990,133666
+3001,1197
+3020,1511
+3039,1381
+3061,1197
+3069,133666
+3082,1511
+3102,1381
+3116,1197
+3141,1511
+3154,133666
+3162,1381
+3181,1197
+3199,1511
+3222,1381
+3232,133666
+3243,1197
+3262,1511
+3268,82312
+3281,1381
+3303,1197
+3311,133666
+3324,1511
+3344,1381
+3358,1197
+3383,1511
+3396,133666
+3404,1381
+3423,1197
+3441,1511
+3464,1381
+3474,133666
+3485,1197
+3504,1511
+3523,1381
+3545,1197
+3553,133666
+3566,1511
+3586,1381
+3600,1197
+3625,1511
+3638,133666
+3646,1381
+3665,1197
+3683,1511
+3706,1381
+3716,133666
+3727,1197
+3746,1511
+3765,1381
+3787,1197
+3795,133666
+3808,1511
+3828,1381
+3842,1197
+3867,1511
+3880,133666
+3888,1381
+3907,1197
+3919,82312
+3925,1511
+3948,1381
+3958,133666
+3969,1197
+3988,1511
+4007,1381
+4029,1197
+4037,133666
+4050,1511
+4070,1381
+4084,1197
+4109,1511
+4122,133666
+4130,1381
+4149,1197
+4167,1511
+4190,1381
+4200,133666
+4211,1197
+4230,1511
+4249,1381
+4271,1197
+4279,133666
+4292,1511
+4312,1381
+4326,1197
+4351,1511
+4364,133666
+4372,1381
+4391,1197
+4409,1511
+4432,1381
+4442,133666
+4453,1197
+4472,1511
+4491,1381
+4513,1197
+4521,133666
+4534,1511
+4554,1381
+4554,82312
+4568,1197
+4593,1511
+4606,133666
+4614,1381
+4633,1197
+4651,1511
+4674,1381
+4684,133666
+4695,1197
+4714,1511
+4733,1381
+4755,1197
+4763,133666
+4776,1511
+4796,1381
+4810,1197
+4835,1511
+4848,133666
+4856,1381
+4875,1197
+4893,1511
+4916,1381
+4926,133666
+4937,1197
+4956,1511
+4975,1381
+4997,1197
+5005,133666
+5018,1511
+5038,1381
+5052,1197
+5077,1511
+5090,133666
+5098,1381
+5117,1197
+5135,1511
+5158,1381
+5168,133666
+5179,1197
+5198,1511
+5204,82312
+5217,1381
+5239,1197
+5247,133666
+5260,1511
+5280,1381
+5294,1197
+5319,1511
+5332,133666
+5340,1381
+5359,1197
+5377,1511
+5400,1381
+5410,133666
+5421,1197
+5440,1511
+5459,1381
+5481,1197
+5489,133666
+5502,1511
+5522,1381
+5536,1197
+5561,1511
+5574,133666
+5582,1381
+5601,1197
+5619,1511
+5642,1381
+5652,133666
+5663,1197
+5682,1511
+5701,1381
+5723,1197
+5731,133666
+5744,1511
+5764,1381
+5778,1197
+5803,1511
+5816,133666
+5824,1381
+5843,1197
+5855,82312
+5861,1511
+5884,1381
+5894,133666
+5905,1197
+5924,1511
+5943,1381
+5965,1197
+5973,133666
+5986,1511
+6006,1381
+6020,1197
+6045,1511
+6058,133666
+6066,1381
+6085,1197
+6103,1511
+6126,1381
+6136,133666
+6147,1197
+6166,1511
+6185,1381
+6207,1197
+6215,133666
+6228,1511
+6248,1381
+6262,1197
+6287,1511
+6300,133666
+6308,1381
+6327,1197
+6345,1511
+6368,1381
+6378,133666
+6389,1197
+6408,1511
+6427,1381
+6449,1197
+6457,133666
+6470,1511
+6490,1381
+6490,82312
+6504,1197
+6529,1511
+6542,133666
+6550,1381
+6569,1197
+6587,1511
+6610,1381
+6620,133666
+6631,1197
+6650,1511
+6669,1381
+6691,1197
+6699,133666
+6712,1511
+6732,1381
+6746,1197
+6771,1511
+6784,133666
+6792,1381
+6811,1197
+6829,1511
+6852,1381
+6862,133666
+6873,1197
+6892,1511
+6911,1381
+6933,1197
+6941,133666
+6954,1511
+6974,1381
+6988,1197
+7013,1511
+7026,133666
+7034,1381
+7053,1197
+7071,1511
+7094,1381
+7104,133666
+7115,1197
+7134,1511
+7140,82312
+7153,1381
+7175,1197
+7183,133666
+7196,1511
+7216,1381
+7230,1197
+7255,1511
+7268,133666
+7276,1381
+7295,1197
+7313,1511
+7336,1381
+7346,133666
+7357,1197
+7376,1511
+7395,1381
+7417,1197
+7425,133666
+7438,1511
+7458,1381
+7472,1197
+7497,1511
+7510,133666
+7518,1381
+7537,1197
+7555,1511
+7578,1381
+7588,133666
+7599,1197
+7618,1511
+7637,1381
+7659,1197
+7667,133666
+7680,1511
+7700,1381
+7714,1197
+7739,1511
+7752,133666
+7760,1381
+7779,1197
+7791,82312
+7797,1511
+7820,1381
+7830,133666
+7841,1197
+7860,1511
+7879,1381
+7901,1197
+7909,133666
+7922,1511
+7942,1381
+7956,1197
+7981,1511
+7994,133666
+8002,1381
+8021,1197
+8039,1511
+8062,1381
+8072,133666
+8083,1197
+8102,1511
+8121,1381
+8143,1197
+8151,133666
+8164,1511
+8184,1381
+8198,1197
+8223,1511
+8236,133666
+8244,1381
+8263,1197
+8281,1511
+8304,1381
+8314,133666
+8325,1197
+8344,1511
+8363,1381
+8385,1197
+8393,133666
+8406,1511
+8426,1381
+8426,82312
+8440,1197
+8465,1511
+8478,133666
+8486,1381
+8505,1197
+8523,1511
+8546,1381
+8556,133666
+8567,1197
+8586,1511
+8605,1381
+8627,1197
+8635,133666
+8648,1511
+8668,1381
+8682,1197
+8707,1511
+8720,133666
+8728,1381
+8747,1197
+8765,1511
+8788,1381
+8798,133666
+8809,1197
+8828,1511
+8847,1381
+8869,1197
+8877,133666
+8890,1511
+8910,1381
+8924,1197
+8949,1511
+8962,133666
+8970,1381
+8989,1197
+9007,1511
+9030,1381
+9040,133666
+9051,1197
+9070,1511
+9076,82312
+9089,1381
+9111,1197
+9119,133666
+9132,1511
+9152,1381
+9166,1197
+9191,1511
+9204,133666
+9212,1381
+9231,1197
+9249,1511
+9272,1381
+9282,133666
+9293,1197
+9312,1511
+9331,1381
+9353,1197
+9361,133666
+9374,1511
+9394,1381
+9408,1197
+9433,1511
+9446,133666
+9454,1381
+9473,1197
+9491,1511
+9514,1381
+9524,133666
+9535,1197
+9554,1511
+9573,1381
+9595,1197
+9603,133666
+9616,1511
+9636,1381
+9650,1197
+9675,1511
+9688,133666
+9696,1381
+9715,1197
+9727,82312
+9733,1511
+9756,1381
+9766,133666
+9777,1197
+9796,1511
+9815,1381
+9837,1197
+9845,133666
+9858,1511
+9878,1381
+9892,1197
+9917,1511
+9930,133666
+9938,1381
+9957,1197
+9975,1511
+9998,1381

registry/phase4ad-author-semantics/evidence/components/five-reset_g_only/events.csv

@@ -0,0 +1,869 @@
+step,neuron_idx
+0,1381
+45,1197
+49,1511
+77,1381
+88,133666
+96,1197
+103,1511
+127,1381
+142,1197
+148,133666
+151,1511
+175,1381
+178,1197
+197,1511
+205,133666
+220,1381
+221,1197
+248,1511
+265,1197
+268,1381
+268,133666
+297,1511
+298,1197
+316,1381
+325,133666
+341,1197
+343,1511
+364,82312
+369,1381
+387,1197
+389,133666
+395,1511
+419,1381
+432,1197
+443,1511
+452,133666
+468,1381
+472,1197
+491,1511
+512,1381
+515,1197
+515,133666
+543,1511
+557,1197
+560,1381
+577,133666
+591,1511
+593,1197
+598,1381
+626,1197
+627,1511
+634,133666
+635,1381
+661,1197
+664,1511
+670,1381
+677,82312
+685,133666
+697,1197
+703,1511
+706,1381
+732,1197
+741,1511
+741,133666
+742,1381
+769,1197
+776,1381
+777,1511
+794,133666
+806,1197
+811,1381
+815,1511
+840,1197
+844,1381
+850,133666
+856,1511
+877,1197
+881,1381
+895,1511
+902,133666
+918,1197
+921,1381
+933,82312
+940,1511
+959,1197
+964,133666
+965,1381
+992,1511
+1000,1197
+1013,1381
+1024,133666
+1040,1511
+1041,1197
+1061,1381
+1082,1197
+1085,1511
+1086,133666
+1112,1381
+1124,1197
+1133,1511
+1146,133666
+1159,1381
+1163,1197
+1182,1511
+1203,1197
+1203,1381
+1207,133666
+1233,1511
+1244,1197
+1250,82312
+1251,1381
+1268,133666
+1281,1197
+1281,1511
+1301,1381
+1322,1197
+1325,1511
+1327,133666
+1352,1381
+1364,1197
+1373,1511
+1387,133666
+1399,1381
+1403,1197
+1422,1511
+1443,1197
+1443,1381
+1447,133666
+1473,1511
+1484,1197
+1491,1381
+1508,133666
+1521,1197
+1521,1511
+1541,1381
+1549,82312
+1562,1197
+1565,1511
+1567,133666
+1592,1381
+1604,1197
+1613,1511
+1627,133666
+1639,1381
+1643,1197
+1662,1511
+1683,1197
+1683,1381
+1687,133666
+1713,1511
+1724,1197
+1731,1381
+1748,133666
+1761,1197
+1761,1511
+1781,1381
+1802,1197
+1805,1511
+1807,133666
+1832,1381
+1844,1197
+1848,82312
+1853,1511
+1867,133666
+1879,1381
+1883,1197
+1902,1511
+1923,1197
+1923,1381
+1927,133666
+1953,1511
+1964,1197
+1971,1381
+1988,133666
+2001,1197
+2001,1511
+2021,1381
+2042,1197
+2045,1511
+2047,133666
+2072,1381
+2084,1197
+2093,1511
+2107,133666
+2119,1381
+2123,1197
+2142,1511
+2147,82312
+2163,1197
+2163,1381
+2167,133666
+2193,1511
+2204,1197
+2211,1381
+2228,133666
+2241,1197
+2241,1511
+2261,1381
+2282,1197
+2285,1511
+2287,133666
+2312,1381
+2324,1197
+2333,1511
+2347,133666
+2359,1381
+2363,1197
+2382,1511
+2403,1197
+2403,1381
+2407,133666
+2433,1511
+2444,1197
+2447,82312
+2451,1381
+2468,133666
+2481,1197
+2481,1511
+2501,1381
+2522,1197
+2525,1511
+2527,133666
+2552,1381
+2564,1197
+2573,1511
+2587,133666
+2599,1381
+2603,1197
+2622,1511
+2643,1197
+2643,1381
+2647,133666
+2673,1511
+2684,1197
+2691,1381
+2708,133666
+2721,1197
+2721,1511
+2741,1381
+2749,82312
+2762,1197
+2765,1511
+2767,133666
+2792,1381
+2804,1197
+2813,1511
+2827,133666
+2839,1381
+2843,1197
+2862,1511
+2883,1197
+2883,1381
+2887,133666
+2913,1511
+2924,1197
+2931,1381
+2948,133666
+2961,1197
+2961,1511
+2981,1381
+3002,1197
+3005,1511
+3007,133666
+3032,1381
+3044,1197
+3048,82312
+3053,1511
+3067,133666
+3079,1381
+3083,1197
+3102,1511
+3123,1197
+3123,1381
+3127,133666
+3153,1511
+3164,1197
+3171,1381
+3188,133666
+3201,1197
+3201,1511
+3221,1381
+3242,1197
+3245,1511
+3247,133666
+3272,1381
+3284,1197
+3293,1511
+3307,133666
+3319,1381
+3323,1197
+3342,1511
+3347,82312
+3363,1197
+3363,1381
+3367,133666
+3393,1511
+3404,1197
+3411,1381
+3428,133666
+3441,1197
+3441,1511
+3461,1381
+3482,1197
+3485,1511
+3487,133666
+3512,1381
+3524,1197
+3533,1511
+3547,133666
+3559,1381
+3563,1197
+3582,1511
+3603,1197
+3603,1381
+3607,133666
+3633,1511
+3644,1197
+3647,82312
+3651,1381
+3668,133666
+3681,1197
+3681,1511
+3701,1381
+3722,1197
+3725,1511
+3727,133666
+3752,1381
+3764,1197
+3773,1511
+3787,133666
+3799,1381
+3803,1197
+3822,1511
+3843,1197
+3843,1381
+3847,133666
+3873,1511
+3884,1197
+3891,1381
+3908,133666
+3921,1197
+3921,1511
+3941,1381
+3949,82312
+3962,1197
+3965,1511
+3967,133666
+3992,1381
+4004,1197
+4013,1511
+4027,133666
+4039,1381
+4043,1197
+4062,1511
+4083,1197
+4083,1381
+4087,133666
+4113,1511
+4124,1197
+4131,1381
+4148,133666
+4161,1197
+4161,1511
+4181,1381
+4202,1197
+4205,1511
+4207,133666
+4232,1381
+4244,1197
+4248,82312
+4253,1511
+4267,133666
+4279,1381
+4283,1197
+4302,1511
+4323,1197
+4323,1381
+4327,133666
+4353,1511
+4364,1197
+4371,1381
+4388,133666
+4401,1197
+4401,1511
+4421,1381
+4442,1197
+4445,1511
+4447,133666
+4472,1381
+4484,1197
+4493,1511
+4507,133666
+4519,1381
+4523,1197
+4542,1511
+4547,82312
+4563,1197
+4563,1381
+4567,133666
+4593,1511
+4604,1197
+4611,1381
+4628,133666
+4641,1197
+4641,1511
+4661,1381
+4682,1197
+4685,1511
+4687,133666
+4712,1381
+4724,1197
+4733,1511
+4747,133666
+4759,1381
+4763,1197
+4782,1511
+4803,1197
+4803,1381
+4807,133666
+4833,1511
+4844,1197
+4847,82312
+4851,1381
+4868,133666
+4881,1197
+4881,1511
+4901,1381
+4922,1197
+4925,1511
+4927,133666
+4952,1381
+4964,1197
+4973,1511
+4987,133666
+4999,1381
+5003,1197
+5022,1511
+5043,1197
+5043,1381
+5047,133666
+5073,1511
+5084,1197
+5091,1381
+5108,133666
+5121,1197
+5121,1511
+5141,1381
+5149,82312
+5162,1197
+5165,1511
+5167,133666
+5192,1381
+5204,1197
+5213,1511
+5227,133666
+5239,1381
+5243,1197
+5262,1511
+5283,1197
+5283,1381
+5287,133666
+5313,1511
+5324,1197
+5331,1381
+5348,133666
+5361,1197
+5361,1511
+5381,1381
+5402,1197
+5405,1511
+5407,133666
+5432,1381
+5444,1197
+5448,82312
+5453,1511
+5467,133666
+5479,1381
+5483,1197
+5502,1511
+5523,1197
+5523,1381
+5527,133666
+5553,1511
+5564,1197
+5571,1381
+5588,133666
+5601,1197
+5601,1511
+5621,1381
+5642,1197
+5645,1511
+5647,133666
+5672,1381
+5684,1197
+5693,1511
+5707,133666
+5719,1381
+5723,1197
+5742,1511
+5747,82312
+5763,1197
+5763,1381
+5767,133666
+5793,1511
+5804,1197
+5811,1381
+5828,133666
+5841,1197
+5841,1511
+5861,1381
+5882,1197
+5885,1511
+5887,133666
+5912,1381
+5924,1197
+5933,1511
+5947,133666
+5959,1381
+5963,1197
+5982,1511
+6003,1197
+6003,1381
+6007,133666
+6033,1511
+6044,1197
+6047,82312
+6051,1381
+6068,133666
+6081,1197
+6081,1511
+6101,1381
+6122,1197
+6125,1511
+6127,133666
+6152,1381
+6164,1197
+6173,1511
+6187,133666
+6199,1381
+6203,1197
+6222,1511
+6243,1197
+6243,1381
+6247,133666
+6273,1511
+6284,1197
+6291,1381
+6308,133666
+6321,1197
+6321,1511
+6341,1381
+6349,82312
+6362,1197
+6365,1511
+6367,133666
+6392,1381
+6404,1197
+6413,1511
+6427,133666
+6439,1381
+6443,1197
+6462,1511
+6483,1197
+6483,1381
+6487,133666
+6513,1511
+6524,1197
+6531,1381
+6548,133666
+6561,1197
+6561,1511
+6581,1381
+6602,1197
+6605,1511
+6607,133666
+6632,1381
+6644,1197
+6648,82312
+6653,1511
+6667,133666
+6679,1381
+6683,1197
+6702,1511
+6723,1197
+6723,1381
+6727,133666
+6753,1511
+6764,1197
+6771,1381
+6788,133666
+6801,1197
+6801,1511
+6821,1381
+6842,1197
+6845,1511
+6847,133666
+6872,1381
+6884,1197
+6893,1511
+6907,133666
+6919,1381
+6923,1197
+6942,1511
+6947,82312
+6963,1197
+6963,1381
+6967,133666
+6993,1511
+7004,1197
+7011,1381
+7028,133666
+7041,1197
+7041,1511
+7061,1381
+7082,1197
+7085,1511
+7087,133666
+7112,1381
+7124,1197
+7133,1511
+7147,133666
+7159,1381
+7163,1197
+7182,1511
+7203,1197
+7203,1381
+7207,133666
+7233,1511
+7244,1197
+7247,82312
+7251,1381
+7268,133666
+7281,1197
+7281,1511
+7301,1381
+7322,1197
+7325,1511
+7327,133666
+7352,1381
+7364,1197
+7373,1511
+7387,133666
+7399,1381
+7403,1197
+7422,1511
+7443,1197
+7443,1381
+7447,133666
+7473,1511
+7484,1197
+7491,1381
+7508,133666
+7521,1197
+7521,1511
+7541,1381
+7549,82312
+7562,1197
+7565,1511
+7567,133666
+7592,1381
+7604,1197
+7613,1511
+7627,133666
+7639,1381
+7643,1197
+7662,1511
+7683,1197
+7683,1381
+7687,133666
+7713,1511
+7724,1197
+7731,1381
+7748,133666
+7761,1197
+7761,1511
+7781,1381
+7802,1197
+7805,1511
+7807,133666
+7832,1381
+7844,1197
+7848,82312
+7853,1511
+7867,133666
+7879,1381
+7883,1197
+7902,1511
+7923,1197
+7923,1381
+7927,133666
+7953,1511
+7964,1197
+7971,1381
+7988,133666
+8001,1197
+8001,1511
+8021,1381
+8042,1197
+8045,1511
+8047,133666
+8072,1381
+8084,1197
+8093,1511
+8107,133666
+8119,1381
+8123,1197
+8142,1511
+8147,82312
+8163,1197
+8163,1381
+8167,133666
+8193,1511
+8204,1197
+8211,1381
+8228,133666
+8241,1197
+8241,1511
+8261,1381
+8282,1197
+8285,1511
+8287,133666
+8312,1381
+8324,1197
+8333,1511
+8347,133666
+8359,1381
+8363,1197
+8382,1511
+8403,1197
+8403,1381
+8407,133666
+8433,1511
+8444,1197
+8447,82312
+8451,1381
+8468,133666
+8481,1197
+8481,1511
+8501,1381
+8522,1197
+8525,1511
+8527,133666
+8552,1381
+8564,1197
+8573,1511
+8587,133666
+8599,1381
+8603,1197
+8622,1511
+8643,1197
+8643,1381
+8647,133666
+8673,1511
+8684,1197
+8691,1381
+8708,133666
+8721,1197
+8721,1511
+8741,1381
+8749,82312
+8762,1197
+8765,1511
+8767,133666
+8792,1381
+8804,1197
+8813,1511
+8827,133666
+8839,1381
+8843,1197
+8862,1511
+8883,1197
+8883,1381
+8887,133666
+8913,1511
+8924,1197
+8931,1381
+8948,133666
+8961,1197
+8961,1511
+8981,1381
+9002,1197
+9005,1511
+9007,133666
+9032,1381
+9044,1197
+9048,82312
+9053,1511
+9067,133666
+9079,1381
+9083,1197
+9102,1511
+9123,1197
+9123,1381
+9127,133666
+9153,1511
+9164,1197
+9171,1381
+9188,133666
+9201,1197
+9201,1511
+9221,1381
+9242,1197
+9245,1511
+9247,133666
+9272,1381
+9284,1197
+9293,1511
+9307,133666
+9319,1381
+9323,1197
+9342,1511
+9347,82312
+9363,1197
+9363,1381
+9367,133666
+9393,1511
+9404,1197
+9411,1381
+9428,133666
+9441,1197
+9441,1511
+9461,1381
+9482,1197
+9485,1511
+9487,133666
+9512,1381
+9524,1197
+9533,1511
+9547,133666
+9559,1381
+9563,1197
+9582,1511
+9603,1197
+9603,1381
+9607,133666
+9633,1511
+9644,1197
+9647,82312
+9651,1381
+9668,133666
+9681,1197
+9681,1511
+9701,1381
+9722,1197
+9725,1511
+9727,133666
+9752,1381
+9764,1197
+9773,1511
+9787,133666
+9799,1381
+9803,1197
+9822,1511
+9843,1197
+9843,1381
+9847,133666
+9873,1511
+9884,1197
+9891,1381
+9908,133666
+9921,1197
+9921,1511
+9941,1381
+9949,82312
+9962,1197
+9965,1511
+9967,133666
+9992,1381

registry/phase4ad-author-semantics/evidence/components/no_input-frozen/events.csv

@@ -0,0 +1 @@
+step,neuron_idx

registry/phase4ad-author-semantics/evidence/components/no_input-refractory_gate_only/events.csv

@@ -0,0 +1 @@
+step,neuron_idx

registry/phase4ad-author-semantics/evidence/components/no_input-reset_and_refractory/events.csv

@@ -0,0 +1 @@
+step,neuron_idx

registry/phase4ad-author-semantics/evidence/components/no_input-reset_g_only/events.csv

@@ -0,0 +1 @@
+step,neuron_idx

registry/phase4ad-author-semantics/evidence/components/pair-frozen/events.csv

@@ -0,0 +1,474 @@
+step,neuron_idx
+0,1381
+49,1511
+90,1381
+122,1511
+149,1381
+177,1511
+199,1381
+225,1511
+245,1381
+270,1511
+289,1381
+314,1511
+332,1381
+357,1511
+375,1381
+399,1511
+417,1381
+441,1511
+459,1381
+483,1511
+501,1381
+525,1511
+543,1381
+567,1511
+585,1381
+609,1511
+627,1381
+651,1511
+669,1381
+693,1511
+711,1381
+735,1511
+753,1381
+777,1511
+795,1381
+819,1511
+837,1381
+861,1511
+879,1381
+903,1511
+921,1381
+945,1511
+963,1381
+987,1511
+1005,1381
+1029,1511
+1047,1381
+1071,1511
+1089,1381
+1113,1511
+1131,1381
+1155,1511
+1173,1381
+1197,1511
+1215,1381
+1239,1511
+1257,1381
+1281,1511
+1299,1381
+1323,1511
+1341,1381
+1365,1511
+1383,1381
+1407,1511
+1425,1381
+1449,1511
+1467,1381
+1491,1511
+1509,1381
+1533,1511
+1551,1381
+1575,1511
+1593,1381
+1617,1511
+1635,1381
+1659,1511
+1677,1381
+1701,1511
+1719,1381
+1743,1511
+1761,1381
+1785,1511
+1803,1381
+1827,1511
+1845,1381
+1869,1511
+1887,1381
+1911,1511
+1929,1381
+1953,1511
+1971,1381
+1995,1511
+2013,1381
+2037,1511
+2055,1381
+2079,1511
+2097,1381
+2121,1511
+2139,1381
+2163,1511
+2181,1381
+2205,1511
+2223,1381
+2247,1511
+2265,1381
+2289,1511
+2307,1381
+2331,1511
+2349,1381
+2373,1511
+2391,1381
+2415,1511
+2433,1381
+2457,1511
+2475,1381
+2499,1511
+2517,1381
+2541,1511
+2559,1381
+2583,1511
+2601,1381
+2625,1511
+2643,1381
+2667,1511
+2685,1381
+2709,1511
+2727,1381
+2751,1511
+2769,1381
+2793,1511
+2811,1381
+2835,1511
+2853,1381
+2877,1511
+2895,1381
+2919,1511
+2937,1381
+2961,1511
+2979,1381
+3003,1511
+3021,1381
+3045,1511
+3063,1381
+3087,1511
+3105,1381
+3129,1511
+3147,1381
+3171,1511
+3189,1381
+3213,1511
+3231,1381
+3255,1511
+3273,1381
+3297,1511
+3315,1381
+3339,1511
+3357,1381
+3381,1511
+3399,1381
+3423,1511
+3441,1381
+3465,1511
+3483,1381
+3507,1511
+3525,1381
+3549,1511
+3567,1381
+3591,1511
+3609,1381
+3633,1511
+3651,1381
+3675,1511
+3693,1381
+3717,1511
+3735,1381
+3759,1511
+3777,1381
+3801,1511
+3819,1381
+3843,1511
+3861,1381
+3885,1511
+3903,1381
+3927,1511
+3945,1381
+3969,1511
+3987,1381
+4011,1511
+4029,1381
+4053,1511
+4071,1381
+4095,1511
+4113,1381
+4137,1511
+4155,1381
+4179,1511
+4197,1381
+4221,1511
+4239,1381
+4263,1511
+4281,1381
+4305,1511
+4323,1381
+4347,1511
+4365,1381
+4389,1511
+4407,1381
+4431,1511
+4449,1381
+4473,1511
+4491,1381
+4515,1511
+4533,1381
+4557,1511
+4575,1381
+4599,1511
+4617,1381
+4641,1511
+4659,1381
+4683,1511
+4701,1381
+4725,1511
+4743,1381
+4767,1511
+4785,1381
+4809,1511
+4827,1381
+4851,1511
+4869,1381
+4893,1511
+4911,1381
+4935,1511
+4953,1381
+4977,1511
+4995,1381
+5019,1511
+5037,1381
+5061,1511
+5079,1381
+5103,1511
+5121,1381
+5145,1511
+5163,1381
+5187,1511
+5205,1381
+5229,1511
+5247,1381
+5271,1511
+5289,1381
+5313,1511
+5331,1381
+5355,1511
+5373,1381
+5397,1511
+5415,1381
+5439,1511
+5457,1381
+5481,1511
+5499,1381
+5523,1511
+5541,1381
+5565,1511
+5583,1381
+5607,1511
+5625,1381
+5649,1511
+5667,1381
+5691,1511
+5709,1381
+5733,1511
+5751,1381
+5775,1511
+5793,1381
+5817,1511
+5835,1381
+5859,1511
+5877,1381
+5901,1511
+5919,1381
+5943,1511
+5961,1381
+5985,1511
+6003,1381
+6027,1511
+6045,1381
+6069,1511
+6087,1381
+6111,1511
+6129,1381
+6153,1511
+6171,1381
+6195,1511
+6213,1381
+6237,1511
+6255,1381
+6279,1511
+6297,1381
+6321,1511
+6339,1381
+6363,1511
+6381,1381
+6405,1511
+6423,1381
+6447,1511
+6465,1381
+6489,1511
+6507,1381
+6531,1511
+6549,1381
+6573,1511
+6591,1381
+6615,1511
+6633,1381
+6657,1511
+6675,1381
+6699,1511
+6717,1381
+6741,1511
+6759,1381
+6783,1511
+6801,1381
+6825,1511
+6843,1381
+6867,1511
+6885,1381
+6909,1511
+6927,1381
+6951,1511
+6969,1381
+6993,1511
+7011,1381
+7035,1511
+7053,1381
+7077,1511
+7095,1381
+7119,1511
+7137,1381
+7161,1511
+7179,1381
+7203,1511
+7221,1381
+7245,1511
+7263,1381
+7287,1511
+7305,1381
+7329,1511
+7347,1381
+7371,1511
+7389,1381
+7413,1511
+7431,1381
+7455,1511
+7473,1381
+7497,1511
+7515,1381
+7539,1511
+7557,1381
+7581,1511
+7599,1381
+7623,1511
+7641,1381
+7665,1511
+7683,1381
+7707,1511
+7725,1381
+7749,1511
+7767,1381
+7791,1511
+7809,1381
+7833,1511
+7851,1381
+7875,1511
+7893,1381
+7917,1511
+7935,1381
+7959,1511
+7977,1381
+8001,1511
+8019,1381
+8043,1511
+8061,1381
+8085,1511
+8103,1381
+8127,1511
+8145,1381
+8169,1511
+8187,1381
+8211,1511
+8229,1381
+8253,1511
+8271,1381
+8295,1511
+8313,1381
+8337,1511
+8355,1381
+8379,1511
+8397,1381
+8421,1511
+8439,1381
+8463,1511
+8481,1381
+8505,1511
+8523,1381
+8547,1511
+8565,1381
+8589,1511
+8607,1381
+8631,1511
+8649,1381
+8673,1511
+8691,1381
+8715,1511
+8733,1381
+8757,1511
+8775,1381
+8799,1511
+8817,1381
+8841,1511
+8859,1381
+8883,1511
+8901,1381
+8925,1511
+8943,1381
+8967,1511
+8985,1381
+9009,1511
+9027,1381
+9051,1511
+9069,1381
+9093,1511
+9111,1381
+9135,1511
+9153,1381
+9177,1511
+9195,1381
+9219,1511
+9237,1381
+9261,1511
+9279,1381
+9303,1511
+9321,1381
+9345,1511
+9363,1381
+9387,1511
+9405,1381
+9429,1511
+9447,1381
+9471,1511
+9489,1381
+9513,1511
+9531,1381
+9555,1511
+9573,1381
+9597,1511
+9615,1381
+9639,1511
+9657,1381
+9681,1511
+9699,1381
+9723,1511
+9741,1381
+9765,1511
+9783,1381
+9807,1511
+9825,1381
+9849,1511
+9867,1381
+9891,1511
+9909,1381
+9933,1511
+9951,1381
+9975,1511
+9993,1381

registry/phase4ad-author-semantics/evidence/components/pair-refractory_gate_only/events.csv

@@ -0,0 +1,636 @@
+step,neuron_idx
+0,1381
+49,1511
+90,1381
+116,1511
+139,1381
+160,1511
+178,1381
+197,1511
+211,1381
+230,1511
+247,1381
+261,1511
+283,1381
+294,1511
+314,1381
+331,1511
+344,1381
+368,1511
+376,1381
+400,1511
+411,1381
+431,1511
+450,1381
+461,1511
+481,1381
+493,1511
+511,1381
+528,1511
+539,1381
+563,1511
+568,1381
+593,1511
+599,1381
+622,1511
+632,1381
+651,1511
+669,1381
+679,1511
+699,1381
+708,1511
+727,1381
+739,1511
+754,1381
+772,1511
+782,1381
+802,1511
+811,1381
+830,1511
+842,1381
+858,1511
+875,1381
+887,1511
+908,1381
+917,1511
+938,1381
+949,1511
+967,1381
+985,1511
+995,1381
+1015,1511
+1024,1381
+1044,1511
+1054,1381
+1072,1511
+1086,1381
+1099,1511
+1119,1381
+1127,1511
+1148,1381
+1156,1511
+1176,1381
+1187,1511
+1203,1381
+1220,1511
+1231,1381
+1253,1511
+1260,1381
+1283,1511
+1291,1381
+1312,1511
+1324,1381
+1341,1511
+1360,1381
+1371,1511
+1390,1381
+1403,1511
+1419,1381
+1438,1511
+1449,1381
+1469,1511
+1481,1381
+1499,1511
+1517,1381
+1527,1511
+1547,1381
+1557,1511
+1575,1381
+1588,1511
+1602,1381
+1621,1511
+1630,1381
+1651,1511
+1659,1381
+1679,1511
+1690,1381
+1707,1511
+1723,1381
+1736,1511
+1757,1381
+1767,1511
+1787,1381
+1800,1511
+1816,1381
+1835,1511
+1846,1381
+1866,1511
+1879,1381
+1896,1511
+1914,1381
+1928,1511
+1945,1381
+1963,1511
+1979,1381
+1995,1511
+2015,1381
+2030,1511
+2047,1381
+2067,1511
+2082,1381
+2100,1511
+2120,1381
+2131,1511
+2151,1381
+2165,1511
+2181,1381
+2201,1511
+2213,1381
+2233,1511
+2248,1381
+2264,1511
+2285,1381
+2297,1511
+2317,1381
+2334,1511
+2347,1381
+2371,1511
+2379,1381
+2403,1511
+2414,1381
+2434,1511
+2453,1381
+2464,1511
+2484,1381
+2496,1511
+2514,1381
+2531,1511
+2542,1381
+2566,1511
+2571,1381
+2596,1511
+2602,1381
+2625,1511
+2635,1381
+2654,1511
+2672,1381
+2682,1511
+2702,1381
+2711,1511
+2730,1381
+2742,1511
+2757,1381
+2775,1511
+2785,1381
+2805,1511
+2814,1381
+2833,1511
+2845,1381
+2861,1511
+2878,1381
+2890,1511
+2911,1381
+2920,1511
+2941,1381
+2952,1511
+2970,1381
+2988,1511
+2998,1381
+3018,1511
+3027,1381
+3047,1511
+3057,1381
+3075,1511
+3089,1381
+3102,1511
+3122,1381
+3130,1511
+3151,1381
+3159,1511
+3179,1381
+3190,1511
+3206,1381
+3223,1511
+3234,1381
+3256,1511
+3263,1381
+3286,1511
+3294,1381
+3315,1511
+3327,1381
+3344,1511
+3363,1381
+3374,1511
+3393,1381
+3406,1511
+3422,1381
+3441,1511
+3452,1381
+3472,1511
+3484,1381
+3502,1511
+3520,1381
+3530,1511
+3550,1381
+3560,1511
+3578,1381
+3591,1511
+3605,1381
+3624,1511
+3633,1381
+3654,1511
+3662,1381
+3682,1511
+3693,1381
+3710,1511
+3726,1381
+3739,1511
+3760,1381
+3770,1511
+3790,1381
+3803,1511
+3819,1381
+3838,1511
+3849,1381
+3869,1511
+3882,1381
+3899,1511
+3917,1381
+3931,1511
+3948,1381
+3966,1511
+3982,1381
+3998,1511
+4018,1381
+4033,1511
+4050,1381
+4070,1511
+4085,1381
+4103,1511
+4123,1381
+4134,1511
+4154,1381
+4168,1511
+4184,1381
+4204,1511
+4216,1381
+4236,1511
+4251,1381
+4267,1511
+4288,1381
+4300,1511
+4320,1381
+4337,1511
+4350,1381
+4374,1511
+4382,1381
+4406,1511
+4417,1381
+4437,1511
+4456,1381
+4467,1511
+4487,1381
+4499,1511
+4517,1381
+4534,1511
+4545,1381
+4569,1511
+4574,1381
+4599,1511
+4605,1381
+4628,1511
+4638,1381
+4657,1511
+4675,1381
+4685,1511
+4705,1381
+4714,1511
+4733,1381
+4745,1511
+4760,1381
+4778,1511
+4788,1381
+4808,1511
+4817,1381
+4836,1511
+4848,1381
+4864,1511
+4881,1381
+4893,1511
+4914,1381
+4923,1511
+4944,1381
+4955,1511
+4973,1381
+4991,1511
+5001,1381
+5021,1511
+5030,1381
+5050,1511
+5060,1381
+5078,1511
+5092,1381
+5105,1511
+5125,1381
+5133,1511
+5154,1381
+5162,1511
+5182,1381
+5193,1511
+5209,1381
+5226,1511
+5237,1381
+5259,1511
+5266,1381
+5289,1511
+5297,1381
+5318,1511
+5330,1381
+5347,1511
+5366,1381
+5377,1511
+5396,1381
+5409,1511
+5425,1381
+5444,1511
+5455,1381
+5475,1511
+5487,1381
+5505,1511
+5523,1381
+5533,1511
+5553,1381
+5563,1511
+5581,1381
+5594,1511
+5608,1381
+5627,1511
+5636,1381
+5657,1511
+5665,1381
+5685,1511
+5696,1381
+5713,1511
+5729,1381
+5742,1511
+5763,1381
+5773,1511
+5793,1381
+5806,1511
+5822,1381
+5841,1511
+5852,1381
+5872,1511
+5885,1381
+5902,1511
+5920,1381
+5934,1511
+5951,1381
+5969,1511
+5985,1381
+6001,1511
+6021,1381
+6036,1511
+6053,1381
+6073,1511
+6088,1381
+6106,1511
+6126,1381
+6137,1511
+6157,1381
+6171,1511
+6187,1381
+6207,1511
+6219,1381
+6239,1511
+6254,1381
+6270,1511
+6291,1381
+6303,1511
+6323,1381
+6340,1511
+6353,1381
+6377,1511
+6385,1381
+6409,1511
+6420,1381
+6440,1511
+6459,1381
+6470,1511
+6490,1381
+6502,1511
+6520,1381
+6537,1511
+6548,1381
+6572,1511
+6577,1381
+6602,1511
+6608,1381
+6631,1511
+6641,1381
+6660,1511
+6678,1381
+6688,1511
+6708,1381
+6717,1511
+6736,1381
+6748,1511
+6763,1381
+6781,1511
+6791,1381
+6811,1511
+6820,1381
+6839,1511
+6851,1381
+6867,1511
+6884,1381
+6896,1511
+6917,1381
+6926,1511
+6947,1381
+6958,1511
+6976,1381
+6994,1511
+7004,1381
+7024,1511
+7033,1381
+7053,1511
+7063,1381
+7081,1511
+7095,1381
+7108,1511
+7128,1381
+7136,1511
+7157,1381
+7165,1511
+7185,1381
+7196,1511
+7212,1381
+7229,1511
+7240,1381
+7262,1511
+7269,1381
+7292,1511
+7300,1381
+7321,1511
+7333,1381
+7350,1511
+7369,1381
+7380,1511
+7399,1381
+7412,1511
+7428,1381
+7447,1511
+7458,1381
+7478,1511
+7490,1381
+7508,1511
+7526,1381
+7536,1511
+7556,1381
+7566,1511
+7584,1381
+7597,1511
+7611,1381
+7630,1511
+7639,1381
+7660,1511
+7668,1381
+7688,1511
+7699,1381
+7716,1511
+7732,1381
+7745,1511
+7766,1381
+7776,1511
+7796,1381
+7809,1511
+7825,1381
+7844,1511
+7855,1381
+7875,1511
+7888,1381
+7905,1511
+7923,1381
+7937,1511
+7954,1381
+7972,1511
+7988,1381
+8004,1511
+8024,1381
+8039,1511
+8056,1381
+8076,1511
+8091,1381
+8109,1511
+8129,1381
+8140,1511
+8160,1381
+8174,1511
+8190,1381
+8210,1511
+8222,1381
+8242,1511
+8257,1381
+8273,1511
+8294,1381
+8306,1511
+8326,1381
+8343,1511
+8356,1381
+8380,1511
+8388,1381
+8412,1511
+8423,1381
+8443,1511
+8462,1381
+8473,1511
+8493,1381
+8505,1511
+8523,1381
+8540,1511
+8551,1381
+8575,1511
+8580,1381
+8605,1511
+8611,1381
+8634,1511
+8644,1381
+8663,1511
+8681,1381
+8691,1511
+8711,1381
+8720,1511
+8739,1381
+8751,1511
+8766,1381
+8784,1511
+8794,1381
+8814,1511
+8823,1381
+8842,1511
+8854,1381
+8870,1511
+8887,1381
+8899,1511
+8920,1381
+8929,1511
+8950,1381
+8961,1511
+8979,1381
+8997,1511
+9007,1381
+9027,1511
+9036,1381
+9056,1511
+9066,1381
+9084,1511
+9098,1381
+9111,1511
+9131,1381
+9139,1511
+9160,1381
+9168,1511
+9188,1381
+9199,1511
+9215,1381
+9232,1511
+9243,1381
+9265,1511
+9272,1381
+9295,1511
+9303,1381
+9324,1511
+9336,1381
+9353,1511
+9372,1381
+9383,1511
+9402,1381
+9415,1511
+9431,1381
+9450,1511
+9461,1381
+9481,1511
+9493,1381
+9511,1511
+9529,1381
+9539,1511
+9559,1381
+9569,1511
+9587,1381
+9600,1511
+9614,1381
+9633,1511
+9642,1381
+9663,1511
+9671,1381
+9691,1511
+9702,1381
+9719,1511
+9735,1381
+9748,1511
+9769,1381
+9779,1511
+9799,1381
+9812,1511
+9828,1381
+9847,1511
+9858,1381
+9878,1511
+9891,1381
+9908,1511
+9926,1381
+9940,1511
+9957,1381
+9975,1511
+9991,1381

registry/phase4ad-author-semantics/evidence/components/pair-reset_and_refractory/events.csv

@@ -0,0 +1,224 @@
+step,neuron_idx
+0,1381
+49,1511
+90,1381
+139,1511
+180,1381
+229,1511
+270,1381
+319,1511
+360,1381
+409,1511
+450,1381
+499,1511
+540,1381
+589,1511
+630,1381
+679,1511
+720,1381
+769,1511
+810,1381
+859,1511
+900,1381
+949,1511
+990,1381
+1039,1511
+1080,1381
+1129,1511
+1170,1381
+1219,1511
+1260,1381
+1309,1511
+1350,1381
+1399,1511
+1440,1381
+1489,1511
+1530,1381
+1579,1511
+1620,1381
+1669,1511
+1710,1381
+1759,1511
+1800,1381
+1849,1511
+1890,1381
+1939,1511
+1980,1381
+2029,1511
+2070,1381
+2119,1511
+2160,1381
+2209,1511
+2250,1381
+2299,1511
+2340,1381
+2389,1511
+2430,1381
+2479,1511
+2520,1381
+2569,1511
+2610,1381
+2659,1511
+2700,1381
+2749,1511
+2790,1381
+2839,1511
+2880,1381
+2929,1511
+2970,1381
+3019,1511
+3060,1381
+3109,1511
+3150,1381
+3199,1511
+3240,1381
+3289,1511
+3330,1381
+3379,1511
+3420,1381
+3469,1511
+3510,1381
+3559,1511
+3600,1381
+3649,1511
+3690,1381
+3739,1511
+3780,1381
+3829,1511
+3870,1381
+3919,1511
+3960,1381
+4009,1511
+4050,1381
+4099,1511
+4140,1381
+4189,1511
+4230,1381
+4279,1511
+4320,1381
+4369,1511
+4410,1381
+4459,1511
+4500,1381
+4549,1511
+4590,1381
+4639,1511
+4680,1381
+4729,1511
+4770,1381
+4819,1511
+4860,1381
+4909,1511
+4950,1381
+4999,1511
+5040,1381
+5089,1511
+5130,1381
+5179,1511
+5220,1381
+5269,1511
+5310,1381
+5359,1511
+5400,1381
+5449,1511
+5490,1381
+5539,1511
+5580,1381
+5629,1511
+5670,1381
+5719,1511
+5760,1381
+5809,1511
+5850,1381
+5899,1511
+5940,1381
+5989,1511
+6030,1381
+6079,1511
+6120,1381
+6169,1511
+6210,1381
+6259,1511
+6300,1381
+6349,1511
+6390,1381
+6439,1511
+6480,1381
+6529,1511
+6570,1381
+6619,1511
+6660,1381
+6709,1511
+6750,1381
+6799,1511
+6840,1381
+6889,1511
+6930,1381
+6979,1511
+7020,1381
+7069,1511
+7110,1381
+7159,1511
+7200,1381
+7249,1511
+7290,1381
+7339,1511
+7380,1381
+7429,1511
+7470,1381
+7519,1511
+7560,1381
+7609,1511
+7650,1381
+7699,1511
+7740,1381
+7789,1511
+7830,1381
+7879,1511
+7920,1381
+7969,1511
+8010,1381
+8059,1511
+8100,1381
+8149,1511
+8190,1381
+8239,1511
+8280,1381
+8329,1511
+8370,1381
+8419,1511
+8460,1381
+8509,1511
+8550,1381
+8599,1511
+8640,1381
+8689,1511
+8730,1381
+8779,1511
+8820,1381
+8869,1511
+8910,1381
+8959,1511
+9000,1381
+9049,1511
+9090,1381
+9139,1511
+9180,1381
+9229,1511
+9270,1381
+9319,1511
+9360,1381
+9409,1511
+9450,1381
+9499,1511
+9540,1381
+9589,1511
+9630,1381
+9679,1511
+9720,1381
+9769,1511
+9810,1381
+9859,1511
+9900,1381
+9949,1511
+9990,1381

registry/phase4ad-author-semantics/evidence/components/pair-reset_g_only/events.csv

@@ -0,0 +1,224 @@
+step,neuron_idx
+0,1381
+49,1511
+90,1381
+139,1511
+180,1381
+229,1511
+270,1381
+319,1511
+360,1381
+409,1511
+450,1381
+499,1511
+540,1381
+589,1511
+630,1381
+679,1511
+720,1381
+769,1511
+810,1381
+859,1511
+900,1381
+949,1511
+990,1381
+1039,1511
+1080,1381
+1129,1511
+1170,1381
+1219,1511
+1260,1381
+1309,1511
+1350,1381
+1399,1511
+1440,1381
+1489,1511
+1530,1381
+1579,1511
+1620,1381
+1669,1511
+1710,1381
+1759,1511
+1800,1381
+1849,1511
+1890,1381
+1939,1511
+1980,1381
+2029,1511
+2070,1381
+2119,1511
+2160,1381
+2209,1511
+2250,1381
+2299,1511
+2340,1381
+2389,1511
+2430,1381
+2479,1511
+2520,1381
+2569,1511
+2610,1381
+2659,1511
+2700,1381
+2749,1511
+2790,1381
+2839,1511
+2880,1381
+2929,1511
+2970,1381
+3019,1511
+3060,1381
+3109,1511
+3150,1381
+3199,1511
+3240,1381
+3289,1511
+3330,1381
+3379,1511
+3420,1381
+3469,1511
+3510,1381
+3559,1511
+3600,1381
+3649,1511
+3690,1381
+3739,1511
+3780,1381
+3829,1511
+3870,1381
+3919,1511
+3960,1381
+4009,1511
+4050,1381
+4099,1511
+4140,1381
+4189,1511
+4230,1381
+4279,1511
+4320,1381
+4369,1511
+4410,1381
+4459,1511
+4500,1381
+4549,1511
+4590,1381
+4639,1511
+4680,1381
+4729,1511
+4770,1381
+4819,1511
+4860,1381
+4909,1511
+4950,1381
+4999,1511
+5040,1381
+5089,1511
+5130,1381
+5179,1511
+5220,1381
+5269,1511
+5310,1381
+5359,1511
+5400,1381
+5449,1511
+5490,1381
+5539,1511
+5580,1381
+5629,1511
+5670,1381
+5719,1511
+5760,1381
+5809,1511
+5850,1381
+5899,1511
+5940,1381
+5989,1511
+6030,1381
+6079,1511
+6120,1381
+6169,1511
+6210,1381
+6259,1511
+6300,1381
+6349,1511
+6390,1381
+6439,1511
+6480,1381
+6529,1511
+6570,1381
+6619,1511
+6660,1381
+6709,1511
+6750,1381
+6799,1511
+6840,1381
+6889,1511
+6930,1381
+6979,1511
+7020,1381
+7069,1511
+7110,1381
+7159,1511
+7200,1381
+7249,1511
+7290,1381
+7339,1511
+7380,1381
+7429,1511
+7470,1381
+7519,1511
+7560,1381
+7609,1511
+7650,1381
+7699,1511
+7740,1381
+7789,1511
+7830,1381
+7879,1511
+7920,1381
+7969,1511
+8010,1381
+8059,1511
+8100,1381
+8149,1511
+8190,1381
+8239,1511
+8280,1381
+8329,1511
+8370,1381
+8419,1511
+8460,1381
+8509,1511
+8550,1381
+8599,1511
+8640,1381
+8689,1511
+8730,1381
+8779,1511
+8820,1381
+8869,1511
+8910,1381
+8959,1511
+9000,1381
+9049,1511
+9090,1381
+9139,1511
+9180,1381
+9229,1511
+9270,1381
+9319,1511
+9360,1381
+9409,1511
+9450,1381
+9499,1511
+9540,1381
+9589,1511
+9630,1381
+9679,1511
+9720,1381
+9769,1511
+9810,1381
+9859,1511
+9900,1381
+9949,1511
+9990,1381

registry/phase4ad-author-semantics/evidence/components/summary.csv

@@ -0,0 +1,81 @@
+motif,policy,precision,neuron_idx,spikes,late_spikes,last_ms
+pair,frozen,float32,1381,237,119,999.3000000000001
+pair,frozen,float32,1511,236,119,997.5
+pair,reset_g_only,float32,1381,112,56,999.0
+pair,reset_g_only,float32,1511,111,55,994.9000000000001
+pair,refractory_gate_only,float32,1381,318,161,999.1
+pair,refractory_gate_only,float32,1511,317,160,997.5
+pair,reset_and_refractory,float32,1381,112,56,999.0
+pair,reset_and_refractory,float32,1511,111,55,994.9000000000001
+trio,frozen,float32,1197,355,179,999.3000000000001
+trio,frozen,float32,1381,355,178,997.8000000000001
+trio,frozen,float32,1511,354,178,997.4000000000001
+trio,reset_g_only,float32,1197,188,94,995.4000000000001
+trio,reset_g_only,float32,1381,189,95,998.7
+trio,reset_g_only,float32,1511,188,94,996.1
+trio,refractory_gate_only,float32,1197,369,185,998.3000000000001
+trio,refractory_gate_only,float32,1381,367,184,999.1
+trio,refractory_gate_only,float32,1511,364,183,997.2
+trio,reset_and_refractory,float32,1197,156,78,995.3000000000001
+trio,reset_and_refractory,float32,1381,157,79,999.6
+trio,reset_and_refractory,float32,1511,156,78,997.5
+five,frozen,float32,1197,370,185,998.8000000000001
+five,frozen,float32,1381,369,185,997.4000000000001
+five,frozen,float32,1511,367,186,999.5
+five,frozen,float32,82312,80,41,990.3000000000001
+five,frozen,float32,133666,297,150,999.5
+five,reset_g_only,float32,1197,249,125,996.2
+five,reset_g_only,float32,1381,211,104,999.2
+five,reset_g_only,float32,1511,209,104,996.5
+five,reset_g_only,float32,82312,33,17,994.9000000000001
+five,reset_g_only,float32,133666,166,83,996.7
+five,refractory_gate_only,float32,1197,372,188,998.0
+five,refractory_gate_only,float32,1381,375,191,998.6
+five,refractory_gate_only,float32,1511,371,187,997.5
+five,refractory_gate_only,float32,82312,85,43,991.9000000000001
+five,refractory_gate_only,float32,133666,307,154,997.7
+five,reset_and_refractory,float32,1197,165,82,995.7
+five,reset_and_refractory,float32,1381,166,83,999.8000000000001
+five,reset_and_refractory,float32,1511,165,83,997.5
+five,reset_and_refractory,float32,82312,15,8,972.7
+five,reset_and_refractory,float32,133666,123,62,993.0
+feedforward,frozen,float32,1197,1,0,10.0
+feedforward,frozen,float32,1381,1,0,0.0
+feedforward,frozen,float32,1511,1,0,4.9
+feedforward,frozen,float32,82312,0,0,
+feedforward,frozen,float32,133666,0,0,
+feedforward,reset_g_only,float32,1197,1,0,10.0
+feedforward,reset_g_only,float32,1381,1,0,0.0
+feedforward,reset_g_only,float32,1511,1,0,4.9
+feedforward,reset_g_only,float32,82312,0,0,
+feedforward,reset_g_only,float32,133666,0,0,
+feedforward,refractory_gate_only,float32,1197,1,0,10.0
+feedforward,refractory_gate_only,float32,1381,1,0,0.0
+feedforward,refractory_gate_only,float32,1511,1,0,4.9
+feedforward,refractory_gate_only,float32,82312,0,0,
+feedforward,refractory_gate_only,float32,133666,0,0,
+feedforward,reset_and_refractory,float32,1197,1,0,10.0
+feedforward,reset_and_refractory,float32,1381,1,0,0.0
+feedforward,reset_and_refractory,float32,1511,1,0,4.9
+feedforward,reset_and_refractory,float32,82312,0,0,
+feedforward,reset_and_refractory,float32,133666,0,0,
+no_input,frozen,float32,1197,0,0,
+no_input,frozen,float32,1381,0,0,
+no_input,frozen,float32,1511,0,0,
+no_input,frozen,float32,82312,0,0,
+no_input,frozen,float32,133666,0,0,
+no_input,reset_g_only,float32,1197,0,0,
+no_input,reset_g_only,float32,1381,0,0,
+no_input,reset_g_only,float32,1511,0,0,
+no_input,reset_g_only,float32,82312,0,0,
+no_input,reset_g_only,float32,133666,0,0,
+no_input,refractory_gate_only,float32,1197,0,0,
+no_input,refractory_gate_only,float32,1381,0,0,
+no_input,refractory_gate_only,float32,1511,0,0,
+no_input,refractory_gate_only,float32,82312,0,0,
+no_input,refractory_gate_only,float32,133666,0,0,
+no_input,reset_and_refractory,float32,1197,0,0,
+no_input,reset_and_refractory,float32,1381,0,0,
+no_input,reset_and_refractory,float32,1511,0,0,
+no_input,reset_and_refractory,float32,82312,0,0,
+no_input,reset_and_refractory,float32,133666,0,0,

registry/phase4ad-author-semantics/evidence/components/trio-reset_and_refractory/events.csv

@@ -0,0 +1,470 @@
+step,neuron_idx
+0,1381
+45,1197
+49,1511
+77,1381
+96,1197
+119,1511
+140,1381
+161,1197
+183,1511
+204,1381
+225,1197
+247,1511
+268,1381
+289,1197
+311,1511
+332,1381
+353,1197
+375,1511
+396,1381
+417,1197
+439,1511
+460,1381
+481,1197
+503,1511
+524,1381
+545,1197
+567,1511
+588,1381
+609,1197
+631,1511
+652,1381
+673,1197
+695,1511
+716,1381
+737,1197
+759,1511
+780,1381
+801,1197
+823,1511
+844,1381
+865,1197
+887,1511
+908,1381
+929,1197
+951,1511
+972,1381
+993,1197
+1015,1511
+1036,1381
+1057,1197
+1079,1511
+1100,1381
+1121,1197
+1143,1511
+1164,1381
+1185,1197
+1207,1511
+1228,1381
+1249,1197
+1271,1511
+1292,1381
+1313,1197
+1335,1511
+1356,1381
+1377,1197
+1399,1511
+1420,1381
+1441,1197
+1463,1511
+1484,1381
+1505,1197
+1527,1511
+1548,1381
+1569,1197
+1591,1511
+1612,1381
+1633,1197
+1655,1511
+1676,1381
+1697,1197
+1719,1511
+1740,1381
+1761,1197
+1783,1511
+1804,1381
+1825,1197
+1847,1511
+1868,1381
+1889,1197
+1911,1511
+1932,1381
+1953,1197
+1975,1511
+1996,1381
+2017,1197
+2039,1511
+2060,1381
+2081,1197
+2103,1511
+2124,1381
+2145,1197
+2167,1511
+2188,1381
+2209,1197
+2231,1511
+2252,1381
+2273,1197
+2295,1511
+2316,1381
+2337,1197
+2359,1511
+2380,1381
+2401,1197
+2423,1511
+2444,1381
+2465,1197
+2487,1511
+2508,1381
+2529,1197
+2551,1511
+2572,1381
+2593,1197
+2615,1511
+2636,1381
+2657,1197
+2679,1511
+2700,1381
+2721,1197
+2743,1511
+2764,1381
+2785,1197
+2807,1511
+2828,1381
+2849,1197
+2871,1511
+2892,1381
+2913,1197
+2935,1511
+2956,1381
+2977,1197
+2999,1511
+3020,1381
+3041,1197
+3063,1511
+3084,1381
+3105,1197
+3127,1511
+3148,1381
+3169,1197
+3191,1511
+3212,1381
+3233,1197
+3255,1511
+3276,1381
+3297,1197
+3319,1511
+3340,1381
+3361,1197
+3383,1511
+3404,1381
+3425,1197
+3447,1511
+3468,1381
+3489,1197
+3511,1511
+3532,1381
+3553,1197
+3575,1511
+3596,1381
+3617,1197
+3639,1511
+3660,1381
+3681,1197
+3703,1511
+3724,1381
+3745,1197
+3767,1511
+3788,1381
+3809,1197
+3831,1511
+3852,1381
+3873,1197
+3895,1511
+3916,1381
+3937,1197
+3959,1511
+3980,1381
+4001,1197
+4023,1511
+4044,1381
+4065,1197
+4087,1511
+4108,1381
+4129,1197
+4151,1511
+4172,1381
+4193,1197
+4215,1511
+4236,1381
+4257,1197
+4279,1511
+4300,1381
+4321,1197
+4343,1511
+4364,1381
+4385,1197
+4407,1511
+4428,1381
+4449,1197
+4471,1511
+4492,1381
+4513,1197
+4535,1511
+4556,1381
+4577,1197
+4599,1511
+4620,1381
+4641,1197
+4663,1511
+4684,1381
+4705,1197
+4727,1511
+4748,1381
+4769,1197
+4791,1511
+4812,1381
+4833,1197
+4855,1511
+4876,1381
+4897,1197
+4919,1511
+4940,1381
+4961,1197
+4983,1511
+5004,1381
+5025,1197
+5047,1511
+5068,1381
+5089,1197
+5111,1511
+5132,1381
+5153,1197
+5175,1511
+5196,1381
+5217,1197
+5239,1511
+5260,1381
+5281,1197
+5303,1511
+5324,1381
+5345,1197
+5367,1511
+5388,1381
+5409,1197
+5431,1511
+5452,1381
+5473,1197
+5495,1511
+5516,1381
+5537,1197
+5559,1511
+5580,1381
+5601,1197
+5623,1511
+5644,1381
+5665,1197
+5687,1511
+5708,1381
+5729,1197
+5751,1511
+5772,1381
+5793,1197
+5815,1511
+5836,1381
+5857,1197
+5879,1511
+5900,1381
+5921,1197
+5943,1511
+5964,1381
+5985,1197
+6007,1511
+6028,1381
+6049,1197
+6071,1511
+6092,1381
+6113,1197
+6135,1511
+6156,1381
+6177,1197
+6199,1511
+6220,1381
+6241,1197
+6263,1511
+6284,1381
+6305,1197
+6327,1511
+6348,1381
+6369,1197
+6391,1511
+6412,1381
+6433,1197
+6455,1511
+6476,1381
+6497,1197
+6519,1511
+6540,1381
+6561,1197
+6583,1511
+6604,1381
+6625,1197
+6647,1511
+6668,1381
+6689,1197
+6711,1511
+6732,1381
+6753,1197
+6775,1511
+6796,1381
+6817,1197
+6839,1511
+6860,1381
+6881,1197
+6903,1511
+6924,1381
+6945,1197
+6967,1511
+6988,1381
+7009,1197
+7031,1511
+7052,1381
+7073,1197
+7095,1511
+7116,1381
+7137,1197
+7159,1511
+7180,1381
+7201,1197
+7223,1511
+7244,1381
+7265,1197
+7287,1511
+7308,1381
+7329,1197
+7351,1511
+7372,1381
+7393,1197
+7415,1511
+7436,1381
+7457,1197
+7479,1511
+7500,1381
+7521,1197
+7543,1511
+7564,1381
+7585,1197
+7607,1511
+7628,1381
+7649,1197
+7671,1511
+7692,1381
+7713,1197
+7735,1511
+7756,1381
+7777,1197
+7799,1511
+7820,1381
+7841,1197
+7863,1511
+7884,1381
+7905,1197
+7927,1511
+7948,1381
+7969,1197
+7991,1511
+8012,1381
+8033,1197
+8055,1511
+8076,1381
+8097,1197
+8119,1511
+8140,1381
+8161,1197
+8183,1511
+8204,1381
+8225,1197
+8247,1511
+8268,1381
+8289,1197
+8311,1511
+8332,1381
+8353,1197
+8375,1511
+8396,1381
+8417,1197
+8439,1511
+8460,1381
+8481,1197
+8503,1511
+8524,1381
+8545,1197
+8567,1511
+8588,1381
+8609,1197
+8631,1511
+8652,1381
+8673,1197
+8695,1511
+8716,1381
+8737,1197
+8759,1511
+8780,1381
+8801,1197
+8823,1511
+8844,1381
+8865,1197
+8887,1511
+8908,1381
+8929,1197
+8951,1511
+8972,1381
+8993,1197
+9015,1511
+9036,1381
+9057,1197
+9079,1511
+9100,1381
+9121,1197
+9143,1511
+9164,1381
+9185,1197
+9207,1511
+9228,1381
+9249,1197
+9271,1511
+9292,1381
+9313,1197
+9335,1511
+9356,1381
+9377,1197
+9399,1511
+9420,1381
+9441,1197
+9463,1511
+9484,1381
+9505,1197
+9527,1511
+9548,1381
+9569,1197
+9591,1511
+9612,1381
+9633,1197
+9655,1511
+9676,1381
+9697,1197
+9719,1511
+9740,1381
+9761,1197
+9783,1511
+9804,1381
+9825,1197
+9847,1511
+9868,1381
+9889,1197
+9911,1511
+9932,1381
+9953,1197
+9975,1511
+9996,1381

registry/phase4ad-author-semantics/evidence/components/trio-reset_g_only/events.csv

@@ -0,0 +1,566 @@
+step,neuron_idx
+0,1381
+45,1197
+49,1511
+77,1381
+96,1197
+103,1511
+129,1381
+149,1197
+156,1511
+182,1381
+202,1197
+209,1511
+235,1381
+255,1197
+262,1511
+288,1381
+308,1197
+315,1511
+341,1381
+361,1197
+368,1511
+394,1381
+414,1197
+421,1511
+447,1381
+467,1197
+474,1511
+500,1381
+520,1197
+527,1511
+553,1381
+573,1197
+580,1511
+606,1381
+626,1197
+633,1511
+659,1381
+679,1197
+686,1511
+712,1381
+732,1197
+739,1511
+765,1381
+785,1197
+792,1511
+818,1381
+838,1197
+845,1511
+871,1381
+891,1197
+898,1511
+924,1381
+944,1197
+951,1511
+977,1381
+997,1197
+1004,1511
+1030,1381
+1050,1197
+1057,1511
+1083,1381
+1103,1197
+1110,1511
+1136,1381
+1156,1197
+1163,1511
+1189,1381
+1209,1197
+1216,1511
+1242,1381
+1262,1197
+1269,1511
+1295,1381
+1315,1197
+1322,1511
+1348,1381
+1368,1197
+1375,1511
+1401,1381
+1421,1197
+1428,1511
+1454,1381
+1474,1197
+1481,1511
+1507,1381
+1527,1197
+1534,1511
+1560,1381
+1580,1197
+1587,1511
+1613,1381
+1633,1197
+1640,1511
+1666,1381
+1686,1197
+1693,1511
+1719,1381
+1739,1197
+1746,1511
+1772,1381
+1792,1197
+1799,1511
+1825,1381
+1845,1197
+1852,1511
+1878,1381
+1898,1197
+1905,1511
+1931,1381
+1951,1197
+1958,1511
+1984,1381
+2004,1197
+2011,1511
+2037,1381
+2057,1197
+2064,1511
+2090,1381
+2110,1197
+2117,1511
+2143,1381
+2163,1197
+2170,1511
+2196,1381
+2216,1197
+2223,1511
+2249,1381
+2269,1197
+2276,1511
+2302,1381
+2322,1197
+2329,1511
+2355,1381
+2375,1197
+2382,1511
+2408,1381
+2428,1197
+2435,1511
+2461,1381
+2481,1197
+2488,1511
+2514,1381
+2534,1197
+2541,1511
+2567,1381
+2587,1197
+2594,1511
+2620,1381
+2640,1197
+2647,1511
+2673,1381
+2693,1197
+2700,1511
+2726,1381
+2746,1197
+2753,1511
+2779,1381
+2799,1197
+2806,1511
+2832,1381
+2852,1197
+2859,1511
+2885,1381
+2905,1197
+2912,1511
+2938,1381
+2958,1197
+2965,1511
+2991,1381
+3011,1197
+3018,1511
+3044,1381
+3064,1197
+3071,1511
+3097,1381
+3117,1197
+3124,1511
+3150,1381
+3170,1197
+3177,1511
+3203,1381
+3223,1197
+3230,1511
+3256,1381
+3276,1197
+3283,1511
+3309,1381
+3329,1197
+3336,1511
+3362,1381
+3382,1197
+3389,1511
+3415,1381
+3435,1197
+3442,1511
+3468,1381
+3488,1197
+3495,1511
+3521,1381
+3541,1197
+3548,1511
+3574,1381
+3594,1197
+3601,1511
+3627,1381
+3647,1197
+3654,1511
+3680,1381
+3700,1197
+3707,1511
+3733,1381
+3753,1197
+3760,1511
+3786,1381
+3806,1197
+3813,1511
+3839,1381
+3859,1197
+3866,1511
+3892,1381
+3912,1197
+3919,1511
+3945,1381
+3965,1197
+3972,1511
+3998,1381
+4018,1197
+4025,1511
+4051,1381
+4071,1197
+4078,1511
+4104,1381
+4124,1197
+4131,1511
+4157,1381
+4177,1197
+4184,1511
+4210,1381
+4230,1197
+4237,1511
+4263,1381
+4283,1197
+4290,1511
+4316,1381
+4336,1197
+4343,1511
+4369,1381
+4389,1197
+4396,1511
+4422,1381
+4442,1197
+4449,1511
+4475,1381
+4495,1197
+4502,1511
+4528,1381
+4548,1197
+4555,1511
+4581,1381
+4601,1197
+4608,1511
+4634,1381
+4654,1197
+4661,1511
+4687,1381
+4707,1197
+4714,1511
+4740,1381
+4760,1197
+4767,1511
+4793,1381
+4813,1197
+4820,1511
+4846,1381
+4866,1197
+4873,1511
+4899,1381
+4919,1197
+4926,1511
+4952,1381
+4972,1197
+4979,1511
+5005,1381
+5025,1197
+5032,1511
+5058,1381
+5078,1197
+5085,1511
+5111,1381
+5131,1197
+5138,1511
+5164,1381
+5184,1197
+5191,1511
+5217,1381
+5237,1197
+5244,1511
+5270,1381
+5290,1197
+5297,1511
+5323,1381
+5343,1197
+5350,1511
+5376,1381
+5396,1197
+5403,1511
+5429,1381
+5449,1197
+5456,1511
+5482,1381
+5502,1197
+5509,1511
+5535,1381
+5555,1197
+5562,1511
+5588,1381
+5608,1197
+5615,1511
+5641,1381
+5661,1197
+5668,1511
+5694,1381
+5714,1197
+5721,1511
+5747,1381
+5767,1197
+5774,1511
+5800,1381
+5820,1197
+5827,1511
+5853,1381
+5873,1197
+5880,1511
+5906,1381
+5926,1197
+5933,1511
+5959,1381
+5979,1197
+5986,1511
+6012,1381
+6032,1197
+6039,1511
+6065,1381
+6085,1197
+6092,1511
+6118,1381
+6138,1197
+6145,1511
+6171,1381
+6191,1197
+6198,1511
+6224,1381
+6244,1197
+6251,1511
+6277,1381
+6297,1197
+6304,1511
+6330,1381
+6350,1197
+6357,1511
+6383,1381
+6403,1197
+6410,1511
+6436,1381
+6456,1197
+6463,1511
+6489,1381
+6509,1197
+6516,1511
+6542,1381
+6562,1197
+6569,1511
+6595,1381
+6615,1197
+6622,1511
+6648,1381
+6668,1197
+6675,1511
+6701,1381
+6721,1197
+6728,1511
+6754,1381
+6774,1197
+6781,1511
+6807,1381
+6827,1197
+6834,1511
+6860,1381
+6880,1197
+6887,1511
+6913,1381
+6933,1197
+6940,1511
+6966,1381
+6986,1197
+6993,1511
+7019,1381
+7039,1197
+7046,1511
+7072,1381
+7092,1197
+7099,1511
+7125,1381
+7145,1197
+7152,1511
+7178,1381
+7198,1197
+7205,1511
+7231,1381
+7251,1197
+7258,1511
+7284,1381
+7304,1197
+7311,1511
+7337,1381
+7357,1197
+7364,1511
+7390,1381
+7410,1197
+7417,1511
+7443,1381
+7463,1197
+7470,1511
+7496,1381
+7516,1197
+7523,1511
+7549,1381
+7569,1197
+7576,1511
+7602,1381
+7622,1197
+7629,1511
+7655,1381
+7675,1197
+7682,1511
+7708,1381
+7728,1197
+7735,1511
+7761,1381
+7781,1197
+7788,1511
+7814,1381
+7834,1197
+7841,1511
+7867,1381
+7887,1197
+7894,1511
+7920,1381
+7940,1197
+7947,1511
+7973,1381
+7993,1197
+8000,1511
+8026,1381
+8046,1197
+8053,1511
+8079,1381
+8099,1197
+8106,1511
+8132,1381
+8152,1197
+8159,1511
+8185,1381
+8205,1197
+8212,1511
+8238,1381
+8258,1197
+8265,1511
+8291,1381
+8311,1197
+8318,1511
+8344,1381
+8364,1197
+8371,1511
+8397,1381
+8417,1197
+8424,1511
+8450,1381
+8470,1197
+8477,1511
+8503,1381
+8523,1197
+8530,1511
+8556,1381
+8576,1197
+8583,1511
+8609,1381
+8629,1197
+8636,1511
+8662,1381
+8682,1197
+8689,1511
+8715,1381
+8735,1197
+8742,1511
+8768,1381
+8788,1197
+8795,1511
+8821,1381
+8841,1197
+8848,1511
+8874,1381
+8894,1197
+8901,1511
+8927,1381
+8947,1197
+8954,1511
+8980,1381
+9000,1197
+9007,1511
+9033,1381
+9053,1197
+9060,1511
+9086,1381
+9106,1197
+9113,1511
+9139,1381
+9159,1197
+9166,1511
+9192,1381
+9212,1197
+9219,1511
+9245,1381
+9265,1197
+9272,1511
+9298,1381
+9318,1197
+9325,1511
+9351,1381
+9371,1197
+9378,1511
+9404,1381
+9424,1197
+9431,1511
+9457,1381
+9477,1197
+9484,1511
+9510,1381
+9530,1197
+9537,1511
+9563,1381
+9583,1197
+9590,1511
+9616,1381
+9636,1197
+9643,1511
+9669,1381
+9689,1197
+9696,1511
+9722,1381
+9742,1197
+9749,1511
+9775,1381
+9795,1197
+9802,1511
+9828,1381
+9848,1197
+9855,1511
+9881,1381
+9901,1197
+9908,1511
+9934,1381
+9954,1197
+9961,1511
+9987,1381

registry/phase4ad-author-semantics/evidence/environment/bootstrap-notes.json

@@ -0,0 +1,9 @@
+{
+  "isolated_venv_only": true,
+  "existing_environments_modified": false,
+  "initial_install_failure": "New venv pip22.0.2 lacks --report; upgraded ONLY new venv pip to author-pinned23.0.1 before installing",
+  "MarkupSafe": "Author-pinned1.1.1 used PyPI source distribution and legacy setup.py because no CPython3.10 wheel; other requested core packages used wheels",
+  "author_environment": "Windows conda CPython3.10.11",
+  "actual_environment": "Linux CPython3.10.12; not binary-identical",
+  "package_download_provenance": "install-report.json contains HTTPS PyPI archive URLs and SHA256 for packages"
+}

registry/phase4ad-author-semantics/evidence/environment/frozen-scientific-environment.json

@@ -0,0 +1,12 @@
+{
+  "python": "3.10.12 (main, Aug 31 2026, 10:18:17) [GCC 11.4.0]",
+  "executable": "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+  "platform": "Linux-5.15.0-194-generic-x86_64-with-glibc2.35",
+  "package_versions": {
+    "numpy": "2.2.6",
+    "pandas": "2.3.3",
+    "pyarrow": "25.0.1",
+    "torch": "2.14.0",
+    "scipy": "1.15.3"
+  }
+}

registry/phase4ad-author-semantics/evidence/environment/installed-packages.json

@@ -0,0 +1,78 @@
+[
+  {
+    "name": "Brian2",
+    "version": "2.5.1"
+  },
+  {
+    "name": "Cython",
+    "version": "0.29.33"
+  },
+  {
+    "name": "Jinja2",
+    "version": "2.11.3"
+  },
+  {
+    "name": "joblib",
+    "version": "1.2.0"
+  },
+  {
+    "name": "MarkupSafe",
+    "version": "1.1.1"
+  },
+  {
+    "name": "mpmath",
+    "version": "1.3.0"
+  },
+  {
+    "name": "numpy",
+    "version": "1.22.3"
+  },
+  {
+    "name": "packaging",
+    "version": "23.1"
+  },
+  {
+    "name": "pandas",
+    "version": "1.4.3"
+  },
+  {
+    "name": "pip",
+    "version": "23.0.1"
+  },
+  {
+    "name": "pyarrow",
+    "version": "11.0.0"
+  },
+  {
+    "name": "pyparsing",
+    "version": "3.0.9"
+  },
+  {
+    "name": "python-dateutil",
+    "version": "2.8.2"
+  },
+  {
+    "name": "pytz",
+    "version": "2023.3"
+  },
+  {
+    "name": "scipy",
+    "version": "1.8.1"
+  },
+  {
+    "name": "setuptools",
+    "version": "67.8.0"
+  },
+  {
+    "name": "six",
+    "version": "1.16.0"
+  },
+  {
+    "name": "sympy",
+    "version": "1.12"
+  },
+  {
+    "name": "wheel",
+    "version": "0.38.4"
+  }
+]

registry/phase4ad-author-semantics/evidence/external-resources/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Philip Shiu and Nico Spiller
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

registry/phase4ad-author-semantics/evidence/external-resources/environment_full.yml

@@ -0,0 +1,109 @@
+name: brian2
+channels:
+  - defaults
+  - conda-forge
+dependencies:
+  - abseil-cpp=20211102.0=h0e60522_0
+  - arrow-cpp=11.0.0=py310h7cee713_0
+  - asttokens=2.2.1=pyhd8ed1ab_0
+  - aws-c-common=0.4.57=ha925a31_1
+  - aws-c-event-stream=0.1.6=hd77b12b_5
+  - aws-checksums=0.1.9=ha925a31_0
+  - aws-sdk-cpp=1.8.185=hd77b12b_0
+  - backcall=0.2.0=pyh9f0ad1d_0
+  - backports=1.0=pyhd8ed1ab_3
+  - backports.functools_lru_cache=1.6.4=pyhd8ed1ab_0
+  - boost-cpp=1.78.0=h5b4e17d_0
+  - brian2=2.5.1=py310hc781a3c_0
+  - bzip2=1.0.8=he774522_0
+  - c-ares=1.19.0=h2bbff1b_0
+  - ca-certificates=2023.5.7=h56e8100_0
+  - colorama=0.4.6=pyhd8ed1ab_0
+  - cython=0.29.33=py310hd77b12b_0
+  - debugpy=1.5.1=py310hd77b12b_0
+  - decorator=5.1.1=pyhd8ed1ab_0
+  - executing=1.2.0=pyhd8ed1ab_0
+  - gflags=2.2.2=ha925a31_1004
+  - glog=0.5.0=h4797de2_0
+  - gsl=2.7=hdfb1a43_0
+  - importlib-metadata=6.6.0=pyha770c72_0
+  - importlib_metadata=6.6.0=hd8ed1ab_0
+  - intel-openmp=2023.1.0=h57928b3_46319
+  - ipykernel=6.15.0=pyh025b116_0
+  - ipython=8.14.0=pyh08f2357_0
+  - jedi=0.18.2=pyhd8ed1ab_0
+  - jinja2=2.11.3=pyhd8ed1ab_2
+  - joblib=1.2.0=pyhd8ed1ab_0
+  - jupyter_client=8.2.0=pyhd8ed1ab_0
+  - jupyter_core=5.3.0=py310h5588dad_0
+  - libblas=3.9.0=8_mkl
+  - libbrotlicommon=1.0.9=h8ffe710_7
+  - libbrotlidec=1.0.9=h8ffe710_7
+  - libbrotlienc=1.0.9=h8ffe710_7
+  - libcblas=3.9.0=8_mkl
+  - libcurl=7.88.1=h86230a5_0
+  - libffi=3.4.4=hd77b12b_0
+  - liblapack=3.9.0=8_mkl
+  - libprotobuf=3.20.3=h23ce68f_0
+  - libsodium=1.0.18=h8d14728_1
+  - libssh2=1.10.0=hcd4344a_0
+  - libthrift=0.15.0=h636ae23_0
+  - lz4-c=1.9.4=h2bbff1b_0
+  - m2w64-gcc-libgfortran=5.3.0=6
+  - m2w64-gcc-libs=5.3.0=7
+  - m2w64-gcc-libs-core=5.3.0=7
+  - m2w64-gmp=6.1.0=2
+  - m2w64-libwinpthread-git=5.0.0.4634.697f757=2
+  - markupsafe=1.1.1=py310he2412df_4
+  - matplotlib-inline=0.1.6=pyhd8ed1ab_0
+  - mkl=2020.4=hb70f87d_311
+  - mpmath=1.3.0=pyhd8ed1ab_0
+  - msys2-conda-epoch=20160418=1
+  - nest-asyncio=1.5.6=pyhd8ed1ab_0
+  - numpy=1.22.3=py310hed7ac4c_2
+  - openssl=1.1.1t=h2bbff1b_0
+  - orc=1.7.4=h623e30f_1
+  - packaging=23.1=pyhd8ed1ab_0
+  - pandas=1.4.3=py310hf5e1058_0
+  - parso=0.8.3=pyhd8ed1ab_0
+  - pickleshare=0.7.5=py_1003
+  - pip=23.0.1=py310haa95532_0
+  - platformdirs=3.5.1=pyhd8ed1ab_0
+  - prompt-toolkit=3.0.38=pyha770c72_0
+  - prompt_toolkit=3.0.38=hd8ed1ab_0
+  - psutil=5.9.0=py310h2bbff1b_0
+  - pure_eval=0.2.2=pyhd8ed1ab_0
+  - py-cpuinfo=9.0.0=pyhd8ed1ab_0
+  - pyarrow=11.0.0=py310h790e06d_0
+  - pygments=2.15.1=pyhd8ed1ab_0
+  - pyparsing=3.0.9=pyhd8ed1ab_0
+  - python=3.10.11=h966fe2a_2
+  - python-dateutil=2.8.2=pyhd8ed1ab_0
+  - python_abi=3.10=2_cp310
+  - pytz=2023.3=pyhd8ed1ab_0
+  - pywin32=305=py310h2bbff1b_0
+  - pyzmq=25.0.2=py310hd77b12b_0
+  - re2=2022.04.01=h0e60522_0
+  - scipy=1.8.1=py310h7c00807_2
+  - setuptools=67.8.0=py310haa95532_0
+  - six=1.16.0=pyh6c4a22f_0
+  - snappy=1.1.9=h6c2663c_0
+  - sqlite=3.41.2=h2bbff1b_0
+  - stack_data=0.6.2=pyhd8ed1ab_0
+  - sympy=1.12=pyh04b8f61_3
+  - tk=8.6.12=h2bbff1b_0
+  - tornado=6.2=py310he2412df_0
+  - traitlets=5.9.0=pyhd8ed1ab_0
+  - typing-extensions=4.6.3=hd8ed1ab_0
+  - typing_extensions=4.6.3=pyha770c72_0
+  - tzdata=2023c=h04d1e81_0
+  - utf8proc=2.6.1=h2bbff1b_0
+  - vc=14.2=h21ff451_1
+  - vs2015_runtime=14.27.29016=h5e58377_2
+  - wcwidth=0.2.6=pyhd8ed1ab_0
+  - wheel=0.38.4=py310haa95532_0
+  - xz=5.4.2=h8cc25b3_0
+  - zeromq=4.3.4=h0e60522_1
+  - zipp=3.15.0=pyhd8ed1ab_0
+  - zlib=1.2.13=h8cc25b3_0
+  - zstd=1.5.5=hd43e919_0

registry/phase4ad-author-semantics/evidence/external-resources/model.py

@@ -0,0 +1,373 @@
+import pandas as pd
+from textwrap import dedent
+
+# brian 2
+from brian2 import NeuronGroup, Synapses, PoissonInput, SpikeMonitor, Network
+from brian2 import mV, ms, Hz
+
+# file handling
+from pathlib import Path
+
+# parallelization
+from joblib import Parallel, delayed, parallel_backend
+from time import time
+
+default_params = {
+    # trials
+    't_run'     : 1000 * ms,              # duration of trial
+    'n_run'     : 30,                     # number of runs
+
+    # network constants
+    # Kakaria and de Bivort 2017 https://doi.org/10.3389/fnbeh.2017.00008
+    'v_0'       : -52 * mV,               # resting potential
+    'v_rst'     : -52 * mV,               # reset potential after spike
+    'v_th'      : -45 * mV,               # threshold for spiking
+    't_mbr'     :  20 * ms,               # membrane time scale (capacitance * resistance = .002 * uF * 10. * Mohm)
+
+    # Jürgensen et al https://doi.org/10.1088/2634-4386/ac3ba6
+    'tau'       : 5 * ms,                 # time constant 
+
+    # Lazar et al https://doi.org/10.7554/eLife.62362
+    't_rfc'     : 2.2 * ms,               # refractory period
+
+    # Paul et al 2015 doi: 10.3389/fncel.2015.00029
+    't_dly'     : 1.8*ms,                 # delay for changes in post-synaptic neuron
+
+    # Free parameter 
+    'w_syn'     : .275 * mV,              # weight per synapse (note: modulated by exponential decay)
+    # Default activation rates 
+    'r_poi'     : 150*Hz,                 # default rate of the Poisson inputs
+    'r_poi2'    :   0*Hz,                 # default rate of a 2nd class of Poisson inputs
+    'f_poi'     : 250,                    # scaling factor for Poisson synapse; 250 is sufficient to cause spiking
+
+    # equations for neurons               # alpha synapse https://doi.org/10.1017/CBO9780511815706; See https://brian2.readthedocs.io/en/stable/user/converting_from_integrated_form.html
+    'eqs'       : dedent(''' 
+                    dv/dt = (v_0 - v + g) / t_mbr : volt (unless refractory)
+                    dg/dt = -g / tau               : volt (unless refractory) 
+                    rfc                            : second
+                    '''),
+    # condition for spike
+    'eq_th'     : 'v > v_th', 
+    # rules for spike        
+    'eq_rst'    : 'v = v_rst; w = 0; g = 0 * mV', 
+}
+
+
+#######################
+# brian2 model setup
+def poi(neu, exc, exc2, params):
+    '''Create PoissonInput for neurons.
+
+    For each neuron in 'names' a PoissonInput is generated and 
+    the refractory period of that neuron is set to 0 in NeuronGroup.
+
+    Parameters
+    ----------
+    neu : NeuronGroup
+        Defined brian2.NeuronGroup object
+    exc : list
+        Indices of neurons for which to create Poisson input
+    exc2 : list
+        Indices of neurons for which to create Poisson input with `r_poi`
+    params : dict
+        Constants and equations that are used to construct the brian2 network model
+
+    Returns
+    -------
+    pois : list
+        PoissonInput objects for each neuron in 'exc'
+    neu : NeuronGroup
+        NeuronGroup with adjusted refractory periods
+    '''
+
+    pois = []
+    for i in exc:
+        p = PoissonInput(
+            target=neu[i], 
+            target_var='v', 
+            N=1, 
+            rate=params['r_poi'], 
+            weight=params['w_syn']*params['f_poi']
+            )
+        neu[i].rfc = 0 * ms # no refractory period for Poisson targets
+        pois.append(p)
+
+    for i in exc2:
+        p = PoissonInput(
+            target=neu[i], 
+            target_var='v', 
+            N=1, 
+            rate=params['r_poi2'], 
+            weight=params['w_syn']*params['f_poi']
+            )
+        neu[i].rfc = 0 * ms # no refractory period for Poisson targets
+        pois.append(p)
+
+    return pois, neu
+
+def silence(slnc, syn):
+    '''Silence neuron by setting weights of all synapses from it to 0
+
+    Parameters
+    ----------
+    slnc : list
+        List of neuron indices to silence
+    syn : brian2.Synapses
+        Defined synapses object
+
+    Returns
+    -------
+    syn : brian2.Synapses
+        Synapses with modified weights
+    '''
+
+    for i in slnc:
+        syn.w[' {} == i'.format(i)] = 0*mV
+    
+    return syn
+
+def create_model(path_comp, path_con, params):
+    '''Create default network model.
+
+    Convert the "completeness materialization" and "connectivity" dataframes
+    into a brian2 neural network model. Network constants and equations
+    are defined at the beginning of this file.
+
+    Parameters
+    ----------
+    path_comp : str
+        path to "completeness materialization" dataframe
+    path_con : str
+        path to "connectivity" dataframe
+    params : dict
+        Constants and equations that are used to construct the brian2 network model
+
+
+    Returns
+    -------
+    neu : NeuronGroup
+        brian2.NeuronGroup object with neurons as in 'path_comp'
+    syn : Synapses
+        brian2.Synapses object with connections as in 'path_con'
+    spk_mon : SpikeMonitor
+        brian2.SpikeMonitor object, which records time of spike events
+    '''
+
+    # load neuron connectivity dataframes
+    df_comp = pd.read_csv(path_comp, index_col=0)
+    df_con = pd.read_parquet(path_con)
+
+    neu = NeuronGroup( # create neurons
+        N=len(df_comp),
+        model=params['eqs'],
+        method='linear',
+        threshold=params['eq_th'],
+        reset=params['eq_rst'],
+        refractory='rfc',
+        name='default_neurons',
+        namespace=params,
+    )
+    neu.v = params['v_0'] # initialize values
+    neu.g = 0
+    neu.rfc = params['t_rfc']
+
+    # create synapses
+    syn = Synapses(neu, neu, 'w : volt', on_pre='g += w', delay=params['t_dly'], name='default_synapses')
+
+    # connect synapses
+    i_pre = df_con.loc[:, 'Presynaptic_Index'].values
+    i_post = df_con.loc[:, 'Postsynaptic_Index'].values
+    syn.connect(i=i_pre, j=i_post)
+
+    # define connection weight
+    syn.w = df_con.loc[:,'Excitatory x Connectivity'].values * params['w_syn']
+
+    # object to record spikes
+    spk_mon = SpikeMonitor(neu) 
+
+    return neu, syn, spk_mon
+
+#####################
+# running simulations
+def get_spk_trn(spk_mon):
+    '''Extracts spike times from 'spk_mon'
+
+    The spike times recorded in the SpikeMonitor object during 
+    simulation are converted to a list of times for each neurons.
+    Returns dict with "brian ID": "list of spike times".
+
+    Parameters
+    ----------
+    spk_mon : SpikeMonitor
+        Contains recorded spike times
+
+    Returns
+    -------
+    spk_trn : dict
+        Mapping between brian neuron IDs and spike times
+    '''
+
+    spk_trn = {k: v for k, v in spk_mon.spike_trains().items() if len(v)}
+    
+    return spk_trn
+
+def construct_dataframe(res, exp_name, i2flyid):
+    '''Take spike time dict and collects spikes in pandas dataframe
+
+    Parameters
+    ----------
+    res : list
+        List with spike time dicts for each trial
+    exp_name : str
+        Name of the experiment
+    i2flyid : dict
+        Mapping between Brian IDs and flywire IDs
+
+    Returns
+    -------
+    df : pandas.DataFrame
+        Dataframe where each row is one spike
+    '''
+    
+    ids, ts, nrun = [], [], []
+
+    for n, i in enumerate(res):
+        for j, k  in i.items():
+            ids.extend([j for _ in k])
+            nrun.extend([n for _ in k])
+            ts.extend([float(l) for l in k])
+
+    d = {
+        't': ts,
+        'trial': nrun,
+        'flywire_id': [i2flyid[i] for i in ids],
+        'exp_name': exp_name
+    }
+    df = pd.DataFrame(d)
+
+    return df
+
+def run_trial(exc, exc2, slnc, path_comp, path_con, params):
+    '''Run single trial of coactivation/silencng experiment
+
+    During the coactivation experiment, the neurons in 'exc' are
+    Poisson inputs. The simulation runs for 't_run'.
+    
+
+    Parameters
+    ----------
+    exc: list
+        contains indices of neurons for PoissonInput
+    exc2: list
+        contains indices of neurons for PoissonInput of different frequency `r_poi2`
+    slnc: list
+        contains indices of neurons to silence
+    path_comp: Path 
+        path to "completeness materialization" dataframe
+    path_con: Path
+        path to "connectivity" dataframe
+    params : dict
+        Constants and equations that are used to construct the brian2 network model
+
+    Returns
+    -------
+    spk_trn : dict
+        Mapping between brian neuron IDs and spike times
+    '''
+
+    # get default network
+    neu, syn, spk_mon = create_model(path_comp, path_con, params)
+    # define Poisson input for excitation
+    poi_inp, neu = poi(neu, exc, exc2, params)
+    # silence neurons
+    syn = silence(slnc, syn)
+    # collect in Network object
+    net = Network(neu, syn, spk_mon, *poi_inp)
+
+    # run simulation
+    net.run(duration=params['t_run'])
+
+    # spike times 
+    spk_trn = get_spk_trn(spk_mon)
+
+    return spk_trn
+
+
+def run_exp(exp_name, neu_exc, path_res, path_comp, path_con,
+            params=default_params, neu_slnc=[], neu_exc2=[], 
+            n_proc=-1, force_overwrite=False):
+    '''
+    Run default network experiment 
+    Neurons in `neu_exc` are Poisson external inputs
+    Neurons in `neu_slnc` are silenced
+
+
+    Parameters
+    ----------
+        exp_name: str
+            name of the experiment
+        neu_exc: list
+            contains custom names or flywire IDs of neurons to be excited
+        path_res: str
+            path to the output folder where spike data is stored
+        path_comp: str 
+            path to "completeness materialization" dataframe
+        path_con: str
+            path to "connectivity" dataframe
+        params : dict
+            Constants and equations that are used to construct the brian2 network model
+        neu_slnc : list (optional)
+            contains custom names or flywire IDs of neurons to be silenced
+        neu_exc2 : list (optional)
+            contains custom names or flywire IDs of neurons to be excited with different frequency
+            requires `r_poi2` to be defined in `params`
+        n_proc: int (optional)
+            number of cores to be used for parallel runs
+            default: -1 (use all available cores)
+            n_proc=1 is equivalent serial code
+        force_overwrite : bool (optional)
+            If True, overwrite output files, else skip simulation, by default False
+    '''
+
+    # convert to Path objects
+    path_res, path_comp, path_con = [ Path(i) for i in [path_res, path_comp, path_con] ]
+
+    # define output files
+    path_save = path_res / '{}.parquet'.format(exp_name)
+    if path_save.is_file() and not force_overwrite:
+        print('>>> Skipping experiment {} because {} exists and force_overwrite = {}'.format(exp_name, path_save, force_overwrite))
+        return 
+
+    # load name/id mappings
+    df_comp = pd.read_csv(path_comp, index_col=0) # load completeness dataframe
+    flyid2i = {j: i for i, j in enumerate(df_comp.index)}  # flywire id: biran ID
+    i2flyid = {j: i for i, j in flyid2i.items()} # brian ID: flywire ID
+    
+    # print info
+    print('>>> Experiment:     {}'.format(exp_name))
+    print('    Output file:    {}'.format(path_save))
+    print('    Excited neurons: {}'.format(len(neu_exc + neu_exc2)))
+    if neu_slnc:
+        print('    Silenced neurons: {}'.format(len(neu_slnc)))
+    
+    # start parallel calculation
+    n_run = params['n_run']
+    start = time() 
+    with parallel_backend('loky', n_jobs=n_proc):
+        exc = [ flyid2i[n] for n in neu_exc ]
+        exc2 = [ flyid2i[n] for n in neu_exc2 ]
+        slnc = [ flyid2i[n] for n in neu_slnc ]
+        res = Parallel()(
+            delayed(
+                run_trial)(exc, exc2, slnc, path_comp, path_con, params) for _ in range(n_run))
+
+        
+    # print simulation time
+    walltime = time() - start 
+    print('    Elapsed time:   {} s'.format(int(walltime)))
+
+    # dataframe with spike times
+    df = construct_dataframe(res, exp_name, i2flyid)
+
+    # store spike data
+    df.to_parquet(path_save, compression='brotli')

registry/phase4ad-author-semantics/evidence/gpu-reference/extension.json

@@ -0,0 +1,17 @@
+{
+  "binary": "/data/digital-drosophila/experiments/phase4ad-author-semantics/gpu-reference/extension-build/male_cns_lif_deterministic_v2_ext.so",
+  "binary_sha256": "57f59f634cc8e3b03f4674a3ddb11ec933ab124feb0b9fa89d08fe26e60fcb7e",
+  "build_seconds": 55.24202698399972,
+  "flags": {
+    "cuda": [
+      "-O3",
+      "--fmad=false",
+      "-std=c++20"
+    ],
+    "cxx": [
+      "-O3",
+      "-ffp-contract=off"
+    ]
+  },
+  "status": "PASS"
+}

registry/phase4ad-author-semantics/evidence/oracle/feedforward-float32-repeat/actual-weights.json

@@ -0,0 +1,20 @@
+{
+  "edge_id": [
+    1337065,
+    1467355,
+    1559765,
+    20992891
+  ],
+  "weights_mv": [
+    28.599998474121094,
+    64.625,
+    62.14999771118164,
+    11.824999809265137
+  ],
+  "weights_volt": [
+    0.028599999845027924,
+    0.06462500244379044,
+    0.062150001525878906,
+    0.011824999935925007
+  ]
+}

registry/phase4ad-author-semantics/evidence/oracle/feedforward-float32-repeat/brian-output/events.csv

@@ -0,0 +1,4 @@
+step,neuron_idx
+0,1381
+51,1511
+104,1197

registry/phase4ad-author-semantics/evidence/oracle/feedforward-float32-repeat/completeness.csv

@@ -0,0 +1,6 @@
+global_neuron_idx,local_index
+1197,0
+1381,1
+1511,2
+82312,3
+133666,4

registry/phase4ad-author-semantics/evidence/oracle/feedforward-float32-repeat/environment.json

@@ -0,0 +1,102 @@
+{
+  "all_package_pins_match": true,
+  "author_platform": "Windows",
+  "author_python": "3.10.11",
+  "binary_identical_author_environment_claimed": false,
+  "packages": {
+    "brian2": {
+      "actual": "2.5.1",
+      "expected": "2.5.1",
+      "matches": true
+    },
+    "cython": {
+      "actual": "0.29.33",
+      "expected": "0.29.33",
+      "matches": true
+    },
+    "jinja2": {
+      "actual": "2.11.3",
+      "expected": "2.11.3",
+      "matches": true
+    },
+    "joblib": {
+      "actual": "1.2.0",
+      "expected": "1.2.0",
+      "matches": true
+    },
+    "markupsafe": {
+      "actual": "1.1.1",
+      "expected": "1.1.1",
+      "matches": true
+    },
+    "mpmath": {
+      "actual": "1.3.0",
+      "expected": "1.3.0",
+      "matches": true
+    },
+    "numpy": {
+      "actual": "1.22.3",
+      "expected": "1.22.3",
+      "matches": true
+    },
+    "packaging": {
+      "actual": "23.1",
+      "expected": "23.1",
+      "matches": true
+    },
+    "pandas": {
+      "actual": "1.4.3",
+      "expected": "1.4.3",
+      "matches": true
+    },
+    "pyarrow": {
+      "actual": "11.0.0",
+      "expected": "11.0.0",
+      "matches": true
+    },
+    "pyparsing": {
+      "actual": "3.0.9",
+      "expected": "3.0.9",
+      "matches": true
+    },
+    "python-dateutil": {
+      "actual": "2.8.2",
+      "expected": "2.8.2",
+      "matches": true
+    },
+    "pytz": {
+      "actual": "2023.3",
+      "expected": "2023.3",
+      "matches": true
+    },
+    "scipy": {
+      "actual": "1.8.1",
+      "expected": "1.8.1",
+      "matches": true
+    },
+    "setuptools": {
+      "actual": "67.8.0",
+      "expected": "67.8.0",
+      "matches": true
+    },
+    "six": {
+      "actual": "1.16.0",
+      "expected": "1.16.0",
+      "matches": true
+    },
+    "sympy": {
+      "actual": "1.12",
+      "expected": "1.12",
+      "matches": true
+    },
+    "wheel": {
+      "actual": "0.38.4",
+      "expected": "0.38.4",
+      "matches": true
+    }
+  },
+  "platform": "Linux-5.15.0-194-generic-x86_64-with-glibc2.35",
+  "python": "3.10.12",
+  "python_executable": "/data/digital-drosophila/experiments/phase4ad-author-semantics/environment/.venv/bin/python",
+  "python_patch_matches": false
+}

registry/phase4ad-author-semantics/evidence/oracle/feedforward-float32-repeat/generated-code.json

@@ -0,0 +1,127 @@
+[
+  {
+    "active": true,
+    "code_objects": [],
+    "name": "default_neurons",
+    "order": 0,
+    "type": "NeuronGroup",
+    "when": "start"
+  },
+  {
+    "active": true,
+    "code_objects": [],
+    "name": "default_synapses",
+    "order": 0,
+    "type": "Synapses",
+    "when": "start"
+  },
+  {
+    "abstract_code": "not_refractory = timestep(t - lastspike, dt) >= timestep(rfc, dt)\n_g = g*exp(-dt*int(not_refractory)/tau)\n_v = g*tau*(-exp(dt*int(not_refractory)/t_mbr) + exp(dt*int(not_refractory)/tau))*exp(-dt*int(not_refractory)/t_mbr)*exp(-dt*int(not_refractory)/tau)/(t_mbr - tau) + v*exp(-dt*int(not_refractory)/t_mbr) + v_0 - v_0*exp(-dt*int(not_refractory)/t_mbr)\ng = _g\nv = _v",
+    "active": true,
+    "code_objects": [
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # scalar code\n    _vectorisation_idx = 1\n    dt = _array_defaultclock_dt[0]\n    _lio_1 = (- dt) / tau\n    _lio_2 = exp(_lio_1)\n    _lio_3 = tau / (t_mbr - tau)\n    _lio_4 = dt / t_mbr\n    _lio_5 = dt / tau\n    _lio_6 = (- dt) / t_mbr\n    _lio_7 = v_0 - v_0\n    _lio_8 = v_0 - (v_0 * exp(_lio_6))\n    _lio_9 = ((_lio_3 * ((- exp(_lio_4)) + exp(_lio_5))) * exp(_lio_6)) * exp(_lio_1)\n    _lio_10 = exp(_lio_6)\n    # vector code\n    _vectorisation_idx = LazyArange(N)\n    g = _array_default_neurons_g.copy()\n    t = _array_defaultclock_t[0]\n    dt = _array_defaultclock_dt[0]\n    rfc = _array_default_neurons_rfc\n    v = _array_default_neurons_v.copy()\n    lastspike = _array_default_neurons_lastspike\n    not_refractory = _array_default_neurons_not_refractory.copy()\n    not_refractory = timestep(t - lastspike, dt) >= timestep(rfc, dt)\n    _g = _numpy.where(not_refractory, _lio_2 * g, g)\n    _v = _numpy.where(not_refractory, _lio_8 + ((_lio_9 * g) + (_lio_10 * v)), _lio_7 + v)\n    g[not_refractory] = _g[not_refractory]\n    v[not_refractory] = _v[not_refractory]\n    _array_default_neurons_g[:] = g\n    _array_default_neurons_v[:] = v\n    _array_default_neurons_not_refractory[:] = not_refractory\n",
+        "name": "default_neurons_stateupdater_codeobject_7",
+        "type": "CallableProxyType"
+      }
+    ],
+    "name": "default_neurons_stateupdater",
+    "order": 0,
+    "type": "StateUpdater",
+    "user_code": "g = -g*int(not_refractory)/tau\nv = (g - v + v_0)*int(not_refractory)/t_mbr",
+    "when": "groups"
+  },
+  {
+    "active": true,
+    "code_objects": [],
+    "name": "oracle_seed_injection",
+    "order": 0,
+    "type": "NetworkOperation",
+    "when": "before_thresholds"
+  },
+  {
+    "abstract_code": "_cond = (v > v_th) and not_refractory",
+    "active": true,
+    "code_objects": [
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _array_default_neurons__spikespace[-1] = 0\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    numpy_True = _numpy.bool_(True)\n    numpy_False = _numpy.bool_(False)\n    # scalar code\n    _vectorisation_idx = 1\n    # vector code\n    _vectorisation_idx = LazyArange(N)\n    v = _array_default_neurons_v\n    not_refractory = _array_default_neurons_not_refractory\n    _cond = (v > v_th) & not_refractory\n    if _cond is True or _cond is numpy_True:\n        _events = _numpy.arange(N)\n    elif _cond is False or _cond is numpy_False:\n        _events = _numpy.array([])\n    else:\n        _events, = _cond.nonzero()\n    _array_default_neurons__spikespace[-1] = len(_events)\n    _array_default_neurons__spikespace[:len(_events)] = _events\n    # Set the neuron to refractory\n    _array_default_neurons_not_refractory[_events] = False\n    _array_default_neurons_lastspike[_events] = _array_defaultclock_t[0]\n",
+        "name": "default_neurons_spike_thresholder_codeobject_8",
+        "type": "CallableProxyType"
+      }
+    ],
+    "name": "default_neurons_spike_thresholder",
+    "order": 0,
+    "type": "Thresholder",
+    "user_code": "_cond = v > v_th",
+    "when": "thresholds"
+  },
+  {
+    "abstract_code": "_to_record_i = _source_i\n_to_record_t = _source_t",
+    "active": true,
+    "code_objects": [
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _n_events = _array_default_neurons__spikespace[-1]\n    if _n_events > 0:\n        _events = _array_default_neurons__spikespace[:_n_events]\n        # Take subgroups into account\n        if _source_start != 0 or _source_stop != _source_N:\n            _events = _events[(_events >= _source_start) & (_events < _source_stop)]\n            _n_events = len(_events)\n        if _n_events > 0:\n            _vectorisation_idx = 1\n            _curlen = _array_spikemonitor_N[0]\n            _newlen = _curlen + _n_events\n            _owner.resize(_newlen)\n            _array_spikemonitor_N[0] = _newlen\n            _vectorisation_idx = _events\n            _idx = _events\n            _source_i = _array_default_neurons_i[_idx]\n            _source_t = _array_defaultclock_t[0]\n            _to_record_i = _source_i\n            _to_record_t = _source_t\n            _dynamic_array_spikemonitor_t[_curlen:_newlen] = _to_record_t\n            _dynamic_array_spikemonitor_i[_curlen:_newlen] = _to_record_i\n            _array_spikemonitor_count[_events - _source_start] += 1\n",
+        "name": "spikemonitor_codeobject",
+        "type": "CallableProxyType"
+      }
+    ],
+    "name": "spikemonitor",
+    "order": 1,
+    "type": "SpikeMonitor",
+    "user_code": "None",
+    "when": "thresholds"
+  },
+  {
+    "abstract_code": "g += w\n",
+    "active": true,
+    "code_objects": [
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _owner.initialise_queue()\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _owner.push_spikes()\n",
+        "name": "default_synapses_pre_push_spikes",
+        "type": "CallableProxyType"
+      },
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _spiking_synapses = _queue.peek()\n    if len(_spiking_synapses):\n        # scalar code\n        # vector code\n        _idx = _spiking_synapses\n        _vectorisation_idx = _idx\n        #  Abstract code:  g += w\n        _postsynaptic_idx = _array_default_synapses__synaptic_post[_idx]\n        w = _array_default_synapses_w[_idx]\n        not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n        _numpy.add.at(_array_default_neurons_g, _postsynaptic_idx[not_refractory], w[not_refractory])\n    # Advance the spike queue\n    _queue.advance()\n",
+        "name": "default_synapses_pre_codeobject_4",
+        "type": "CallableProxyType"
+      }
+    ],
+    "name": "default_synapses_pre",
+    "order": -1,
+    "type": "SynapticPathway",
+    "user_code": "None",
+    "when": "synapses"
+  },
+  {
+    "abstract_code": "v = v_rst; w = 0; g = 0 * mV",
+    "active": true,
+    "code_objects": [
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # scalar code\n    _vectorisation_idx = 1\n    w = 0\n    # vector code\n    _idx = _array_default_neurons__spikespace[:_array_default_neurons__spikespace[-1]]\n    _vectorisation_idx = _idx\n    v = v_rst\n    g = 0.0\n    _array_default_neurons_g[_idx] = g\n    _array_default_neurons_v[_idx] = v\n",
+        "name": "default_neurons_spike_resetter_codeobject_4",
+        "type": "CallableProxyType"
+      }
+    ],
+    "name": "default_neurons_spike_resetter",
+    "order": 0,
+    "type": "Resetter",
+    "user_code": "None",
+    "when": "resets"
+  },
+  {
+    "abstract_code": "_to_record_v = _source_v\n_to_record_g = _source_g\n_to_record_lastspike = _source_lastspike\n_to_record_not_refractory = _source_not_refractory",
+    "active": true,
+    "code_objects": [
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # Resize dynamic arrays\n    _new_len = len(_dynamic_array_oracle_end_state_t) + 1\n    _owner.resize(_new_len)\n    # Store values\n    _dynamic_array_oracle_end_state_t[-1] = _array_defaultclock_t[0]\n    # scalar code\n    _vectorisation_idx = 1\n    # vector code\n    _vectorisation_idx = _array_oracle_end_state__indices\n    _idx = _array_oracle_end_state__indices\n    _source_not_refractory = _array_default_neurons_not_refractory[_idx]\n    _source_g = _array_default_neurons_g[_idx]\n    _source_v = _array_default_neurons_v[_idx]\n    _source_lastspike = _array_default_neurons_lastspike[_idx]\n    _to_record_v = _source_v\n    _to_record_g = _source_g\n    _to_record_lastspike = _source_lastspike\n    _to_record_not_refractory = _source_not_refractory\n    _dynamic_array_oracle_end_state_v[-1, :] = _to_record_v\n    _dynamic_array_oracle_end_state_g[-1, :] = _to_record_g\n    _dynamic_array_oracle_end_state_lastspike[-1, :] = _to_record_lastspike\n    _dynamic_array_oracle_end_state_not_refractory[-1, :] = _to_record_not_refractory\n",
+        "name": "oracle_end_state_codeobject",
+        "type": "CallableProxyType"
+      }
+    ],
+    "name": "oracle_end_state",
+    "order": 0,
+    "type": "StateMonitor",
+    "user_code": "None",
+    "when": "end"
+  }
+]

registry/phase4ad-author-semantics/evidence/oracle/feedforward-float32-repeat/run-spec.json

@@ -0,0 +1,123 @@
+{
+  "author_commit": "91bdd1e7dcf193f3e7ca5a8933497fcef63b7960",
+  "author_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e",
+  "config": {
+    "author_precisions": [
+      "float64",
+      "float32"
+    ],
+    "comparison": {
+      "exact_spike_events_required_for_oracle_validation": true,
+      "float32_state_max_abs_tolerance_mv": 0.001,
+      "float64_state_max_abs_tolerance_mv": 1e-08,
+      "precision_cross_comparison_may_diverge_but_must_be_reported": true
+    },
+    "component_policies": [
+      "frozen",
+      "reset_g_only",
+      "refractory_gate_only",
+      "reset_and_refractory"
+    ],
+    "dt_ms": 0.1,
+    "duration_ms": 1000.0,
+    "experiment": "experiments/phase4ad-author-semantics",
+    "human_authorization": "\u5141\u8bb8\u72ec\u7acb\u65b0\u6a21\u578b\u5206\u652f\u6d4b\u8bd5\u52a8\u529b\u5b66\u5047\u8bbe",
+    "late_start_ms": 500.0,
+    "model": {
+      "dt_ms": 0.1,
+      "membrane_tau_ms": 20.0,
+      "refractory_ms": 2.2,
+      "reset_potential_mv": -52.0,
+      "resting_potential_mv": -52.0,
+      "synaptic_delay_ms": 1.8,
+      "synaptic_tau_ms": 5.0,
+      "threshold_mv": -45.0,
+      "w_syn_mv_per_anatomical_synapse": 0.275
+    },
+    "model_directory": "models/male-cns-lif/author-semantics-lab-v1",
+    "motifs": [
+      "pair",
+      "trio",
+      "five",
+      "feedforward",
+      "no_input"
+    ],
+    "name": "author-semantics-lab-v1",
+    "no_training_or_candidate": true,
+    "phase": "4AD",
+    "prior_experiment": "experiments/phase4ac-lif-semantics",
+    "prior_model": "models/male-cns-lif/lif-semantics-audit-v1",
+    "root": "/data/digital-drosophila",
+    "seed_margin_mv": 1.0,
+    "seed_node": 1381
+  },
+  "delay_steps": 18,
+  "dt_ms": 0.1,
+  "edge_ids": [
+    1337065,
+    1467355,
+    1559765,
+    20992891
+  ],
+  "external_arrivals": {
+    "events": 0,
+    "ordering": "after default_synapses.pre"
+  },
+  "internal_voltage_unit": "volt",
+  "nodes": [
+    1197,
+    1381,
+    1511,
+    82312,
+    133666
+  ],
+  "parameter_checks": {
+    "membrane_tau_ms": {
+      "author": 20.0,
+      "config": 20.0
+    },
+    "refractory_ms": {
+      "author": 2.2,
+      "config": 2.2
+    },
+    "reset_potential_mv": {
+      "author": -52.0,
+      "config": -52.0
+    },
+    "resting_potential_mv": {
+      "author": -52.0,
+      "config": -52.0
+    },
+    "synaptic_delay_ms": {
+      "author": 1.8,
+      "config": 1.8
+    },
+    "synaptic_tau_ms": {
+      "author": 5.0,
+      "config": 5.0
+    },
+    "threshold_mv": {
+      "author": -45.0,
+      "config": -45.0
+    },
+    "w_syn_mv_per_anatomical_synapse": {
+      "author": 0.275,
+      "config": 0.275
+    }
+  },
+  "precision": "float32",
+  "preferences": {
+    "codegen.target": "numpy",
+    "core.default_float_dtype": "float32",
+    "legacy.refractory_timing": false
+  },
+  "refractory_steps": 22,
+  "returned_voltage_unit": "mV",
+  "seed": {
+    "injections": 0,
+    "margin_mv": 1.0,
+    "requested_global_node": 1381
+  },
+  "steps": 10000,
+  "weight_rule": "raw_count multiplied by unchanged author w_syn; no sign inference"
+}

registry/phase4ad-author-semantics/evidence/oracle/feedforward-float32-repeat/schedule.json

@@ -0,0 +1,11 @@
+{
+  "schedule": [
+    "start",
+    "groups",
+    "thresholds",
+    "synapses",
+    "resets",
+    "end"
+  ],
+  "summary": "                    object                      |             part of             |       Clock dt       |       when        | order | active\n------------------------------------------------+---------------------------------+----------------------+-------------------+-------+-------\ndefault_neurons_stateupdater (StateUpdater)     | default_neurons (NeuronGroup)   | 100. us (every step) | groups            |     0 |  yes  \noracle_seed_injection (NetworkOperation)        | --                              | 100. us (every step) | before_thresholds |     0 |  yes  \ndefault_neurons_spike_thresholder (Thresholder) | default_neurons (NeuronGroup)   | 100. us (every step) | thresholds        |     0 |  yes  \nspikemonitor (SpikeMonitor)                     | spikemonitor (SpikeMonitor)     | 100. us (every step) | thresholds        |     1 |  yes  \ndefault_synapses_pre (SynapticPathway)          | default_synapses (Synapses)     | 100. us (every step) | synapses          |    -1 |  yes  \ndefault_neurons_spike_resetter (Resetter)       | default_neurons (NeuronGroup)   | 100. us (every step) | resets            |     0 |  yes  \noracle_end_state (StateMonitor)                 | oracle_end_state (StateMonitor) | 100. us (every step) | end               |     0 |  yes  "
+}

registry/phase4ad-author-semantics/evidence/oracle/feedforward-float32-repeat/seed.json

@@ -0,0 +1,7 @@
+{
+  "applied_mv": -43.99999976158142,
+  "injections": 1,
+  "margin_mv": 1.0,
+  "requested_global_node": 1381,
+  "spiked_at_zero": true
+}

registry/phase4ad-author-semantics/evidence/oracle/feedforward-float32/actual-weights.json

@@ -0,0 +1,20 @@
+{
+  "edge_id": [
+    1337065,
+    1467355,
+    1559765,
+    20992891
+  ],
+  "weights_mv": [
+    28.599998474121094,
+    64.625,
+    62.14999771118164,
+    11.824999809265137
+  ],
+  "weights_volt": [
+    0.028599999845027924,
+    0.06462500244379044,
+    0.062150001525878906,
+    0.011824999935925007
+  ]
+}

registry/phase4ad-author-semantics/evidence/oracle/feedforward-float32/brian-output/events.csv

@@ -0,0 +1,4 @@
+step,neuron_idx
+0,1381
+51,1511
+104,1197

registry/phase4ad-author-semantics/evidence/oracle/feedforward-float32/comparison.json

@@ -0,0 +1,11 @@
+{
+  "exact_events": true,
+  "exact_counts": true,
+  "ref_exact": true,
+  "max_abs_mv": 0.00020179152488708496,
+  "mean_abs_mv": 1.9821550031807453e-05,
+  "same_event_prefix_max_abs_mv": 0.00020179152488708496,
+  "first_event_divergence_step": null,
+  "tolerance_mv": 0.001,
+  "pass_oracle": true
+}

registry/phase4ad-author-semantics/evidence/oracle/feedforward-float32/completeness.csv

@@ -0,0 +1,6 @@
+global_neuron_idx,local_index
+1197,0
+1381,1
+1511,2
+82312,3
+133666,4

registry/phase4ad-author-semantics/evidence/oracle/feedforward-float32/environment.json

@@ -0,0 +1,102 @@
+{
+  "all_package_pins_match": true,
+  "author_platform": "Windows",
+  "author_python": "3.10.11",
+  "binary_identical_author_environment_claimed": false,
+  "packages": {
+    "brian2": {
+      "actual": "2.5.1",
+      "expected": "2.5.1",
+      "matches": true
+    },
+    "cython": {
+      "actual": "0.29.33",
+      "expected": "0.29.33",
+      "matches": true
+    },
+    "jinja2": {
+      "actual": "2.11.3",
+      "expected": "2.11.3",
+      "matches": true
+    },
+    "joblib": {
+      "actual": "1.2.0",
+      "expected": "1.2.0",
+      "matches": true
+    },
+    "markupsafe": {
+      "actual": "1.1.1",
+      "expected": "1.1.1",
+      "matches": true
+    },
+    "mpmath": {
+      "actual": "1.3.0",
+      "expected": "1.3.0",
+      "matches": true
+    },
+    "numpy": {
+      "actual": "1.22.3",
+      "expected": "1.22.3",
+      "matches": true
+    },
+    "packaging": {
+      "actual": "23.1",
+      "expected": "23.1",
+      "matches": true
+    },
+    "pandas": {
+      "actual": "1.4.3",
+      "expected": "1.4.3",
+      "matches": true
+    },
+    "pyarrow": {
+      "actual": "11.0.0",
+      "expected": "11.0.0",
+      "matches": true
+    },
+    "pyparsing": {
+      "actual": "3.0.9",
+      "expected": "3.0.9",
+      "matches": true
+    },
+    "python-dateutil": {
+      "actual": "2.8.2",
+      "expected": "2.8.2",
+      "matches": true
+    },
+    "pytz": {
+      "actual": "2023.3",
+      "expected": "2023.3",
+      "matches": true
+    },
+    "scipy": {
+      "actual": "1.8.1",
+      "expected": "1.8.1",
+      "matches": true
+    },
+    "setuptools": {
+      "actual": "67.8.0",
+      "expected": "67.8.0",
+      "matches": true
+    },
+    "six": {
+      "actual": "1.16.0",
+      "expected": "1.16.0",
+      "matches": true
+    },
+    "sympy": {
+      "actual": "1.12",
+      "expected": "1.12",
+      "matches": true
+    },
+    "wheel": {
+      "actual": "0.38.4",
+      "expected": "0.38.4",
+      "matches": true
+    }
+  },
+  "platform": "Linux-5.15.0-194-generic-x86_64-with-glibc2.35",
+  "python": "3.10.12",
+  "python_executable": "/data/digital-drosophila/experiments/phase4ad-author-semantics/environment/.venv/bin/python",
+  "python_patch_matches": false
+}

registry/phase4ad-author-semantics/evidence/oracle/feedforward-float32/generated-code.json

@@ -0,0 +1,127 @@
+[
+  {
+    "active": true,
+    "code_objects": [],
+    "name": "default_neurons",
+    "order": 0,
+    "type": "NeuronGroup",
+    "when": "start"
+  },
+  {
+    "active": true,
+    "code_objects": [],
+    "name": "default_synapses",
+    "order": 0,
+    "type": "Synapses",
+    "when": "start"
+  },
+  {
+    "abstract_code": "not_refractory = timestep(t - lastspike, dt) >= timestep(rfc, dt)\n_g = g*exp(-dt*int(not_refractory)/tau)\n_v = g*tau*(-exp(dt*int(not_refractory)/t_mbr) + exp(dt*int(not_refractory)/tau))*exp(-dt*int(not_refractory)/t_mbr)*exp(-dt*int(not_refractory)/tau)/(t_mbr - tau) + v*exp(-dt*int(not_refractory)/t_mbr) + v_0 - v_0*exp(-dt*int(not_refractory)/t_mbr)\ng = _g\nv = _v",
+    "active": true,
+    "code_objects": [
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # scalar code\n    _vectorisation_idx = 1\n    dt = _array_defaultclock_dt[0]\n    _lio_1 = (- dt) / tau\n    _lio_2 = exp(_lio_1)\n    _lio_3 = tau / (t_mbr - tau)\n    _lio_4 = dt / t_mbr\n    _lio_5 = dt / tau\n    _lio_6 = (- dt) / t_mbr\n    _lio_7 = v_0 - v_0\n    _lio_8 = v_0 - (v_0 * exp(_lio_6))\n    _lio_9 = ((_lio_3 * ((- exp(_lio_4)) + exp(_lio_5))) * exp(_lio_6)) * exp(_lio_1)\n    _lio_10 = exp(_lio_6)\n    # vector code\n    _vectorisation_idx = LazyArange(N)\n    g = _array_default_neurons_g.copy()\n    t = _array_defaultclock_t[0]\n    dt = _array_defaultclock_dt[0]\n    rfc = _array_default_neurons_rfc\n    v = _array_default_neurons_v.copy()\n    lastspike = _array_default_neurons_lastspike\n    not_refractory = _array_default_neurons_not_refractory.copy()\n    not_refractory = timestep(t - lastspike, dt) >= timestep(rfc, dt)\n    _g = _numpy.where(not_refractory, _lio_2 * g, g)\n    _v = _numpy.where(not_refractory, _lio_8 + ((_lio_9 * g) + (_lio_10 * v)), _lio_7 + v)\n    g[not_refractory] = _g[not_refractory]\n    v[not_refractory] = _v[not_refractory]\n    _array_default_neurons_g[:] = g\n    _array_default_neurons_v[:] = v\n    _array_default_neurons_not_refractory[:] = not_refractory\n",
+        "name": "default_neurons_stateupdater_codeobject_6",
+        "type": "CallableProxyType"
+      }
+    ],
+    "name": "default_neurons_stateupdater",
+    "order": 0,
+    "type": "StateUpdater",
+    "user_code": "g = -g*int(not_refractory)/tau\nv = (g - v + v_0)*int(not_refractory)/t_mbr",
+    "when": "groups"
+  },
+  {
+    "active": true,
+    "code_objects": [],
+    "name": "oracle_seed_injection",
+    "order": 0,
+    "type": "NetworkOperation",
+    "when": "before_thresholds"
+  },
+  {
+    "abstract_code": "_cond = (v > v_th) and not_refractory",
+    "active": true,
+    "code_objects": [
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _array_default_neurons__spikespace[-1] = 0\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    numpy_True = _numpy.bool_(True)\n    numpy_False = _numpy.bool_(False)\n    # scalar code\n    _vectorisation_idx = 1\n    # vector code\n    _vectorisation_idx = LazyArange(N)\n    v = _array_default_neurons_v\n    not_refractory = _array_default_neurons_not_refractory\n    _cond = (v > v_th) & not_refractory\n    if _cond is True or _cond is numpy_True:\n        _events = _numpy.arange(N)\n    elif _cond is False or _cond is numpy_False:\n        _events = _numpy.array([])\n    else:\n        _events, = _cond.nonzero()\n    _array_default_neurons__spikespace[-1] = len(_events)\n    _array_default_neurons__spikespace[:len(_events)] = _events\n    # Set the neuron to refractory\n    _array_default_neurons_not_refractory[_events] = False\n    _array_default_neurons_lastspike[_events] = _array_defaultclock_t[0]\n",
+        "name": "default_neurons_spike_thresholder_codeobject_7",
+        "type": "CallableProxyType"
+      }
+    ],
+    "name": "default_neurons_spike_thresholder",
+    "order": 0,
+    "type": "Thresholder",
+    "user_code": "_cond = v > v_th",
+    "when": "thresholds"
+  },
+  {
+    "abstract_code": "_to_record_i = _source_i\n_to_record_t = _source_t",
+    "active": true,
+    "code_objects": [
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _n_events = _array_default_neurons__spikespace[-1]\n    if _n_events > 0:\n        _events = _array_default_neurons__spikespace[:_n_events]\n        # Take subgroups into account\n        if _source_start != 0 or _source_stop != _source_N:\n            _events = _events[(_events >= _source_start) & (_events < _source_stop)]\n            _n_events = len(_events)\n        if _n_events > 0:\n            _vectorisation_idx = 1\n            _curlen = _array_spikemonitor_N[0]\n            _newlen = _curlen + _n_events\n            _owner.resize(_newlen)\n            _array_spikemonitor_N[0] = _newlen\n            _vectorisation_idx = _events\n            _idx = _events\n            _source_i = _array_default_neurons_i[_idx]\n            _source_t = _array_defaultclock_t[0]\n            _to_record_i = _source_i\n            _to_record_t = _source_t\n            _dynamic_array_spikemonitor_t[_curlen:_newlen] = _to_record_t\n            _dynamic_array_spikemonitor_i[_curlen:_newlen] = _to_record_i\n            _array_spikemonitor_count[_events - _source_start] += 1\n",
+        "name": "spikemonitor_codeobject",
+        "type": "CallableProxyType"
+      }
+    ],
+    "name": "spikemonitor",
+    "order": 1,
+    "type": "SpikeMonitor",
+    "user_code": "None",
+    "when": "thresholds"
+  },
+  {
+    "abstract_code": "g += w\n",
+    "active": true,
+    "code_objects": [
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _owner.initialise_queue()\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _owner.push_spikes()\n",
+        "name": "default_synapses_pre_push_spikes",
+        "type": "CallableProxyType"
+      },
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _spiking_synapses = _queue.peek()\n    if len(_spiking_synapses):\n        # scalar code\n        # vector code\n        _idx = _spiking_synapses\n        _vectorisation_idx = _idx\n        #  Abstract code:  g += w\n        _postsynaptic_idx = _array_default_synapses__synaptic_post[_idx]\n        w = _array_default_synapses_w[_idx]\n        not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n        _numpy.add.at(_array_default_neurons_g, _postsynaptic_idx[not_refractory], w[not_refractory])\n    # Advance the spike queue\n    _queue.advance()\n",
+        "name": "default_synapses_pre_codeobject_7",
+        "type": "CallableProxyType"
+      }
+    ],
+    "name": "default_synapses_pre",
+    "order": -1,
+    "type": "SynapticPathway",
+    "user_code": "None",
+    "when": "synapses"
+  },
+  {
+    "abstract_code": "v = v_rst; w = 0; g = 0 * mV",
+    "active": true,
+    "code_objects": [
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # scalar code\n    _vectorisation_idx = 1\n    w = 0\n    # vector code\n    _idx = _array_default_neurons__spikespace[:_array_default_neurons__spikespace[-1]]\n    _vectorisation_idx = _idx\n    v = v_rst\n    g = 0.0\n    _array_default_neurons_g[_idx] = g\n    _array_default_neurons_v[_idx] = v\n",
+        "name": "default_neurons_spike_resetter_codeobject_7",
+        "type": "CallableProxyType"
+      }
+    ],
+    "name": "default_neurons_spike_resetter",
+    "order": 0,
+    "type": "Resetter",
+    "user_code": "None",
+    "when": "resets"
+  },
+  {
+    "abstract_code": "_to_record_v = _source_v\n_to_record_g = _source_g\n_to_record_lastspike = _source_lastspike\n_to_record_not_refractory = _source_not_refractory",
+    "active": true,
+    "code_objects": [
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # Resize dynamic arrays\n    _new_len = len(_dynamic_array_oracle_end_state_t) + 1\n    _owner.resize(_new_len)\n    # Store values\n    _dynamic_array_oracle_end_state_t[-1] = _array_defaultclock_t[0]\n    # scalar code\n    _vectorisation_idx = 1\n    # vector code\n    _vectorisation_idx = _array_oracle_end_state__indices\n    _idx = _array_oracle_end_state__indices\n    _source_not_refractory = _array_default_neurons_not_refractory[_idx]\n    _source_g = _array_default_neurons_g[_idx]\n    _source_v = _array_default_neurons_v[_idx]\n    _source_lastspike = _array_default_neurons_lastspike[_idx]\n    _to_record_v = _source_v\n    _to_record_g = _source_g\n    _to_record_lastspike = _source_lastspike\n    _to_record_not_refractory = _source_not_refractory\n    _dynamic_array_oracle_end_state_v[-1, :] = _to_record_v\n    _dynamic_array_oracle_end_state_g[-1, :] = _to_record_g\n    _dynamic_array_oracle_end_state_lastspike[-1, :] = _to_record_lastspike\n    _dynamic_array_oracle_end_state_not_refractory[-1, :] = _to_record_not_refractory\n",
+        "name": "oracle_end_state_codeobject",
+        "type": "CallableProxyType"
+      }
+    ],
+    "name": "oracle_end_state",
+    "order": 0,
+    "type": "StateMonitor",
+    "user_code": "None",
+    "when": "end"
+  }
+]

registry/phase4ad-author-semantics/evidence/oracle/feedforward-float32/independent-output/events.csv

@@ -0,0 +1,4 @@
+step,neuron_idx
+0,1381
+51,1511
+104,1197

registry/phase4ad-author-semantics/evidence/oracle/feedforward-float32/run-spec.json

@@ -0,0 +1,123 @@
+{
+  "author_commit": "91bdd1e7dcf193f3e7ca5a8933497fcef63b7960",
+  "author_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e",
+  "config": {
+    "author_precisions": [
+      "float64",
+      "float32"
+    ],
+    "comparison": {
+      "exact_spike_events_required_for_oracle_validation": true,
+      "float32_state_max_abs_tolerance_mv": 0.001,
+      "float64_state_max_abs_tolerance_mv": 1e-08,
+      "precision_cross_comparison_may_diverge_but_must_be_reported": true
+    },
+    "component_policies": [
+      "frozen",
+      "reset_g_only",
+      "refractory_gate_only",
+      "reset_and_refractory"
+    ],
+    "dt_ms": 0.1,
+    "duration_ms": 1000.0,
+    "experiment": "experiments/phase4ad-author-semantics",
+    "human_authorization": "\u5141\u8bb8\u72ec\u7acb\u65b0\u6a21\u578b\u5206\u652f\u6d4b\u8bd5\u52a8\u529b\u5b66\u5047\u8bbe",
+    "late_start_ms": 500.0,
+    "model": {
+      "dt_ms": 0.1,
+      "membrane_tau_ms": 20.0,
+      "refractory_ms": 2.2,
+      "reset_potential_mv": -52.0,
+      "resting_potential_mv": -52.0,
+      "synaptic_delay_ms": 1.8,
+      "synaptic_tau_ms": 5.0,
+      "threshold_mv": -45.0,
+      "w_syn_mv_per_anatomical_synapse": 0.275
+    },
+    "model_directory": "models/male-cns-lif/author-semantics-lab-v1",
+    "motifs": [
+      "pair",
+      "trio",
+      "five",
+      "feedforward",
+      "no_input"
+    ],
+    "name": "author-semantics-lab-v1",
+    "no_training_or_candidate": true,
+    "phase": "4AD",
+    "prior_experiment": "experiments/phase4ac-lif-semantics",
+    "prior_model": "models/male-cns-lif/lif-semantics-audit-v1",
+    "root": "/data/digital-drosophila",
+    "seed_margin_mv": 1.0,
+    "seed_node": 1381
+  },
+  "delay_steps": 18,
+  "dt_ms": 0.1,
+  "edge_ids": [
+    1337065,
+    1467355,
+    1559765,
+    20992891
+  ],
+  "external_arrivals": {
+    "events": 0,
+    "ordering": "after default_synapses.pre"
+  },
+  "internal_voltage_unit": "volt",
+  "nodes": [
+    1197,
+    1381,
+    1511,
+    82312,
+    133666
+  ],
+  "parameter_checks": {
+    "membrane_tau_ms": {
+      "author": 20.0,
+      "config": 20.0
+    },
+    "refractory_ms": {
+      "author": 2.2,
+      "config": 2.2
+    },
+    "reset_potential_mv": {
+      "author": -52.0,
+      "config": -52.0
+    },
+    "resting_potential_mv": {
+      "author": -52.0,
+      "config": -52.0
+    },
+    "synaptic_delay_ms": {
+      "author": 1.8,
+      "config": 1.8
+    },
+    "synaptic_tau_ms": {
+      "author": 5.0,
+      "config": 5.0
+    },
+    "threshold_mv": {
+      "author": -45.0,
+      "config": -45.0
+    },
+    "w_syn_mv_per_anatomical_synapse": {
+      "author": 0.275,
+      "config": 0.275
+    }
+  },
+  "precision": "float32",
+  "preferences": {
+    "codegen.target": "numpy",
+    "core.default_float_dtype": "float32",
+    "legacy.refractory_timing": false
+  },
+  "refractory_steps": 22,
+  "returned_voltage_unit": "mV",
+  "seed": {
+    "injections": 0,
+    "margin_mv": 1.0,
+    "requested_global_node": 1381
+  },
+  "steps": 10000,
+  "weight_rule": "raw_count multiplied by unchanged author w_syn; no sign inference"
+}

registry/phase4ad-author-semantics/evidence/oracle/feedforward-float32/schedule.json

@@ -0,0 +1,11 @@
+{
+  "schedule": [
+    "start",
+    "groups",
+    "thresholds",
+    "synapses",
+    "resets",
+    "end"
+  ],
+  "summary": "                    object                      |             part of             |       Clock dt       |       when        | order | active\n------------------------------------------------+---------------------------------+----------------------+-------------------+-------+-------\ndefault_neurons_stateupdater (StateUpdater)     | default_neurons (NeuronGroup)   | 100. us (every step) | groups            |     0 |  yes  \noracle_seed_injection (NetworkOperation)        | --                              | 100. us (every step) | before_thresholds |     0 |  yes  \ndefault_neurons_spike_thresholder (Thresholder) | default_neurons (NeuronGroup)   | 100. us (every step) | thresholds        |     0 |  yes  \nspikemonitor (SpikeMonitor)                     | spikemonitor (SpikeMonitor)     | 100. us (every step) | thresholds        |     1 |  yes  \ndefault_synapses_pre (SynapticPathway)          | default_synapses (Synapses)     | 100. us (every step) | synapses          |    -1 |  yes  \ndefault_neurons_spike_resetter (Resetter)       | default_neurons (NeuronGroup)   | 100. us (every step) | resets            |     0 |  yes  \noracle_end_state (StateMonitor)                 | oracle_end_state (StateMonitor) | 100. us (every step) | end               |     0 |  yes  "
+}

registry/phase4ad-author-semantics/evidence/oracle/feedforward-float32/seed.json

@@ -0,0 +1,7 @@
+{
+  "applied_mv": -43.99999976158142,
+  "injections": 1,
+  "margin_mv": 1.0,
+  "requested_global_node": 1381,
+  "spiked_at_zero": true
+}

registry/phase4ad-author-semantics/evidence/oracle/feedforward-float64-repeat/actual-weights.json

@@ -0,0 +1,20 @@
+{
+  "edge_id": [
+    1337065,
+    1467355,
+    1559765,
+    20992891
+  ],
+  "weights_mv": [
+    28.6,
+    64.625,
+    62.150000000000006,
+    11.825000000000001
+  ],
+  "weights_volt": [
+    0.0286,
+    0.064625,
+    0.062150000000000004,
+    0.011825
+  ]
+}

registry/phase4ad-author-semantics/evidence/oracle/feedforward-float64-repeat/brian-output/events.csv

@@ -0,0 +1,4 @@
+step,neuron_idx
+0,1381
+51,1511
+104,1197

registry/phase4ad-author-semantics/evidence/oracle/feedforward-float64-repeat/completeness.csv

@@ -0,0 +1,6 @@
+global_neuron_idx,local_index
+1197,0
+1381,1
+1511,2
+82312,3
+133666,4

registry/phase4ad-author-semantics/evidence/oracle/feedforward-float64-repeat/environment.json

@@ -0,0 +1,102 @@
+{
+  "all_package_pins_match": true,
+  "author_platform": "Windows",
+  "author_python": "3.10.11",
+  "binary_identical_author_environment_claimed": false,
+  "packages": {
+    "brian2": {
+      "actual": "2.5.1",
+      "expected": "2.5.1",
+      "matches": true
+    },
+    "cython": {
+      "actual": "0.29.33",
+      "expected": "0.29.33",
+      "matches": true
+    },
+    "jinja2": {
+      "actual": "2.11.3",
+      "expected": "2.11.3",
+      "matches": true
+    },
+    "joblib": {
+      "actual": "1.2.0",
+      "expected": "1.2.0",
+      "matches": true
+    },
+    "markupsafe": {
+      "actual": "1.1.1",
+      "expected": "1.1.1",
+      "matches": true
+    },
+    "mpmath": {
+      "actual": "1.3.0",
+      "expected": "1.3.0",
+      "matches": true
+    },
+    "numpy": {
+      "actual": "1.22.3",
+      "expected": "1.22.3",
+      "matches": true
+    },
+    "packaging": {
+      "actual": "23.1",
+      "expected": "23.1",
+      "matches": true
+    },
+    "pandas": {
+      "actual": "1.4.3",
+      "expected": "1.4.3",
+      "matches": true
+    },
+    "pyarrow": {
+      "actual": "11.0.0",
+      "expected": "11.0.0",
+      "matches": true
+    },
+    "pyparsing": {
+      "actual": "3.0.9",
+      "expected": "3.0.9",
+      "matches": true
+    },
+    "python-dateutil": {
+      "actual": "2.8.2",
+      "expected": "2.8.2",
+      "matches": true
+    },
+    "pytz": {
+      "actual": "2023.3",
+      "expected": "2023.3",
+      "matches": true
+    },
+    "scipy": {
+      "actual": "1.8.1",
+      "expected": "1.8.1",
+      "matches": true
+    },
+    "setuptools": {
+      "actual": "67.8.0",
+      "expected": "67.8.0",
+      "matches": true
+    },
+    "six": {
+      "actual": "1.16.0",
+      "expected": "1.16.0",
+      "matches": true
+    },
+    "sympy": {
+      "actual": "1.12",
+      "expected": "1.12",
+      "matches": true
+    },
+    "wheel": {
+      "actual": "0.38.4",
+      "expected": "0.38.4",
+      "matches": true
+    }
+  },
+  "platform": "Linux-5.15.0-194-generic-x86_64-with-glibc2.35",
+  "python": "3.10.12",
+  "python_executable": "/data/digital-drosophila/experiments/phase4ad-author-semantics/environment/.venv/bin/python",
+  "python_patch_matches": false
+}

registry/phase4ad-author-semantics/evidence/oracle/feedforward-float64-repeat/generated-code.json

@@ -0,0 +1,127 @@
+[
+  {
+    "active": true,
+    "code_objects": [],
+    "name": "default_neurons",
+    "order": 0,
+    "type": "NeuronGroup",
+    "when": "start"
+  },
+  {
+    "active": true,
+    "code_objects": [],
+    "name": "default_synapses",
+    "order": 0,
+    "type": "Synapses",
+    "when": "start"
+  },
+  {
+    "abstract_code": "not_refractory = timestep(t - lastspike, dt) >= timestep(rfc, dt)\n_g = g*exp(-dt*int(not_refractory)/tau)\n_v = g*tau*(-exp(dt*int(not_refractory)/t_mbr) + exp(dt*int(not_refractory)/tau))*exp(-dt*int(not_refractory)/t_mbr)*exp(-dt*int(not_refractory)/tau)/(t_mbr - tau) + v*exp(-dt*int(not_refractory)/t_mbr) + v_0 - v_0*exp(-dt*int(not_refractory)/t_mbr)\ng = _g\nv = _v",
+    "active": true,
+    "code_objects": [
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # scalar code\n    _vectorisation_idx = 1\n    dt = _array_defaultclock_dt[0]\n    _lio_1 = (- dt) / tau\n    _lio_2 = exp(_lio_1)\n    _lio_3 = tau / (t_mbr - tau)\n    _lio_4 = dt / t_mbr\n    _lio_5 = dt / tau\n    _lio_6 = (- dt) / t_mbr\n    _lio_7 = v_0 - v_0\n    _lio_8 = v_0 - (v_0 * exp(_lio_6))\n    _lio_9 = ((_lio_3 * ((- exp(_lio_4)) + exp(_lio_5))) * exp(_lio_6)) * exp(_lio_1)\n    _lio_10 = exp(_lio_6)\n    # vector code\n    _vectorisation_idx = LazyArange(N)\n    g = _array_default_neurons_g.copy()\n    t = _array_defaultclock_t[0]\n    dt = _array_defaultclock_dt[0]\n    rfc = _array_default_neurons_rfc\n    v = _array_default_neurons_v.copy()\n    lastspike = _array_default_neurons_lastspike\n    not_refractory = _array_default_neurons_not_refractory.copy()\n    not_refractory = timestep(t - lastspike, dt) >= timestep(rfc, dt)\n    _g = _numpy.where(not_refractory, _lio_2 * g, g)\n    _v = _numpy.where(not_refractory, _lio_8 + ((_lio_9 * g) + (_lio_10 * v)), _lio_7 + v)\n    g[not_refractory] = _g[not_refractory]\n    v[not_refractory] = _v[not_refractory]\n    _array_default_neurons_g[:] = g\n    _array_default_neurons_v[:] = v\n    _array_default_neurons_not_refractory[:] = not_refractory\n",
+        "name": "default_neurons_stateupdater_codeobject_5",
+        "type": "CallableProxyType"
+      }
+    ],
+    "name": "default_neurons_stateupdater",
+    "order": 0,
+    "type": "StateUpdater",
+    "user_code": "g = -g*int(not_refractory)/tau\nv = (g - v + v_0)*int(not_refractory)/t_mbr",
+    "when": "groups"
+  },
+  {
+    "active": true,
+    "code_objects": [],
+    "name": "oracle_seed_injection",
+    "order": 0,
+    "type": "NetworkOperation",
+    "when": "before_thresholds"
+  },
+  {
+    "abstract_code": "_cond = (v > v_th) and not_refractory",
+    "active": true,
+    "code_objects": [
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _array_default_neurons__spikespace[-1] = 0\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    numpy_True = _numpy.bool_(True)\n    numpy_False = _numpy.bool_(False)\n    # scalar code\n    _vectorisation_idx = 1\n    # vector code\n    _vectorisation_idx = LazyArange(N)\n    v = _array_default_neurons_v\n    not_refractory = _array_default_neurons_not_refractory\n    _cond = (v > v_th) & not_refractory\n    if _cond is True or _cond is numpy_True:\n        _events = _numpy.arange(N)\n    elif _cond is False or _cond is numpy_False:\n        _events = _numpy.array([])\n    else:\n        _events, = _cond.nonzero()\n    _array_default_neurons__spikespace[-1] = len(_events)\n    _array_default_neurons__spikespace[:len(_events)] = _events\n    # Set the neuron to refractory\n    _array_default_neurons_not_refractory[_events] = False\n    _array_default_neurons_lastspike[_events] = _array_defaultclock_t[0]\n",
+        "name": "default_neurons_spike_thresholder_codeobject_6",
+        "type": "CallableProxyType"
+      }
+    ],
+    "name": "default_neurons_spike_thresholder",
+    "order": 0,
+    "type": "Thresholder",
+    "user_code": "_cond = v > v_th",
+    "when": "thresholds"
+  },
+  {
+    "abstract_code": "_to_record_i = _source_i\n_to_record_t = _source_t",
+    "active": true,
+    "code_objects": [
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _n_events = _array_default_neurons__spikespace[-1]\n    if _n_events > 0:\n        _events = _array_default_neurons__spikespace[:_n_events]\n        # Take subgroups into account\n        if _source_start != 0 or _source_stop != _source_N:\n            _events = _events[(_events >= _source_start) & (_events < _source_stop)]\n            _n_events = len(_events)\n        if _n_events > 0:\n            _vectorisation_idx = 1\n            _curlen = _array_spikemonitor_N[0]\n            _newlen = _curlen + _n_events\n            _owner.resize(_newlen)\n            _array_spikemonitor_N[0] = _newlen\n            _vectorisation_idx = _events\n            _idx = _events\n            _source_i = _array_default_neurons_i[_idx]\n            _source_t = _array_defaultclock_t[0]\n            _to_record_i = _source_i\n            _to_record_t = _source_t\n            _dynamic_array_spikemonitor_t[_curlen:_newlen] = _to_record_t\n            _dynamic_array_spikemonitor_i[_curlen:_newlen] = _to_record_i\n            _array_spikemonitor_count[_events - _source_start] += 1\n",
+        "name": "spikemonitor_codeobject",
+        "type": "CallableProxyType"
+      }
+    ],
+    "name": "spikemonitor",
+    "order": 1,
+    "type": "SpikeMonitor",
+    "user_code": "None",
+    "when": "thresholds"
+  },
+  {
+    "abstract_code": "g += w\n",
+    "active": true,
+    "code_objects": [
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _owner.initialise_queue()\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _owner.push_spikes()\n",
+        "name": "default_synapses_pre_push_spikes",
+        "type": "CallableProxyType"
+      },
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _spiking_synapses = _queue.peek()\n    if len(_spiking_synapses):\n        # scalar code\n        # vector code\n        _idx = _spiking_synapses\n        _vectorisation_idx = _idx\n        #  Abstract code:  g += w\n        _postsynaptic_idx = _array_default_synapses__synaptic_post[_idx]\n        w = _array_default_synapses_w[_idx]\n        not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n        _numpy.add.at(_array_default_neurons_g, _postsynaptic_idx[not_refractory], w[not_refractory])\n    # Advance the spike queue\n    _queue.advance()\n",
+        "name": "default_synapses_pre_codeobject_6",
+        "type": "CallableProxyType"
+      }
+    ],
+    "name": "default_synapses_pre",
+    "order": -1,
+    "type": "SynapticPathway",
+    "user_code": "None",
+    "when": "synapses"
+  },
+  {
+    "abstract_code": "v = v_rst; w = 0; g = 0 * mV",
+    "active": true,
+    "code_objects": [
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # scalar code\n    _vectorisation_idx = 1\n    w = 0\n    # vector code\n    _idx = _array_default_neurons__spikespace[:_array_default_neurons__spikespace[-1]]\n    _vectorisation_idx = _idx\n    v = v_rst\n    g = 0.0\n    _array_default_neurons_g[_idx] = g\n    _array_default_neurons_v[_idx] = v\n",
+        "name": "default_neurons_spike_resetter_codeobject_6",
+        "type": "CallableProxyType"
+      }
+    ],
+    "name": "default_neurons_spike_resetter",
+    "order": 0,
+    "type": "Resetter",
+    "user_code": "None",
+    "when": "resets"
+  },
+  {
+    "abstract_code": "_to_record_v = _source_v\n_to_record_g = _source_g\n_to_record_lastspike = _source_lastspike\n_to_record_not_refractory = _source_not_refractory",
+    "active": true,
+    "code_objects": [
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # Resize dynamic arrays\n    _new_len = len(_dynamic_array_oracle_end_state_t) + 1\n    _owner.resize(_new_len)\n    # Store values\n    _dynamic_array_oracle_end_state_t[-1] = _array_defaultclock_t[0]\n    # scalar code\n    _vectorisation_idx = 1\n    # vector code\n    _vectorisation_idx = _array_oracle_end_state__indices\n    _idx = _array_oracle_end_state__indices\n    _source_not_refractory = _array_default_neurons_not_refractory[_idx]\n    _source_g = _array_default_neurons_g[_idx]\n    _source_v = _array_default_neurons_v[_idx]\n    _source_lastspike = _array_default_neurons_lastspike[_idx]\n    _to_record_v = _source_v\n    _to_record_g = _source_g\n    _to_record_lastspike = _source_lastspike\n    _to_record_not_refractory = _source_not_refractory\n    _dynamic_array_oracle_end_state_v[-1, :] = _to_record_v\n    _dynamic_array_oracle_end_state_g[-1, :] = _to_record_g\n    _dynamic_array_oracle_end_state_lastspike[-1, :] = _to_record_lastspike\n    _dynamic_array_oracle_end_state_not_refractory[-1, :] = _to_record_not_refractory\n",
+        "name": "oracle_end_state_codeobject",
+        "type": "CallableProxyType"
+      }
+    ],
+    "name": "oracle_end_state",
+    "order": 0,
+    "type": "StateMonitor",
+    "user_code": "None",
+    "when": "end"
+  }
+]

registry/phase4ad-author-semantics/evidence/oracle/feedforward-float64-repeat/run-spec.json

@@ -0,0 +1,123 @@
+{
+  "author_commit": "91bdd1e7dcf193f3e7ca5a8933497fcef63b7960",
+  "author_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e",
+  "config": {
+    "author_precisions": [
+      "float64",
+      "float32"
+    ],
+    "comparison": {
+      "exact_spike_events_required_for_oracle_validation": true,
+      "float32_state_max_abs_tolerance_mv": 0.001,
+      "float64_state_max_abs_tolerance_mv": 1e-08,
+      "precision_cross_comparison_may_diverge_but_must_be_reported": true
+    },
+    "component_policies": [
+      "frozen",
+      "reset_g_only",
+      "refractory_gate_only",
+      "reset_and_refractory"
+    ],
+    "dt_ms": 0.1,
+    "duration_ms": 1000.0,
+    "experiment": "experiments/phase4ad-author-semantics",
+    "human_authorization": "\u5141\u8bb8\u72ec\u7acb\u65b0\u6a21\u578b\u5206\u652f\u6d4b\u8bd5\u52a8\u529b\u5b66\u5047\u8bbe",
+    "late_start_ms": 500.0,
+    "model": {
+      "dt_ms": 0.1,
+      "membrane_tau_ms": 20.0,
+      "refractory_ms": 2.2,
+      "reset_potential_mv": -52.0,
+      "resting_potential_mv": -52.0,
+      "synaptic_delay_ms": 1.8,
+      "synaptic_tau_ms": 5.0,
+      "threshold_mv": -45.0,
+      "w_syn_mv_per_anatomical_synapse": 0.275
+    },
+    "model_directory": "models/male-cns-lif/author-semantics-lab-v1",
+    "motifs": [
+      "pair",
+      "trio",
+      "five",
+      "feedforward",
+      "no_input"
+    ],
+    "name": "author-semantics-lab-v1",
+    "no_training_or_candidate": true,
+    "phase": "4AD",
+    "prior_experiment": "experiments/phase4ac-lif-semantics",
+    "prior_model": "models/male-cns-lif/lif-semantics-audit-v1",
+    "root": "/data/digital-drosophila",
+    "seed_margin_mv": 1.0,
+    "seed_node": 1381
+  },
+  "delay_steps": 18,
+  "dt_ms": 0.1,
+  "edge_ids": [
+    1337065,
+    1467355,
+    1559765,
+    20992891
+  ],
+  "external_arrivals": {
+    "events": 0,
+    "ordering": "after default_synapses.pre"
+  },
+  "internal_voltage_unit": "volt",
+  "nodes": [
+    1197,
+    1381,
+    1511,
+    82312,
+    133666
+  ],
+  "parameter_checks": {
+    "membrane_tau_ms": {
+      "author": 20.0,
+      "config": 20.0
+    },
+    "refractory_ms": {
+      "author": 2.2,
+      "config": 2.2
+    },
+    "reset_potential_mv": {
+      "author": -52.0,
+      "config": -52.0
+    },
+    "resting_potential_mv": {
+      "author": -52.0,
+      "config": -52.0
+    },
+    "synaptic_delay_ms": {
+      "author": 1.8,
+      "config": 1.8
+    },
+    "synaptic_tau_ms": {
+      "author": 5.0,
+      "config": 5.0
+    },
+    "threshold_mv": {
+      "author": -45.0,
+      "config": -45.0
+    },
+    "w_syn_mv_per_anatomical_synapse": {
+      "author": 0.275,
+      "config": 0.275
+    }
+  },
+  "precision": "float64",
+  "preferences": {
+    "codegen.target": "numpy",
+    "core.default_float_dtype": "float64",
+    "legacy.refractory_timing": false
+  },
+  "refractory_steps": 22,
+  "returned_voltage_unit": "mV",
+  "seed": {
+    "injections": 0,
+    "margin_mv": 1.0,
+    "requested_global_node": 1381
+  },
+  "steps": 10000,
+  "weight_rule": "raw_count multiplied by unchanged author w_syn; no sign inference"
+}

registry/phase4ad-author-semantics/evidence/oracle/feedforward-float64-repeat/schedule.json

@@ -0,0 +1,11 @@
+{
+  "schedule": [
+    "start",
+    "groups",
+    "thresholds",
+    "synapses",
+    "resets",
+    "end"
+  ],
+  "summary": "                    object                      |             part of             |       Clock dt       |       when        | order | active\n------------------------------------------------+---------------------------------+----------------------+-------------------+-------+-------\ndefault_neurons_stateupdater (StateUpdater)     | default_neurons (NeuronGroup)   | 100. us (every step) | groups            |     0 |  yes  \noracle_seed_injection (NetworkOperation)        | --                              | 100. us (every step) | before_thresholds |     0 |  yes  \ndefault_neurons_spike_thresholder (Thresholder) | default_neurons (NeuronGroup)   | 100. us (every step) | thresholds        |     0 |  yes  \nspikemonitor (SpikeMonitor)                     | spikemonitor (SpikeMonitor)     | 100. us (every step) | thresholds        |     1 |  yes  \ndefault_synapses_pre (SynapticPathway)          | default_synapses (Synapses)     | 100. us (every step) | synapses          |    -1 |  yes  \ndefault_neurons_spike_resetter (Resetter)       | default_neurons (NeuronGroup)   | 100. us (every step) | resets            |     0 |  yes  \noracle_end_state (StateMonitor)                 | oracle_end_state (StateMonitor) | 100. us (every step) | end               |     0 |  yes  "
+}

registry/phase4ad-author-semantics/evidence/oracle/feedforward-float64-repeat/seed.json

@@ -0,0 +1,7 @@
+{
+  "applied_mv": -44.0,
+  "injections": 1,
+  "margin_mv": 1.0,
+  "requested_global_node": 1381,
+  "spiked_at_zero": true
+}

registry/phase4ad-author-semantics/evidence/oracle/feedforward-float64/actual-weights.json

@@ -0,0 +1,20 @@
+{
+  "edge_id": [
+    1337065,
+    1467355,
+    1559765,
+    20992891
+  ],
+  "weights_mv": [
+    28.6,
+    64.625,
+    62.150000000000006,
+    11.825000000000001
+  ],
+  "weights_volt": [
+    0.0286,
+    0.064625,
+    0.062150000000000004,
+    0.011825
+  ]
+}

registry/phase4ad-author-semantics/evidence/oracle/feedforward-float64/brian-output/events.csv

@@ -0,0 +1,4 @@
+step,neuron_idx
+0,1381
+51,1511
+104,1197

registry/phase4ad-author-semantics/evidence/oracle/feedforward-float64/comparison.json

@@ -0,0 +1,11 @@
+{
+  "exact_events": true,
+  "exact_counts": true,
+  "ref_exact": true,
+  "max_abs_mv": 3.765876499528531e-13,
+  "mean_abs_mv": 3.893371799264915e-14,
+  "same_event_prefix_max_abs_mv": 3.765876499528531e-13,
+  "first_event_divergence_step": null,
+  "tolerance_mv": 1e-08,
+  "pass_oracle": true
+}

registry/phase4ad-author-semantics/evidence/oracle/feedforward-float64/completeness.csv

@@ -0,0 +1,6 @@
+global_neuron_idx,local_index
+1197,0
+1381,1
+1511,2
+82312,3
+133666,4

registry/phase4ad-author-semantics/evidence/oracle/feedforward-float64/environment.json

@@ -0,0 +1,102 @@
+{
+  "all_package_pins_match": true,
+  "author_platform": "Windows",
+  "author_python": "3.10.11",
+  "binary_identical_author_environment_claimed": false,
+  "packages": {
+    "brian2": {
+      "actual": "2.5.1",
+      "expected": "2.5.1",
+      "matches": true
+    },
+    "cython": {
+      "actual": "0.29.33",
+      "expected": "0.29.33",
+      "matches": true
+    },
+    "jinja2": {
+      "actual": "2.11.3",
+      "expected": "2.11.3",
+      "matches": true
+    },
+    "joblib": {
+      "actual": "1.2.0",
+      "expected": "1.2.0",
+      "matches": true
+    },
+    "markupsafe": {
+      "actual": "1.1.1",
+      "expected": "1.1.1",
+      "matches": true
+    },
+    "mpmath": {
+      "actual": "1.3.0",
+      "expected": "1.3.0",
+      "matches": true
+    },
+    "numpy": {
+      "actual": "1.22.3",
+      "expected": "1.22.3",
+      "matches": true
+    },
+    "packaging": {
+      "actual": "23.1",
+      "expected": "23.1",
+      "matches": true
+    },
+    "pandas": {
+      "actual": "1.4.3",
+      "expected": "1.4.3",
+      "matches": true
+    },
+    "pyarrow": {
+      "actual": "11.0.0",
+      "expected": "11.0.0",
+      "matches": true
+    },
+    "pyparsing": {
+      "actual": "3.0.9",
+      "expected": "3.0.9",
+      "matches": true
+    },
+    "python-dateutil": {
+      "actual": "2.8.2",
+      "expected": "2.8.2",
+      "matches": true
+    },
+    "pytz": {
+      "actual": "2023.3",
+      "expected": "2023.3",
+      "matches": true
+    },
+    "scipy": {
+      "actual": "1.8.1",
+      "expected": "1.8.1",
+      "matches": true
+    },
+    "setuptools": {
+      "actual": "67.8.0",
+      "expected": "67.8.0",
+      "matches": true
+    },
+    "six": {
+      "actual": "1.16.0",
+      "expected": "1.16.0",
+      "matches": true
+    },
+    "sympy": {
+      "actual": "1.12",
+      "expected": "1.12",
+      "matches": true
+    },
+    "wheel": {
+      "actual": "0.38.4",
+      "expected": "0.38.4",
+      "matches": true
+    }
+  },
+  "platform": "Linux-5.15.0-194-generic-x86_64-with-glibc2.35",
+  "python": "3.10.12",
+  "python_executable": "/data/digital-drosophila/experiments/phase4ad-author-semantics/environment/.venv/bin/python",
+  "python_patch_matches": false
+}

registry/phase4ad-author-semantics/evidence/oracle/feedforward-float64/generated-code.json

@@ -0,0 +1,127 @@
+[
+  {
+    "active": true,
+    "code_objects": [],
+    "name": "default_neurons",
+    "order": 0,
+    "type": "NeuronGroup",
+    "when": "start"
+  },
+  {
+    "active": true,
+    "code_objects": [],
+    "name": "default_synapses",
+    "order": 0,
+    "type": "Synapses",
+    "when": "start"
+  },
+  {
+    "abstract_code": "not_refractory = timestep(t - lastspike, dt) >= timestep(rfc, dt)\n_g = g*exp(-dt*int(not_refractory)/tau)\n_v = g*tau*(-exp(dt*int(not_refractory)/t_mbr) + exp(dt*int(not_refractory)/tau))*exp(-dt*int(not_refractory)/t_mbr)*exp(-dt*int(not_refractory)/tau)/(t_mbr - tau) + v*exp(-dt*int(not_refractory)/t_mbr) + v_0 - v_0*exp(-dt*int(not_refractory)/t_mbr)\ng = _g\nv = _v",
+    "active": true,
+    "code_objects": [
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # scalar code\n    _vectorisation_idx = 1\n    dt = _array_defaultclock_dt[0]\n    _lio_1 = (- dt) / tau\n    _lio_2 = exp(_lio_1)\n    _lio_3 = tau / (t_mbr - tau)\n    _lio_4 = dt / t_mbr\n    _lio_5 = dt / tau\n    _lio_6 = (- dt) / t_mbr\n    _lio_7 = v_0 - v_0\n    _lio_8 = v_0 - (v_0 * exp(_lio_6))\n    _lio_9 = ((_lio_3 * ((- exp(_lio_4)) + exp(_lio_5))) * exp(_lio_6)) * exp(_lio_1)\n    _lio_10 = exp(_lio_6)\n    # vector code\n    _vectorisation_idx = LazyArange(N)\n    g = _array_default_neurons_g.copy()\n    t = _array_defaultclock_t[0]\n    dt = _array_defaultclock_dt[0]\n    rfc = _array_default_neurons_rfc\n    v = _array_default_neurons_v.copy()\n    lastspike = _array_default_neurons_lastspike\n    not_refractory = _array_default_neurons_not_refractory.copy()\n    not_refractory = timestep(t - lastspike, dt) >= timestep(rfc, dt)\n    _g = _numpy.where(not_refractory, _lio_2 * g, g)\n    _v = _numpy.where(not_refractory, _lio_8 + ((_lio_9 * g) + (_lio_10 * v)), _lio_7 + v)\n    g[not_refractory] = _g[not_refractory]\n    v[not_refractory] = _v[not_refractory]\n    _array_default_neurons_g[:] = g\n    _array_default_neurons_v[:] = v\n    _array_default_neurons_not_refractory[:] = not_refractory\n",
+        "name": "default_neurons_stateupdater_codeobject_4",
+        "type": "CallableProxyType"
+      }
+    ],
+    "name": "default_neurons_stateupdater",
+    "order": 0,
+    "type": "StateUpdater",
+    "user_code": "g = -g*int(not_refractory)/tau\nv = (g - v + v_0)*int(not_refractory)/t_mbr",
+    "when": "groups"
+  },
+  {
+    "active": true,
+    "code_objects": [],
+    "name": "oracle_seed_injection",
+    "order": 0,
+    "type": "NetworkOperation",
+    "when": "before_thresholds"
+  },
+  {
+    "abstract_code": "_cond = (v > v_th) and not_refractory",
+    "active": true,
+    "code_objects": [
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _array_default_neurons__spikespace[-1] = 0\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    numpy_True = _numpy.bool_(True)\n    numpy_False = _numpy.bool_(False)\n    # scalar code\n    _vectorisation_idx = 1\n    # vector code\n    _vectorisation_idx = LazyArange(N)\n    v = _array_default_neurons_v\n    not_refractory = _array_default_neurons_not_refractory\n    _cond = (v > v_th) & not_refractory\n    if _cond is True or _cond is numpy_True:\n        _events = _numpy.arange(N)\n    elif _cond is False or _cond is numpy_False:\n        _events = _numpy.array([])\n    else:\n        _events, = _cond.nonzero()\n    _array_default_neurons__spikespace[-1] = len(_events)\n    _array_default_neurons__spikespace[:len(_events)] = _events\n    # Set the neuron to refractory\n    _array_default_neurons_not_refractory[_events] = False\n    _array_default_neurons_lastspike[_events] = _array_defaultclock_t[0]\n",
+        "name": "default_neurons_spike_thresholder_codeobject_5",
+        "type": "CallableProxyType"
+      }
+    ],
+    "name": "default_neurons_spike_thresholder",
+    "order": 0,
+    "type": "Thresholder",
+    "user_code": "_cond = v > v_th",
+    "when": "thresholds"
+  },
+  {
+    "abstract_code": "_to_record_i = _source_i\n_to_record_t = _source_t",
+    "active": true,
+    "code_objects": [
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _n_events = _array_default_neurons__spikespace[-1]\n    if _n_events > 0:\n        _events = _array_default_neurons__spikespace[:_n_events]\n        # Take subgroups into account\n        if _source_start != 0 or _source_stop != _source_N:\n            _events = _events[(_events >= _source_start) & (_events < _source_stop)]\n            _n_events = len(_events)\n        if _n_events > 0:\n            _vectorisation_idx = 1\n            _curlen = _array_spikemonitor_N[0]\n            _newlen = _curlen + _n_events\n            _owner.resize(_newlen)\n            _array_spikemonitor_N[0] = _newlen\n            _vectorisation_idx = _events\n            _idx = _events\n            _source_i = _array_default_neurons_i[_idx]\n            _source_t = _array_defaultclock_t[0]\n            _to_record_i = _source_i\n            _to_record_t = _source_t\n            _dynamic_array_spikemonitor_t[_curlen:_newlen] = _to_record_t\n            _dynamic_array_spikemonitor_i[_curlen:_newlen] = _to_record_i\n            _array_spikemonitor_count[_events - _source_start] += 1\n",
+        "name": "spikemonitor_codeobject",
+        "type": "CallableProxyType"
+      }
+    ],
+    "name": "spikemonitor",
+    "order": 1,
+    "type": "SpikeMonitor",
+    "user_code": "None",
+    "when": "thresholds"
+  },
+  {
+    "abstract_code": "g += w\n",
+    "active": true,
+    "code_objects": [
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _owner.initialise_queue()\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _owner.push_spikes()\n",
+        "name": "default_synapses_pre_push_spikes",
+        "type": "CallableProxyType"
+      },
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _spiking_synapses = _queue.peek()\n    if len(_spiking_synapses):\n        # scalar code\n        # vector code\n        _idx = _spiking_synapses\n        _vectorisation_idx = _idx\n        #  Abstract code:  g += w\n        _postsynaptic_idx = _array_default_synapses__synaptic_post[_idx]\n        w = _array_default_synapses_w[_idx]\n        not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n        _numpy.add.at(_array_default_neurons_g, _postsynaptic_idx[not_refractory], w[not_refractory])\n    # Advance the spike queue\n    _queue.advance()\n",
+        "name": "default_synapses_pre_codeobject_5",
+        "type": "CallableProxyType"
+      }
+    ],
+    "name": "default_synapses_pre",
+    "order": -1,
+    "type": "SynapticPathway",
+    "user_code": "None",
+    "when": "synapses"
+  },
+  {
+    "abstract_code": "v = v_rst; w = 0; g = 0 * mV",
+    "active": true,
+    "code_objects": [
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # scalar code\n    _vectorisation_idx = 1\n    w = 0\n    # vector code\n    _idx = _array_default_neurons__spikespace[:_array_default_neurons__spikespace[-1]]\n    _vectorisation_idx = _idx\n    v = v_rst\n    g = 0.0\n    _array_default_neurons_g[_idx] = g\n    _array_default_neurons_v[_idx] = v\n",
+        "name": "default_neurons_spike_resetter_codeobject_5",
+        "type": "CallableProxyType"
+      }
+    ],
+    "name": "default_neurons_spike_resetter",
+    "order": 0,
+    "type": "Resetter",
+    "user_code": "None",
+    "when": "resets"
+  },
+  {
+    "abstract_code": "_to_record_v = _source_v\n_to_record_g = _source_g\n_to_record_lastspike = _source_lastspike\n_to_record_not_refractory = _source_not_refractory",
+    "active": true,
+    "code_objects": [
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # Resize dynamic arrays\n    _new_len = len(_dynamic_array_oracle_end_state_t) + 1\n    _owner.resize(_new_len)\n    # Store values\n    _dynamic_array_oracle_end_state_t[-1] = _array_defaultclock_t[0]\n    # scalar code\n    _vectorisation_idx = 1\n    # vector code\n    _vectorisation_idx = _array_oracle_end_state__indices\n    _idx = _array_oracle_end_state__indices\n    _source_not_refractory = _array_default_neurons_not_refractory[_idx]\n    _source_g = _array_default_neurons_g[_idx]\n    _source_v = _array_default_neurons_v[_idx]\n    _source_lastspike = _array_default_neurons_lastspike[_idx]\n    _to_record_v = _source_v\n    _to_record_g = _source_g\n    _to_record_lastspike = _source_lastspike\n    _to_record_not_refractory = _source_not_refractory\n    _dynamic_array_oracle_end_state_v[-1, :] = _to_record_v\n    _dynamic_array_oracle_end_state_g[-1, :] = _to_record_g\n    _dynamic_array_oracle_end_state_lastspike[-1, :] = _to_record_lastspike\n    _dynamic_array_oracle_end_state_not_refractory[-1, :] = _to_record_not_refractory\n",
+        "name": "oracle_end_state_codeobject",
+        "type": "CallableProxyType"
+      }
+    ],
+    "name": "oracle_end_state",
+    "order": 0,
+    "type": "StateMonitor",
+    "user_code": "None",
+    "when": "end"
+  }
+]

registry/phase4ad-author-semantics/evidence/oracle/feedforward-float64/independent-output/events.csv

@@ -0,0 +1,4 @@
+step,neuron_idx
+0,1381
+51,1511
+104,1197

registry/phase4ad-author-semantics/evidence/oracle/feedforward-float64/run-spec.json

@@ -0,0 +1,123 @@
+{
+  "author_commit": "91bdd1e7dcf193f3e7ca5a8933497fcef63b7960",
+  "author_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e",
+  "config": {
+    "author_precisions": [
+      "float64",
+      "float32"
+    ],
+    "comparison": {
+      "exact_spike_events_required_for_oracle_validation": true,
+      "float32_state_max_abs_tolerance_mv": 0.001,
+      "float64_state_max_abs_tolerance_mv": 1e-08,
+      "precision_cross_comparison_may_diverge_but_must_be_reported": true
+    },
+    "component_policies": [
+      "frozen",
+      "reset_g_only",
+      "refractory_gate_only",
+      "reset_and_refractory"
+    ],
+    "dt_ms": 0.1,
+    "duration_ms": 1000.0,
+    "experiment": "experiments/phase4ad-author-semantics",
+    "human_authorization": "\u5141\u8bb8\u72ec\u7acb\u65b0\u6a21\u578b\u5206\u652f\u6d4b\u8bd5\u52a8\u529b\u5b66\u5047\u8bbe",
+    "late_start_ms": 500.0,
+    "model": {
+      "dt_ms": 0.1,
+      "membrane_tau_ms": 20.0,
+      "refractory_ms": 2.2,
+      "reset_potential_mv": -52.0,
+      "resting_potential_mv": -52.0,
+      "synaptic_delay_ms": 1.8,
+      "synaptic_tau_ms": 5.0,
+      "threshold_mv": -45.0,
+      "w_syn_mv_per_anatomical_synapse": 0.275
+    },
+    "model_directory": "models/male-cns-lif/author-semantics-lab-v1",
+    "motifs": [
+      "pair",
+      "trio",
+      "five",
+      "feedforward",
+      "no_input"
+    ],
+    "name": "author-semantics-lab-v1",
+    "no_training_or_candidate": true,
+    "phase": "4AD",
+    "prior_experiment": "experiments/phase4ac-lif-semantics",
+    "prior_model": "models/male-cns-lif/lif-semantics-audit-v1",
+    "root": "/data/digital-drosophila",
+    "seed_margin_mv": 1.0,
+    "seed_node": 1381
+  },
+  "delay_steps": 18,
+  "dt_ms": 0.1,
+  "edge_ids": [
+    1337065,
+    1467355,
+    1559765,
+    20992891
+  ],
+  "external_arrivals": {
+    "events": 0,
+    "ordering": "after default_synapses.pre"
+  },
+  "internal_voltage_unit": "volt",
+  "nodes": [
+    1197,
+    1381,
+    1511,
+    82312,
+    133666
+  ],
+  "parameter_checks": {
+    "membrane_tau_ms": {
+      "author": 20.0,
+      "config": 20.0
+    },
+    "refractory_ms": {
+      "author": 2.2,
+      "config": 2.2
+    },
+    "reset_potential_mv": {
+      "author": -52.0,
+      "config": -52.0
+    },
+    "resting_potential_mv": {
+      "author": -52.0,
+      "config": -52.0
+    },
+    "synaptic_delay_ms": {
+      "author": 1.8,
+      "config": 1.8
+    },
+    "synaptic_tau_ms": {
+      "author": 5.0,
+      "config": 5.0
+    },
+    "threshold_mv": {
+      "author": -45.0,
+      "config": -45.0
+    },
+    "w_syn_mv_per_anatomical_synapse": {
+      "author": 0.275,
+      "config": 0.275
+    }
+  },
+  "precision": "float64",
+  "preferences": {
+    "codegen.target": "numpy",
+    "core.default_float_dtype": "float64",
+    "legacy.refractory_timing": false
+  },
+  "refractory_steps": 22,
+  "returned_voltage_unit": "mV",
+  "seed": {
+    "injections": 0,
+    "margin_mv": 1.0,
+    "requested_global_node": 1381
+  },
+  "steps": 10000,
+  "weight_rule": "raw_count multiplied by unchanged author w_syn; no sign inference"
+}

registry/phase4ad-author-semantics/evidence/oracle/feedforward-float64/schedule.json

@@ -0,0 +1,11 @@
+{
+  "schedule": [
+    "start",
+    "groups",
+    "thresholds",
+    "synapses",
+    "resets",
+    "end"
+  ],
+  "summary": "                    object                      |             part of             |       Clock dt       |       when        | order | active\n------------------------------------------------+---------------------------------+----------------------+-------------------+-------+-------\ndefault_neurons_stateupdater (StateUpdater)     | default_neurons (NeuronGroup)   | 100. us (every step) | groups            |     0 |  yes  \noracle_seed_injection (NetworkOperation)        | --                              | 100. us (every step) | before_thresholds |     0 |  yes  \ndefault_neurons_spike_thresholder (Thresholder) | default_neurons (NeuronGroup)   | 100. us (every step) | thresholds        |     0 |  yes  \nspikemonitor (SpikeMonitor)                     | spikemonitor (SpikeMonitor)     | 100. us (every step) | thresholds        |     1 |  yes  \ndefault_synapses_pre (SynapticPathway)          | default_synapses (Synapses)     | 100. us (every step) | synapses          |    -1 |  yes  \ndefault_neurons_spike_resetter (Resetter)       | default_neurons (NeuronGroup)   | 100. us (every step) | resets            |     0 |  yes  \noracle_end_state (StateMonitor)                 | oracle_end_state (StateMonitor) | 100. us (every step) | end               |     0 |  yes  "
+}

registry/phase4ad-author-semantics/evidence/oracle/feedforward-float64/seed.json

@@ -0,0 +1,7 @@
+{
+  "applied_mv": -44.0,
+  "injections": 1,
+  "margin_mv": 1.0,
+  "requested_global_node": 1381,
+  "spiked_at_zero": true
+}

registry/phase4ad-author-semantics/evidence/oracle/five-float32-repeat/actual-weights.json

@@ -0,0 +1,47 @@
+{
+  "edge_id": [
+    1336648,
+    1336655,
+    1337065,
+    1467340,
+    1467355,
+    1467852,
+    1559765,
+    1559772,
+    1560267,
+    20992285,
+    20992291,
+    20992294,
+    20992891
+  ],
+  "weights_mv": [
+    57.75,
+    47.29999923706055,
+    28.599998474121094,
+    71.2249984741211,
+    64.625,
+    17.599998474121094,
+    62.14999771118164,
+    77.82499694824219,
+    19.249998092651367,
+    26.125,
+    15.675000190734863,
+    20.899999618530273,
+    11.824999809265137
+  ],
+  "weights_volt": [
+    0.057750001549720764,
+    0.04729999974370003,
+    0.028599999845027924,
+    0.07122500240802765,
+    0.06462500244379044,
+    0.01759999990463257,
+    0.062150001525878906,
+    0.07782500237226486,
+    0.01924999989569187,
+    0.026125000789761543,
+    0.015675000846385956,
+    0.020899999886751175,
+    0.011824999935925007
+  ]
+}

registry/phase4ad-author-semantics/evidence/oracle/five-float32-repeat/brian-output/events.csv

@@ -0,0 +1,611 @@
+step,neuron_idx
+0,1381
+46,1197
+51,1511
+79,1381
+91,133666
+99,1197
+120,1511
+140,1381
+163,1197
+170,133666
+185,1511
+205,1381
+220,1197
+246,1511
+259,133666
+268,1381
+288,1197
+306,1511
+330,1381
+341,133666
+351,1197
+371,1511
+391,1381
+414,1197
+422,133666
+436,1511
+457,1381
+471,1197
+497,1511
+510,133666
+519,1381
+539,1197
+557,1511
+581,1381
+592,133666
+602,1197
+622,1511
+642,1381
+665,1197
+673,133666
+687,1511
+708,1381
+722,1197
+748,1511
+761,133666
+770,1381
+790,1197
+808,1511
+832,1381
+843,133666
+853,1197
+873,1511
+881,82312
+893,1381
+916,1197
+924,133666
+938,1511
+959,1381
+973,1197
+999,1511
+1012,133666
+1021,1381
+1041,1197
+1059,1511
+1083,1381
+1094,133666
+1104,1197
+1124,1511
+1144,1381
+1167,1197
+1175,133666
+1189,1511
+1210,1381
+1224,1197
+1250,1511
+1263,133666
+1272,1381
+1292,1197
+1310,1511
+1334,1381
+1345,133666
+1355,1197
+1375,1511
+1395,1381
+1418,1197
+1426,133666
+1440,1511
+1461,1381
+1475,1197
+1501,1511
+1514,133666
+1523,1381
+1543,1197
+1561,1511
+1585,1381
+1596,133666
+1606,1197
+1626,1511
+1641,82312
+1646,1381
+1669,1197
+1677,133666
+1691,1511
+1712,1381
+1726,1197
+1752,1511
+1765,133666
+1774,1381
+1794,1197
+1812,1511
+1836,1381
+1847,133666
+1857,1197
+1877,1511
+1897,1381
+1920,1197
+1928,133666
+1942,1511
+1963,1381
+1977,1197
+2003,1511
+2016,133666
+2025,1381
+2045,1197
+2063,1511
+2087,1381
+2098,133666
+2108,1197
+2128,1511
+2148,1381
+2171,1197
+2179,133666
+2193,1511
+2214,1381
+2228,1197
+2254,1511
+2267,133666
+2276,1381
+2296,1197
+2314,1511
+2338,1381
+2349,133666
+2359,1197
+2379,1511
+2394,82312
+2399,1381
+2422,1197
+2430,133666
+2444,1511
+2465,1381
+2479,1197
+2505,1511
+2518,133666
+2527,1381
+2547,1197
+2565,1511
+2589,1381
+2600,133666
+2610,1197
+2630,1511
+2650,1381
+2673,1197
+2681,133666
+2695,1511
+2716,1381
+2730,1197
+2756,1511
+2769,133666
+2778,1381
+2798,1197
+2816,1511
+2840,1381
+2851,133666
+2861,1197
+2881,1511
+2901,1381
+2924,1197
+2932,133666
+2946,1511
+2967,1381
+2981,1197
+3007,1511
+3020,133666
+3029,1381
+3049,1197
+3067,1511
+3091,1381
+3102,133666
+3112,1197
+3132,1511
+3147,82312
+3152,1381
+3175,1197
+3183,133666
+3197,1511
+3218,1381
+3232,1197
+3258,1511
+3271,133666
+3280,1381
+3300,1197
+3318,1511
+3342,1381
+3353,133666
+3363,1197
+3383,1511
+3403,1381
+3426,1197
+3434,133666
+3448,1511
+3469,1381
+3483,1197
+3509,1511
+3522,133666
+3531,1381
+3551,1197
+3569,1511
+3593,1381
+3604,133666
+3614,1197
+3634,1511
+3654,1381
+3677,1197
+3685,133666
+3699,1511
+3720,1381
+3734,1197
+3760,1511
+3773,133666
+3782,1381
+3802,1197
+3820,1511
+3844,1381
+3855,133666
+3865,1197
+3885,1511
+3900,82312
+3905,1381
+3928,1197
+3936,133666
+3950,1511
+3971,1381
+3985,1197
+4011,1511
+4024,133666
+4033,1381
+4053,1197
+4071,1511
+4095,1381
+4106,133666
+4116,1197
+4136,1511
+4156,1381
+4179,1197
+4187,133666
+4201,1511
+4222,1381
+4236,1197
+4262,1511
+4275,133666
+4284,1381
+4304,1197
+4322,1511
+4346,1381
+4357,133666
+4367,1197
+4387,1511
+4407,1381
+4430,1197
+4438,133666
+4452,1511
+4473,1381
+4487,1197
+4513,1511
+4526,133666
+4535,1381
+4555,1197
+4573,1511
+4597,1381
+4608,133666
+4618,1197
+4638,1511
+4653,82312
+4658,1381
+4681,1197
+4689,133666
+4703,1511
+4724,1381
+4738,1197
+4764,1511
+4777,133666
+4786,1381
+4806,1197
+4824,1511
+4848,1381
+4859,133666
+4869,1197
+4889,1511
+4909,1381
+4932,1197
+4940,133666
+4954,1511
+4975,1381
+4989,1197
+5015,1511
+5028,133666
+5037,1381
+5057,1197
+5075,1511
+5099,1381
+5110,133666
+5120,1197
+5140,1511
+5160,1381
+5183,1197
+5191,133666
+5205,1511
+5226,1381
+5240,1197
+5266,1511
+5279,133666
+5288,1381
+5308,1197
+5326,1511
+5350,1381
+5361,133666
+5371,1197
+5391,1511
+5406,82312
+5411,1381
+5434,1197
+5442,133666
+5456,1511
+5477,1381
+5491,1197
+5517,1511
+5530,133666
+5539,1381
+5559,1197
+5577,1511
+5601,1381
+5612,133666
+5622,1197
+5642,1511
+5662,1381
+5685,1197
+5693,133666
+5707,1511
+5728,1381
+5742,1197
+5768,1511
+5781,133666
+5790,1381
+5810,1197
+5828,1511
+5852,1381
+5863,133666
+5873,1197
+5893,1511
+5913,1381
+5936,1197
+5944,133666
+5958,1511
+5979,1381
+5993,1197
+6019,1511
+6032,133666
+6041,1381
+6061,1197
+6079,1511
+6103,1381
+6114,133666
+6124,1197
+6144,1511
+6159,82312
+6164,1381
+6187,1197
+6195,133666
+6209,1511
+6230,1381
+6244,1197
+6270,1511
+6283,133666
+6292,1381
+6312,1197
+6330,1511
+6354,1381
+6365,133666
+6375,1197
+6395,1511
+6415,1381
+6438,1197
+6446,133666
+6460,1511
+6481,1381
+6495,1197
+6521,1511
+6534,133666
+6543,1381
+6563,1197
+6581,1511
+6605,1381
+6616,133666
+6626,1197
+6646,1511
+6666,1381
+6689,1197
+6697,133666
+6711,1511
+6732,1381
+6746,1197
+6772,1511
+6785,133666
+6794,1381
+6814,1197
+6832,1511
+6856,1381
+6867,133666
+6877,1197
+6897,1511
+6912,82312
+6917,1381
+6940,1197
+6948,133666
+6962,1511
+6983,1381
+6997,1197
+7023,1511
+7036,133666
+7045,1381
+7065,1197
+7083,1511
+7107,1381
+7118,133666
+7128,1197
+7148,1511
+7168,1381
+7191,1197
+7199,133666
+7213,1511
+7234,1381
+7248,1197
+7274,1511
+7287,133666
+7296,1381
+7316,1197
+7334,1511
+7358,1381
+7369,133666
+7379,1197
+7399,1511
+7419,1381
+7442,1197
+7450,133666
+7464,1511
+7485,1381
+7499,1197
+7525,1511
+7538,133666
+7547,1381
+7567,1197
+7585,1511
+7609,1381
+7620,133666
+7630,1197
+7650,1511
+7665,82312
+7670,1381
+7693,1197
+7701,133666
+7715,1511
+7736,1381
+7750,1197
+7776,1511
+7789,133666
+7798,1381
+7818,1197
+7836,1511
+7860,1381
+7871,133666
+7881,1197
+7901,1511
+7921,1381
+7944,1197
+7952,133666
+7966,1511
+7987,1381
+8001,1197
+8027,1511
+8040,133666
+8049,1381
+8069,1197
+8087,1511
+8111,1381
+8122,133666
+8132,1197
+8152,1511
+8172,1381
+8195,1197
+8203,133666
+8217,1511
+8238,1381
+8252,1197
+8278,1511
+8291,133666
+8300,1381
+8320,1197
+8338,1511
+8362,1381
+8373,133666
+8383,1197
+8403,1511
+8418,82312
+8423,1381
+8446,1197
+8454,133666
+8468,1511
+8489,1381
+8503,1197
+8529,1511
+8542,133666
+8551,1381
+8571,1197
+8589,1511
+8613,1381
+8624,133666
+8634,1197
+8654,1511
+8674,1381
+8697,1197
+8705,133666
+8719,1511
+8740,1381
+8754,1197
+8780,1511
+8793,133666
+8802,1381
+8822,1197
+8840,1511
+8864,1381
+8875,133666
+8885,1197
+8905,1511
+8925,1381
+8948,1197
+8956,133666
+8970,1511
+8991,1381
+9005,1197
+9031,1511
+9044,133666
+9053,1381
+9073,1197
+9091,1511
+9115,1381
+9126,133666
+9136,1197
+9156,1511
+9171,82312
+9176,1381
+9199,1197
+9207,133666
+9221,1511
+9242,1381
+9256,1197
+9282,1511
+9295,133666
+9304,1381
+9324,1197
+9342,1511
+9366,1381
+9377,133666
+9387,1197
+9407,1511
+9427,1381
+9450,1197
+9458,133666
+9472,1511
+9493,1381
+9507,1197
+9533,1511
+9546,133666
+9555,1381
+9575,1197
+9593,1511
+9617,1381
+9628,133666
+9638,1197
+9658,1511
+9678,1381
+9701,1197
+9709,133666
+9723,1511
+9744,1381
+9758,1197
+9784,1511
+9797,133666
+9806,1381
+9826,1197
+9844,1511
+9868,1381
+9879,133666
+9889,1197
+9909,1511
+9924,82312
+9929,1381
+9952,1197
+9960,133666
+9974,1511
+9995,1381

registry/phase4ad-author-semantics/evidence/oracle/five-float32-repeat/completeness.csv

@@ -0,0 +1,6 @@
+global_neuron_idx,local_index
+1197,0
+1381,1
+1511,2
+82312,3
+133666,4

registry/phase4ad-author-semantics/evidence/oracle/five-float32-repeat/environment.json

@@ -0,0 +1,102 @@
+{
+  "all_package_pins_match": true,
+  "author_platform": "Windows",
+  "author_python": "3.10.11",
+  "binary_identical_author_environment_claimed": false,
+  "packages": {
+    "brian2": {
+      "actual": "2.5.1",
+      "expected": "2.5.1",
+      "matches": true
+    },
+    "cython": {
+      "actual": "0.29.33",
+      "expected": "0.29.33",
+      "matches": true
+    },
+    "jinja2": {
+      "actual": "2.11.3",
+      "expected": "2.11.3",
+      "matches": true
+    },
+    "joblib": {
+      "actual": "1.2.0",
+      "expected": "1.2.0",
+      "matches": true
+    },
+    "markupsafe": {
+      "actual": "1.1.1",
+      "expected": "1.1.1",
+      "matches": true
+    },
+    "mpmath": {
+      "actual": "1.3.0",
+      "expected": "1.3.0",
+      "matches": true
+    },
+    "numpy": {
+      "actual": "1.22.3",
+      "expected": "1.22.3",
+      "matches": true
+    },
+    "packaging": {
+      "actual": "23.1",
+      "expected": "23.1",
+      "matches": true
+    },
+    "pandas": {
+      "actual": "1.4.3",
+      "expected": "1.4.3",
+      "matches": true
+    },
+    "pyarrow": {
+      "actual": "11.0.0",
+      "expected": "11.0.0",
+      "matches": true
+    },
+    "pyparsing": {
+      "actual": "3.0.9",
+      "expected": "3.0.9",
+      "matches": true
+    },
+    "python-dateutil": {
+      "actual": "2.8.2",
+      "expected": "2.8.2",
+      "matches": true
+    },
+    "pytz": {
+      "actual": "2023.3",
+      "expected": "2023.3",
+      "matches": true
+    },
+    "scipy": {
+      "actual": "1.8.1",
+      "expected": "1.8.1",
+      "matches": true
+    },
+    "setuptools": {
+      "actual": "67.8.0",
+      "expected": "67.8.0",
+      "matches": true
+    },
+    "six": {
+      "actual": "1.16.0",
+      "expected": "1.16.0",
+      "matches": true
+    },
+    "sympy": {
+      "actual": "1.12",
+      "expected": "1.12",
+      "matches": true
+    },
+    "wheel": {
+      "actual": "0.38.4",
+      "expected": "0.38.4",
+      "matches": true
+    }
+  },
+  "platform": "Linux-5.15.0-194-generic-x86_64-with-glibc2.35",
+  "python": "3.10.12",
+  "python_executable": "/data/digital-drosophila/experiments/phase4ad-author-semantics/environment/.venv/bin/python",
+  "python_patch_matches": false
+}

registry/phase4ad-author-semantics/evidence/oracle/five-float32-repeat/generated-code.json

@@ -0,0 +1,127 @@
+[
+  {
+    "active": true,
+    "code_objects": [],
+    "name": "default_neurons",
+    "order": 0,
+    "type": "NeuronGroup",
+    "when": "start"
+  },
+  {
+    "active": true,
+    "code_objects": [],
+    "name": "default_synapses",
+    "order": 0,
+    "type": "Synapses",
+    "when": "start"
+  },
+  {
+    "abstract_code": "not_refractory = timestep(t - lastspike, dt) >= timestep(rfc, dt)\n_g = g*exp(-dt*int(not_refractory)/tau)\n_v = g*tau*(-exp(dt*int(not_refractory)/t_mbr) + exp(dt*int(not_refractory)/tau))*exp(-dt*int(not_refractory)/t_mbr)*exp(-dt*int(not_refractory)/tau)/(t_mbr - tau) + v*exp(-dt*int(not_refractory)/t_mbr) + v_0 - v_0*exp(-dt*int(not_refractory)/t_mbr)\ng = _g\nv = _v",
+    "active": true,
+    "code_objects": [
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # scalar code\n    _vectorisation_idx = 1\n    dt = _array_defaultclock_dt[0]\n    _lio_1 = (- dt) / tau\n    _lio_2 = exp(_lio_1)\n    _lio_3 = tau / (t_mbr - tau)\n    _lio_4 = dt / t_mbr\n    _lio_5 = dt / tau\n    _lio_6 = (- dt) / t_mbr\n    _lio_7 = v_0 - v_0\n    _lio_8 = v_0 - (v_0 * exp(_lio_6))\n    _lio_9 = ((_lio_3 * ((- exp(_lio_4)) + exp(_lio_5))) * exp(_lio_6)) * exp(_lio_1)\n    _lio_10 = exp(_lio_6)\n    # vector code\n    _vectorisation_idx = LazyArange(N)\n    g = _array_default_neurons_g.copy()\n    t = _array_defaultclock_t[0]\n    dt = _array_defaultclock_dt[0]\n    rfc = _array_default_neurons_rfc\n    v = _array_default_neurons_v.copy()\n    lastspike = _array_default_neurons_lastspike\n    not_refractory = _array_default_neurons_not_refractory.copy()\n    not_refractory = timestep(t - lastspike, dt) >= timestep(rfc, dt)\n    _g = _numpy.where(not_refractory, _lio_2 * g, g)\n    _v = _numpy.where(not_refractory, _lio_8 + ((_lio_9 * g) + (_lio_10 * v)), _lio_7 + v)\n    g[not_refractory] = _g[not_refractory]\n    v[not_refractory] = _v[not_refractory]\n    _array_default_neurons_g[:] = g\n    _array_default_neurons_v[:] = v\n    _array_default_neurons_not_refractory[:] = not_refractory\n",
+        "name": "default_neurons_stateupdater_codeobject_3",
+        "type": "CallableProxyType"
+      }
+    ],
+    "name": "default_neurons_stateupdater",
+    "order": 0,
+    "type": "StateUpdater",
+    "user_code": "g = -g*int(not_refractory)/tau\nv = (g - v + v_0)*int(not_refractory)/t_mbr",
+    "when": "groups"
+  },
+  {
+    "active": true,
+    "code_objects": [],
+    "name": "oracle_seed_injection",
+    "order": 0,
+    "type": "NetworkOperation",
+    "when": "before_thresholds"
+  },
+  {
+    "abstract_code": "_cond = (v > v_th) and not_refractory",
+    "active": true,
+    "code_objects": [
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _array_default_neurons__spikespace[-1] = 0\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    numpy_True = _numpy.bool_(True)\n    numpy_False = _numpy.bool_(False)\n    # scalar code\n    _vectorisation_idx = 1\n    # vector code\n    _vectorisation_idx = LazyArange(N)\n    v = _array_default_neurons_v\n    not_refractory = _array_default_neurons_not_refractory\n    _cond = (v > v_th) & not_refractory\n    if _cond is True or _cond is numpy_True:\n        _events = _numpy.arange(N)\n    elif _cond is False or _cond is numpy_False:\n        _events = _numpy.array([])\n    else:\n        _events, = _cond.nonzero()\n    _array_default_neurons__spikespace[-1] = len(_events)\n    _array_default_neurons__spikespace[:len(_events)] = _events\n    # Set the neuron to refractory\n    _array_default_neurons_not_refractory[_events] = False\n    _array_default_neurons_lastspike[_events] = _array_defaultclock_t[0]\n",
+        "name": "default_neurons_spike_thresholder_codeobject_4",
+        "type": "CallableProxyType"
+      }
+    ],
+    "name": "default_neurons_spike_thresholder",
+    "order": 0,
+    "type": "Thresholder",
+    "user_code": "_cond = v > v_th",
+    "when": "thresholds"
+  },
+  {
+    "abstract_code": "_to_record_i = _source_i\n_to_record_t = _source_t",
+    "active": true,
+    "code_objects": [
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _n_events = _array_default_neurons__spikespace[-1]\n    if _n_events > 0:\n        _events = _array_default_neurons__spikespace[:_n_events]\n        # Take subgroups into account\n        if _source_start != 0 or _source_stop != _source_N:\n            _events = _events[(_events >= _source_start) & (_events < _source_stop)]\n            _n_events = len(_events)\n        if _n_events > 0:\n            _vectorisation_idx = 1\n            _curlen = _array_spikemonitor_N[0]\n            _newlen = _curlen + _n_events\n            _owner.resize(_newlen)\n            _array_spikemonitor_N[0] = _newlen\n            _vectorisation_idx = _events\n            _idx = _events\n            _source_i = _array_default_neurons_i[_idx]\n            _source_t = _array_defaultclock_t[0]\n            _to_record_i = _source_i\n            _to_record_t = _source_t\n            _dynamic_array_spikemonitor_t[_curlen:_newlen] = _to_record_t\n            _dynamic_array_spikemonitor_i[_curlen:_newlen] = _to_record_i\n            _array_spikemonitor_count[_events - _source_start] += 1\n",
+        "name": "spikemonitor_codeobject",
+        "type": "CallableProxyType"
+      }
+    ],
+    "name": "spikemonitor",
+    "order": 1,
+    "type": "SpikeMonitor",
+    "user_code": "None",
+    "when": "thresholds"
+  },
+  {
+    "abstract_code": "g += w\n",
+    "active": true,
+    "code_objects": [
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _owner.initialise_queue()\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _owner.push_spikes()\n",
+        "name": "default_synapses_pre_push_spikes",
+        "type": "CallableProxyType"
+      },
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _spiking_synapses = _queue.peek()\n    if len(_spiking_synapses):\n        # scalar code\n        # vector code\n        _idx = _spiking_synapses\n        _vectorisation_idx = _idx\n        #  Abstract code:  g += w\n        _postsynaptic_idx = _array_default_synapses__synaptic_post[_idx]\n        w = _array_default_synapses_w[_idx]\n        not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n        _numpy.add.at(_array_default_neurons_g, _postsynaptic_idx[not_refractory], w[not_refractory])\n    # Advance the spike queue\n    _queue.advance()\n",
+        "name": "default_synapses_pre_codeobject_4",
+        "type": "CallableProxyType"
+      }
+    ],
+    "name": "default_synapses_pre",
+    "order": -1,
+    "type": "SynapticPathway",
+    "user_code": "None",
+    "when": "synapses"
+  },
+  {
+    "abstract_code": "v = v_rst; w = 0; g = 0 * mV",
+    "active": true,
+    "code_objects": [
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # scalar code\n    _vectorisation_idx = 1\n    w = 0\n    # vector code\n    _idx = _array_default_neurons__spikespace[:_array_default_neurons__spikespace[-1]]\n    _vectorisation_idx = _idx\n    v = v_rst\n    g = 0.0\n    _array_default_neurons_g[_idx] = g\n    _array_default_neurons_v[_idx] = v\n",
+        "name": "default_neurons_spike_resetter_codeobject_4",
+        "type": "CallableProxyType"
+      }
+    ],
+    "name": "default_neurons_spike_resetter",
+    "order": 0,
+    "type": "Resetter",
+    "user_code": "None",
+    "when": "resets"
+  },
+  {
+    "abstract_code": "_to_record_v = _source_v\n_to_record_g = _source_g\n_to_record_lastspike = _source_lastspike\n_to_record_not_refractory = _source_not_refractory",
+    "active": true,
+    "code_objects": [
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # Resize dynamic arrays\n    _new_len = len(_dynamic_array_oracle_end_state_t) + 1\n    _owner.resize(_new_len)\n    # Store values\n    _dynamic_array_oracle_end_state_t[-1] = _array_defaultclock_t[0]\n    # scalar code\n    _vectorisation_idx = 1\n    # vector code\n    _vectorisation_idx = _array_oracle_end_state__indices\n    _idx = _array_oracle_end_state__indices\n    _source_not_refractory = _array_default_neurons_not_refractory[_idx]\n    _source_g = _array_default_neurons_g[_idx]\n    _source_v = _array_default_neurons_v[_idx]\n    _source_lastspike = _array_default_neurons_lastspike[_idx]\n    _to_record_v = _source_v\n    _to_record_g = _source_g\n    _to_record_lastspike = _source_lastspike\n    _to_record_not_refractory = _source_not_refractory\n    _dynamic_array_oracle_end_state_v[-1, :] = _to_record_v\n    _dynamic_array_oracle_end_state_g[-1, :] = _to_record_g\n    _dynamic_array_oracle_end_state_lastspike[-1, :] = _to_record_lastspike\n    _dynamic_array_oracle_end_state_not_refractory[-1, :] = _to_record_not_refractory\n",
+        "name": "oracle_end_state_codeobject",
+        "type": "CallableProxyType"
+      }
+    ],
+    "name": "oracle_end_state",
+    "order": 0,
+    "type": "StateMonitor",
+    "user_code": "None",
+    "when": "end"
+  }
+]

registry/phase4ad-author-semantics/evidence/oracle/five-float32-repeat/run-spec.json

@@ -0,0 +1,132 @@
+{
+  "author_commit": "91bdd1e7dcf193f3e7ca5a8933497fcef63b7960",
+  "author_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e",
+  "config": {
+    "author_precisions": [
+      "float64",
+      "float32"
+    ],
+    "comparison": {
+      "exact_spike_events_required_for_oracle_validation": true,
+      "float32_state_max_abs_tolerance_mv": 0.001,
+      "float64_state_max_abs_tolerance_mv": 1e-08,
+      "precision_cross_comparison_may_diverge_but_must_be_reported": true
+    },
+    "component_policies": [
+      "frozen",
+      "reset_g_only",
+      "refractory_gate_only",
+      "reset_and_refractory"
+    ],
+    "dt_ms": 0.1,
+    "duration_ms": 1000.0,
+    "experiment": "experiments/phase4ad-author-semantics",
+    "human_authorization": "\u5141\u8bb8\u72ec\u7acb\u65b0\u6a21\u578b\u5206\u652f\u6d4b\u8bd5\u52a8\u529b\u5b66\u5047\u8bbe",
+    "late_start_ms": 500.0,
+    "model": {
+      "dt_ms": 0.1,
+      "membrane_tau_ms": 20.0,
+      "refractory_ms": 2.2,
+      "reset_potential_mv": -52.0,
+      "resting_potential_mv": -52.0,
+      "synaptic_delay_ms": 1.8,
+      "synaptic_tau_ms": 5.0,
+      "threshold_mv": -45.0,
+      "w_syn_mv_per_anatomical_synapse": 0.275
+    },
+    "model_directory": "models/male-cns-lif/author-semantics-lab-v1",
+    "motifs": [
+      "pair",
+      "trio",
+      "five",
+      "feedforward",
+      "no_input"
+    ],
+    "name": "author-semantics-lab-v1",
+    "no_training_or_candidate": true,
+    "phase": "4AD",
+    "prior_experiment": "experiments/phase4ac-lif-semantics",
+    "prior_model": "models/male-cns-lif/lif-semantics-audit-v1",
+    "root": "/data/digital-drosophila",
+    "seed_margin_mv": 1.0,
+    "seed_node": 1381
+  },
+  "delay_steps": 18,
+  "dt_ms": 0.1,
+  "edge_ids": [
+    1336648,
+    1336655,
+    1337065,
+    1467340,
+    1467355,
+    1467852,
+    1559765,
+    1559772,
+    1560267,
+    20992285,
+    20992291,
+    20992294,
+    20992891
+  ],
+  "external_arrivals": {
+    "events": 0,
+    "ordering": "after default_synapses.pre"
+  },
+  "internal_voltage_unit": "volt",
+  "nodes": [
+    1197,
+    1381,
+    1511,
+    82312,
+    133666
+  ],
+  "parameter_checks": {
+    "membrane_tau_ms": {
+      "author": 20.0,
+      "config": 20.0
+    },
+    "refractory_ms": {
+      "author": 2.2,
+      "config": 2.2
+    },
+    "reset_potential_mv": {
+      "author": -52.0,
+      "config": -52.0
+    },
+    "resting_potential_mv": {
+      "author": -52.0,
+      "config": -52.0
+    },
+    "synaptic_delay_ms": {
+      "author": 1.8,
+      "config": 1.8
+    },
+    "synaptic_tau_ms": {
+      "author": 5.0,
+      "config": 5.0
+    },
+    "threshold_mv": {
+      "author": -45.0,
+      "config": -45.0
+    },
+    "w_syn_mv_per_anatomical_synapse": {
+      "author": 0.275,
+      "config": 0.275
+    }
+  },
+  "precision": "float32",
+  "preferences": {
+    "codegen.target": "numpy",
+    "core.default_float_dtype": "float32",
+    "legacy.refractory_timing": false
+  },
+  "refractory_steps": 22,
+  "returned_voltage_unit": "mV",
+  "seed": {
+    "injections": 0,
+    "margin_mv": 1.0,
+    "requested_global_node": 1381
+  },
+  "steps": 10000,
+  "weight_rule": "raw_count multiplied by unchanged author w_syn; no sign inference"
+}

registry/phase4ad-author-semantics/evidence/oracle/five-float32-repeat/schedule.json

@@ -0,0 +1,11 @@
+{
+  "schedule": [
+    "start",
+    "groups",
+    "thresholds",
+    "synapses",
+    "resets",
+    "end"
+  ],
+  "summary": "                    object                      |             part of             |       Clock dt       |       when        | order | active\n------------------------------------------------+---------------------------------+----------------------+-------------------+-------+-------\ndefault_neurons_stateupdater (StateUpdater)     | default_neurons (NeuronGroup)   | 100. us (every step) | groups            |     0 |  yes  \noracle_seed_injection (NetworkOperation)        | --                              | 100. us (every step) | before_thresholds |     0 |  yes  \ndefault_neurons_spike_thresholder (Thresholder) | default_neurons (NeuronGroup)   | 100. us (every step) | thresholds        |     0 |  yes  \nspikemonitor (SpikeMonitor)                     | spikemonitor (SpikeMonitor)     | 100. us (every step) | thresholds        |     1 |  yes  \ndefault_synapses_pre (SynapticPathway)          | default_synapses (Synapses)     | 100. us (every step) | synapses          |    -1 |  yes  \ndefault_neurons_spike_resetter (Resetter)       | default_neurons (NeuronGroup)   | 100. us (every step) | resets            |     0 |  yes  \noracle_end_state (StateMonitor)                 | oracle_end_state (StateMonitor) | 100. us (every step) | end               |     0 |  yes  "
+}

registry/phase4ad-author-semantics/evidence/oracle/five-float32-repeat/seed.json

@@ -0,0 +1,7 @@
+{
+  "applied_mv": -43.99999976158142,
+  "injections": 1,
+  "margin_mv": 1.0,
+  "requested_global_node": 1381,
+  "spiked_at_zero": true
+}

registry/phase4ad-author-semantics/evidence/oracle/five-float32/actual-weights.json

@@ -0,0 +1,47 @@
+{
+  "edge_id": [
+    1336648,
+    1336655,
+    1337065,
+    1467340,
+    1467355,
+    1467852,
+    1559765,
+    1559772,
+    1560267,
+    20992285,
+    20992291,
+    20992294,
+    20992891
+  ],
+  "weights_mv": [
+    57.75,
+    47.29999923706055,
+    28.599998474121094,
+    71.2249984741211,
+    64.625,
+    17.599998474121094,
+    62.14999771118164,
+    77.82499694824219,
+    19.249998092651367,
+    26.125,
+    15.675000190734863,
+    20.899999618530273,
+    11.824999809265137
+  ],
+  "weights_volt": [
+    0.057750001549720764,
+    0.04729999974370003,
+    0.028599999845027924,
+    0.07122500240802765,
+    0.06462500244379044,
+    0.01759999990463257,
+    0.062150001525878906,
+    0.07782500237226486,
+    0.01924999989569187,
+    0.026125000789761543,
+    0.015675000846385956,
+    0.020899999886751175,
+    0.011824999935925007
+  ]
+}

registry/phase4ad-author-semantics/evidence/oracle/five-float32/brian-output/events.csv

@@ -0,0 +1,611 @@
+step,neuron_idx
+0,1381
+46,1197
+51,1511
+79,1381
+91,133666
+99,1197
+120,1511
+140,1381
+163,1197
+170,133666
+185,1511
+205,1381
+220,1197
+246,1511
+259,133666
+268,1381
+288,1197
+306,1511
+330,1381
+341,133666
+351,1197
+371,1511
+391,1381
+414,1197
+422,133666
+436,1511
+457,1381
+471,1197
+497,1511
+510,133666
+519,1381
+539,1197
+557,1511
+581,1381
+592,133666
+602,1197
+622,1511
+642,1381
+665,1197
+673,133666
+687,1511
+708,1381
+722,1197
+748,1511
+761,133666
+770,1381
+790,1197
+808,1511
+832,1381
+843,133666
+853,1197
+873,1511
+881,82312
+893,1381
+916,1197
+924,133666
+938,1511
+959,1381
+973,1197
+999,1511
+1012,133666
+1021,1381
+1041,1197
+1059,1511
+1083,1381
+1094,133666
+1104,1197
+1124,1511
+1144,1381
+1167,1197
+1175,133666
+1189,1511
+1210,1381
+1224,1197
+1250,1511
+1263,133666
+1272,1381
+1292,1197
+1310,1511
+1334,1381
+1345,133666
+1355,1197
+1375,1511
+1395,1381
+1418,1197
+1426,133666
+1440,1511
+1461,1381
+1475,1197
+1501,1511
+1514,133666
+1523,1381
+1543,1197
+1561,1511
+1585,1381
+1596,133666
+1606,1197
+1626,1511
+1641,82312
+1646,1381
+1669,1197
+1677,133666
+1691,1511
+1712,1381
+1726,1197
+1752,1511
+1765,133666
+1774,1381
+1794,1197
+1812,1511
+1836,1381
+1847,133666
+1857,1197
+1877,1511
+1897,1381
+1920,1197
+1928,133666
+1942,1511
+1963,1381
+1977,1197
+2003,1511
+2016,133666
+2025,1381
+2045,1197
+2063,1511
+2087,1381
+2098,133666
+2108,1197
+2128,1511
+2148,1381
+2171,1197
+2179,133666
+2193,1511
+2214,1381
+2228,1197
+2254,1511
+2267,133666
+2276,1381
+2296,1197
+2314,1511
+2338,1381
+2349,133666
+2359,1197
+2379,1511
+2394,82312
+2399,1381
+2422,1197
+2430,133666
+2444,1511
+2465,1381
+2479,1197
+2505,1511
+2518,133666
+2527,1381
+2547,1197
+2565,1511
+2589,1381
+2600,133666
+2610,1197
+2630,1511
+2650,1381
+2673,1197
+2681,133666
+2695,1511
+2716,1381
+2730,1197
+2756,1511
+2769,133666
+2778,1381
+2798,1197
+2816,1511
+2840,1381
+2851,133666
+2861,1197
+2881,1511
+2901,1381
+2924,1197
+2932,133666
+2946,1511
+2967,1381
+2981,1197
+3007,1511
+3020,133666
+3029,1381
+3049,1197
+3067,1511
+3091,1381
+3102,133666
+3112,1197
+3132,1511
+3147,82312
+3152,1381
+3175,1197
+3183,133666
+3197,1511
+3218,1381
+3232,1197
+3258,1511
+3271,133666
+3280,1381
+3300,1197
+3318,1511
+3342,1381
+3353,133666
+3363,1197
+3383,1511
+3403,1381
+3426,1197
+3434,133666
+3448,1511
+3469,1381
+3483,1197
+3509,1511
+3522,133666
+3531,1381
+3551,1197
+3569,1511
+3593,1381
+3604,133666
+3614,1197
+3634,1511
+3654,1381
+3677,1197
+3685,133666
+3699,1511
+3720,1381
+3734,1197
+3760,1511
+3773,133666
+3782,1381
+3802,1197
+3820,1511
+3844,1381
+3855,133666
+3865,1197
+3885,1511
+3900,82312
+3905,1381
+3928,1197
+3936,133666
+3950,1511
+3971,1381
+3985,1197
+4011,1511
+4024,133666
+4033,1381
+4053,1197
+4071,1511
+4095,1381
+4106,133666
+4116,1197
+4136,1511
+4156,1381
+4179,1197
+4187,133666
+4201,1511
+4222,1381
+4236,1197
+4262,1511
+4275,133666
+4284,1381
+4304,1197
+4322,1511
+4346,1381
+4357,133666
+4367,1197
+4387,1511
+4407,1381
+4430,1197
+4438,133666
+4452,1511
+4473,1381
+4487,1197
+4513,1511
+4526,133666
+4535,1381
+4555,1197
+4573,1511
+4597,1381
+4608,133666
+4618,1197
+4638,1511
+4653,82312
+4658,1381
+4681,1197
+4689,133666
+4703,1511
+4724,1381
+4738,1197
+4764,1511
+4777,133666
+4786,1381
+4806,1197
+4824,1511
+4848,1381
+4859,133666
+4869,1197
+4889,1511
+4909,1381
+4932,1197
+4940,133666
+4954,1511
+4975,1381
+4989,1197
+5015,1511
+5028,133666
+5037,1381
+5057,1197
+5075,1511
+5099,1381
+5110,133666
+5120,1197
+5140,1511
+5160,1381
+5183,1197
+5191,133666
+5205,1511
+5226,1381
+5240,1197
+5266,1511
+5279,133666
+5288,1381
+5308,1197
+5326,1511
+5350,1381
+5361,133666
+5371,1197
+5391,1511
+5406,82312
+5411,1381
+5434,1197
+5442,133666
+5456,1511
+5477,1381
+5491,1197
+5517,1511
+5530,133666
+5539,1381
+5559,1197
+5577,1511
+5601,1381
+5612,133666
+5622,1197
+5642,1511
+5662,1381
+5685,1197
+5693,133666
+5707,1511
+5728,1381
+5742,1197
+5768,1511
+5781,133666
+5790,1381
+5810,1197
+5828,1511
+5852,1381
+5863,133666
+5873,1197
+5893,1511
+5913,1381
+5936,1197
+5944,133666
+5958,1511
+5979,1381
+5993,1197
+6019,1511
+6032,133666
+6041,1381
+6061,1197
+6079,1511
+6103,1381
+6114,133666
+6124,1197
+6144,1511
+6159,82312
+6164,1381
+6187,1197
+6195,133666
+6209,1511
+6230,1381
+6244,1197
+6270,1511
+6283,133666
+6292,1381
+6312,1197
+6330,1511
+6354,1381
+6365,133666
+6375,1197
+6395,1511
+6415,1381
+6438,1197
+6446,133666
+6460,1511
+6481,1381
+6495,1197
+6521,1511
+6534,133666
+6543,1381
+6563,1197
+6581,1511
+6605,1381
+6616,133666
+6626,1197
+6646,1511
+6666,1381
+6689,1197
+6697,133666
+6711,1511
+6732,1381
+6746,1197
+6772,1511
+6785,133666
+6794,1381
+6814,1197
+6832,1511
+6856,1381
+6867,133666
+6877,1197
+6897,1511
+6912,82312
+6917,1381
+6940,1197
+6948,133666
+6962,1511
+6983,1381
+6997,1197
+7023,1511
+7036,133666
+7045,1381
+7065,1197
+7083,1511
+7107,1381
+7118,133666
+7128,1197
+7148,1511
+7168,1381
+7191,1197
+7199,133666
+7213,1511
+7234,1381
+7248,1197
+7274,1511
+7287,133666
+7296,1381
+7316,1197
+7334,1511
+7358,1381
+7369,133666
+7379,1197
+7399,1511
+7419,1381
+7442,1197
+7450,133666
+7464,1511
+7485,1381
+7499,1197
+7525,1511
+7538,133666
+7547,1381
+7567,1197
+7585,1511
+7609,1381
+7620,133666
+7630,1197
+7650,1511
+7665,82312
+7670,1381
+7693,1197
+7701,133666
+7715,1511
+7736,1381
+7750,1197
+7776,1511
+7789,133666
+7798,1381
+7818,1197
+7836,1511
+7860,1381
+7871,133666
+7881,1197
+7901,1511
+7921,1381
+7944,1197
+7952,133666
+7966,1511
+7987,1381
+8001,1197
+8027,1511
+8040,133666
+8049,1381
+8069,1197
+8087,1511
+8111,1381
+8122,133666
+8132,1197
+8152,1511
+8172,1381
+8195,1197
+8203,133666
+8217,1511
+8238,1381
+8252,1197
+8278,1511
+8291,133666
+8300,1381
+8320,1197
+8338,1511
+8362,1381
+8373,133666
+8383,1197
+8403,1511
+8418,82312
+8423,1381
+8446,1197
+8454,133666
+8468,1511
+8489,1381
+8503,1197
+8529,1511
+8542,133666
+8551,1381
+8571,1197
+8589,1511
+8613,1381
+8624,133666
+8634,1197
+8654,1511
+8674,1381
+8697,1197
+8705,133666
+8719,1511
+8740,1381
+8754,1197
+8780,1511
+8793,133666
+8802,1381
+8822,1197
+8840,1511
+8864,1381
+8875,133666
+8885,1197
+8905,1511
+8925,1381
+8948,1197
+8956,133666
+8970,1511
+8991,1381
+9005,1197
+9031,1511
+9044,133666
+9053,1381
+9073,1197
+9091,1511
+9115,1381
+9126,133666
+9136,1197
+9156,1511
+9171,82312
+9176,1381
+9199,1197
+9207,133666
+9221,1511
+9242,1381
+9256,1197
+9282,1511
+9295,133666
+9304,1381
+9324,1197
+9342,1511
+9366,1381
+9377,133666
+9387,1197
+9407,1511
+9427,1381
+9450,1197
+9458,133666
+9472,1511
+9493,1381
+9507,1197
+9533,1511
+9546,133666
+9555,1381
+9575,1197
+9593,1511
+9617,1381
+9628,133666
+9638,1197
+9658,1511
+9678,1381
+9701,1197
+9709,133666
+9723,1511
+9744,1381
+9758,1197
+9784,1511
+9797,133666
+9806,1381
+9826,1197
+9844,1511
+9868,1381
+9879,133666
+9889,1197
+9909,1511
+9924,82312
+9929,1381
+9952,1197
+9960,133666
+9974,1511
+9995,1381