diff --git a/CURRENT.md b/CURRENT.md index 379b6ca..e16c93d 100644 --- a/CURRENT.md +++ b/CURRENT.md @@ -1,30 +1,29 @@ -# 当前研究状态 — Phase 4AD +# 当前研究状态 — Phase 4AE -已按用户授权建立独立分支 `codex/lif-author-semantics-lab`。 -正式状态：**COMPLETE-ORACLE-VALIDATED-LAB-ONLY**。 -学习仍未达到可用标准；不替换任何旧候选，不把实现检查PASS当作学习PASS。 +独立新模型分支：`codex/lif-author-semantics-lab`。 +正式状态：**PASS-ISOLATED-GPU-NUMERICAL-GATE**。 +尚未完成新动力学全脑验证或conditioning，学习仍未达到可用标准。 -- [关键结果、限制与下一步](docs/progress/phase4ad-interpretation.md) -- [完整实验报告](docs/progress/phase4ad-author-semantics.md) -- [实验预声明](models/male-cns-lif/author-semantics-lab-v1/PROTOCOL.md) -- [新产物封存核验](registry/phase4ad-author-semantics/seal-verification.json) -- [此前全脑输入背景复核](docs/progress/feedback-context-review-20260930.md) +- [本轮关键结果、限制和下一步](docs/progress/phase4ae-interpretation.md) +- [完整数值实验](docs/progress/phase4ae-author-runtime.md) +- [预先声明的协议](models/male-cns-lif/author-runtime-lab-v1/PROTOCOL.md) +- [交叉精度差异](registry/phase4ae-author-runtime/cross-precision-description.json) +- [校验与来源](registry/phase4ae-author-runtime/seal-verification.json) +- [上轮持续循环发现](docs/progress/phase4ad-interpretation.md) -## 关键发现 +## 已完成 -固定作者代码在Brian2 2.5.1实际运行。16项单元检查、10组真实回路/精度对照及其重复通过；58/58审计项通过。 -恢复作者完整动力学后，五节点真实回路1秒放电从1,483降到610，但后500ms仍有306次。 -因此不能认为“修g reset/不应期就解决学习问题”；持续循环仍存在，低活跃度不是晋级条件。 +12组固定小图/压力case、两种精度、各重复3次，共72次GPU执行。 +每次GPU与同精度实际Brian2参考的完整V/g history逐bit相同、最大误差0；事件、计数、不应期、请求送达及到达顺序/guard也一致。 +旧五组全脑参考回归和原230,239项及后续封存产物hash再次通过。 -下一步先做独立GPU实现的高入度/累加顺序与短时全图对照，再检验固定DoOR嗅觉输入是否保留区别；尚未开始conditioning。 -输入请求、不应期拒绝和实际放电必须分开统计。后续学习必须执行真实无调制/冻结/随机奖励对照和等待期，而非复用标签。 +float64与float32在临界阈值夹具分别放电4次/3次，因此不能把32位版本直接称为64位等价优化。 +旧模型、base CSR、原synapse count、W_syn、transmitter signs、APL校准、eligibility-v2和14,232 mask均未修改。 -## 冻结与服务 +## 下一步 -原230,239项以及4AA/4AB/4AC与背景复核封存文件前后校验不变。 -旧deterministic-v2五组全脑参考重新运行，事件、计数、最终电压和g精确一致。 -base CSR、raw counts、W_syn、transmitter signs、APL参数、eligibility-v2、14,232-edge mask未修改。 -只在独立实验环境安装作者版本依赖；未停用或修改ComfyUI。 -没有游戏、RL、decoder、视觉输入或权重训练，没有生成新的learned candidate。 +先用float64做完整图的10/50ms固定数值对照，再进行固定DoOR嗅觉信息保持测试。 +全部通过才进入真实学习验收：至少5个training seeds、独立evaluation、刺激特异性MBON/downstream，以及真正运行的对照和保持期。 +未训练、未进入游戏/RL/decoder/视觉接口。ComfyUI保持原样。 -代码、小报告、来源和校验清单进入Git；大数据及完整实验轨迹保留服务器，不等于完整异机备份。 +Git仅同步源码、小报告和校验清单；大数据与完整实验轨迹在服务器，不等于完整异机备份。 diff --git a/docs/progress/phase4ae-author-runtime.md b/docs/progress/phase4ae-author-runtime.md new file mode 100644 index 0000000..86a4318 --- /dev/null +++ b/docs/progress/phase4ae-author-runtime.md @@ -0,0 +1,37 @@ +# Phase 4AE GPU作者语义数值门禁 + +状态：`PASS-ISOLATED-GPU-NUMERICAL-GATE`。 + +仅验证固定小网络，尚未证明全脑等价、生物学正确或学习可用。未训练、未修改冻结输入或旧模型。 + +| case | precision | events | max V/g error V | exact whole history | pass | +|---|---|---:|---:|---|---| +| fanin_bursts | float64 | 1539 | 0.0 | True | True | +| fanin_bursts | float32 | 1539 | 0.0 | True | True | +| highest_indegree | float64 | 101 | 0.0 | True | True | +| highest_indegree | float32 | 101 | 0.0 | True | True | +| mixed_high_indegree | float64 | 106 | 0.0 | True | True | +| mixed_high_indegree | float32 | 106 | 0.0 | True | True | +| motif_feedforward | float64 | 3 | 0.0 | True | True | +| motif_feedforward | float32 | 3 | 0.0 | True | True | +| motif_five | float64 | 60 | 0.0 | True | True | +| motif_five | float32 | 60 | 0.0 | True | True | +| motif_no_input | float64 | 0 | 0.0 | True | True | +| motif_no_input | float32 | 0 | 0.0 | True | True | +| motif_pair | float64 | 22 | 0.0 | True | True | +| motif_pair | float32 | 22 | 0.0 | True | True | +| motif_trio | float64 | 45 | 0.0 | True | True | +| motif_trio | float32 | 45 | 0.0 | True | True | +| ordered_cancellation | float64 | 32 | 0.0 | True | True | +| ordered_cancellation | float32 | 32 | 0.0 | True | True | +| release_selfloop | float64 | 8 | 0.0 | True | True | +| release_selfloop | float32 | 8 | 0.0 | True | True | +| signed_random | float64 | 400 | 0.0 | True | True | +| signed_random | float32 | 400 | 0.0 | True | True | +| threshold_rounding | float64 | 4 | 0.0 | True | True | +| threshold_rounding | float32 | 3 | 0.0 | True | True | + +每项GPU执行3次，检查原始事件、输入请求实际送达、逐目标到达顺序及guard、计数、不应期和完整状态。 +大整数、随机图、重复/零边属于纯数值夹具，不是新增MaleCNS连接或生理假设。真实子图使用全部既有诱导边、原contact count与冻结transmitter sign。 +原始冻结完整性与旧五组全脑deterministic-v2回归再次核验；该旧回归PASS不等于新动力学全脑PASS。 +没有根据活动强度选择参数；尚须短时全图对照及嗅觉信息保持测试。 diff --git a/docs/progress/phase4ae-interpretation.md b/docs/progress/phase4ae-interpretation.md new file mode 100644 index 0000000..02d85cb --- /dev/null +++ b/docs/progress/phase4ae-interpretation.md @@ -0,0 +1,51 @@ +# Phase 4AE：独立GPU后端通过固定数值压力集 + +状态：`PASS-ISOLATED-GPU-NUMERICAL-GATE`。独立分支仍为 `codex/lif-author-semantics-lab`。 +这不是 learned candidate，也不是全脑或长期动力学等价声明。 + +## 具体推进 + +- 新增双精度CUDA后端，按已验证作者表达式逐次舍入，禁用FMA和fast-math。 +- 保留精确18-step delay与22-step refractory；只展开当时放电源的真实出边，不逐步扫描全部edge。 +- 突触从目标当前g开始逐条累加，不能先求边权和再加；刚放电的目标拒绝同tick输入。 +- 将实际请求、允许注入、不应期拒绝分开统计。没有采用作者poi接口的rfc=0策略。 +- Brian2实际队列由只读代理观测；每个oracle再做无代理复跑，证明观测工具没有改变输出。 + +固定12组case × float64/float32 × 3次GPU执行，**72/72通过**。 +全部状态history逐bit一致，V/g最大绝对差为0；事件、计数、不应期、请求送达、逐目标到达顺序和接受标记均一致。 +三次GPU重复逐数组相同，24组Brian oracle的观测/无观测对照均通过。 +这些是整个短轨迹的对照，不是仅比较总spike数或末态。 + +## 覆盖范围和未覆盖项 + +5个合成夹具覆盖有序正负抵消、256源fan-in、同tick输入与不应期释放、自环/队列回绕、阈值可表示数邻域，以及固定seed随机有符号网络。 +极大整数、重复/零边只用于明确标记的数值夹具，不是真实MaleCNS新连接或生理参数。 + +2个真实128-neuron诱导子图按入度和原contact count选取，保持所有真实内部边与sign。 +两者中心都是全图最高入度节点neuron_idx=5/body_id=10009/type=CT1，入度11,526；伙伴组成不同。 +这是数值压力测试，不是两个独立中心的证据，也不是视觉编码实验。 +另有原4AD五个固定真实motif的100ms前缀。还没有覆盖所有全图累加场景和长时间反馈。 + +## 精度差异不能隐藏 + +作者float64与作者float32在阈值临界夹具产生4次和3次事件，首次分歧在tick0。 +两套GPU分别精确复制了各自参考，但**float32不能因此称为float64的等价加速**。 +本轮没有放宽事件门槛，没有根据活动强度选模型。下一次全图首先使用作者默认float64，以减少精度混淆。 +[完整交叉精度记录](../../registry/phase4ae-author-runtime/cross-precision-description.json)。 + +## 下一步与学习门槛 + +下一关：166,700节点/25,582,938边完整图的短时float64逐步对照：无输入10ms、固定单seed50ms、固定五seed50ms。 +采用连续运行和流式状态记录，不保存dense spike矩阵；比较实际队列摘要及所有细胞的每tick状态。 +通过后才进行固定DoOR嗅觉CAL，并独立审计原graded APL与新语义的组合。 +只有信息保持、held-out区分和真实conditioning功能/对照通过，才能讨论学习候选；不能从本轮数值PASS跳到学习PASS。 + +## 完整性与运行信息 + +原230,239项及4AA–4AD、背景复核前后hash检查通过，旧五个deterministic-v2全脑参考再次精确一致。 +新模型11个payload、新实验916个payload独立封存。ComfyUI未修改，科学环境未升级。 +72次GPU诊断总wall约15.93s；诊断峰值allocated VRAM约5.45MB。 +这些数值来自小图并包含诊断同步，**不是全脑性能或实时性承诺**；旧全脑回归峰值约286MB也不是新动力学性能。 +大数据/完整状态只留服务器；Git同步源码、小报告、出处与checksum，不等于完整异机备份。 + +详见[完整实验报告](phase4ae-author-runtime.md)、[预声明](../../models/male-cns-lif/author-runtime-lab-v1/PROTOCOL.md)、[封存校验](../../registry/phase4ae-author-runtime/seal-verification.json)。 diff --git a/models/male-cns-lif/author-runtime-lab-v1/PROTOCOL.md b/models/male-cns-lif/author-runtime-lab-v1/PROTOCOL.md new file mode 100644 index 0000000..e6f378d --- /dev/null +++ b/models/male-cns-lif/author-runtime-lab-v1/PROTOCOL.md @@ -0,0 +1,68 @@ +# Phase 4AE — GPU author-semantics numerical gate + +User authorized an independent model branch. This is not conditioning and does +not replace any Phase 1–4AD candidate/artifact. Learning remains unachieved. +The fixed author equations and all physical parameters come from the validated +4AD oracle, with dt=.1ms, delay=18 steps, refractory=22 steps and W=.275mV. +Canonical CSR, raw contact counts and frozen transmitter signs are read-only. + +## Predeclared tests + +Five synthetic numerical fixtures: ordered cancellation (including deliberately +nonphysiological large signed integers), 256-source fan-in bursts, refractory +release/self-loop collisions, representable threshold neighbours, and a fixed +seed signed random graph. Synthetic negative node labels are NOT MaleCNS IDs; +duplicate/zero edges occur only in labelled numerical fixtures. + +Two 128-neuron real induced graphs are selected before simulation: the highest +in-degree target and its 127 largest-contact presynaptic partners; separately the +highest-in-degree target with >=64 positive and >=63 negative presynaptic inputs, +64 positive and 63 negative largest-contact partners. Ties break by canonical +neuron_idx. Include every existing edge within the selected node set, without +changing raw counts/signs or adding edges. This is numerical stress, not an input +interface or a physiological validation. Preserve identities and selection audit. + +Also run the same five 4AD motifs for 100ms with one common seed request (or no +request for no_input). Report every outcome; do not select by activity/separability. +These tests do not exhaust all full-brain numerical corner cases. + +## Exact arithmetic and schedule + +Execute unchanged pinned author create_model in Brian2 2.5.1/NumPy1.22.3 using +the isolated 4AD environment. Export raw SI variables, actual coefficients and +weights. GPU float32 coefficients round to float32 before each multiply/add; +float64 uses double. No FMA or fast-math. Match generated expression order. + +Update refractory and integrate; apply only currently permitted voltage seed +requests; strict threshold closes write access immediately; then accept delayed +anatomical arrivals in author order within each target, external synthetic input, +and reset. A fused reset is equivalent only if all arrivals reject current spikes. +Never replace sequential g+=w with g+sum(w). A queue proxy observes real Brian +arrival order without changing values; compare proxy and unwrapped runs exactly. +Use an exact spike ring buffer, no approximated delay or dense edge scan. + +Before-threshold requests use the existing common requested-event convention, +not the author's distinct poi interface that changes target refractory to zero. +Report requested/accepted/rejected input separately. No graded APL in these isolated +tests; its future integration and frozen coefficients require explicit audit. + +For each case/precision compare GPU to the same-precision real Brian oracle: +exact events, counts, refractory, input delivery and per-target arrival order/guard; +report full-history max/mean V/g error and bitwise state comparison. Fixed tolerance +is 1e-11V float64 / 1e-6V float32. Any event divergence fails, regardless of tolerance. +Each GPU case repeats three times with all arrays exactly equal. Cross-precision +differences are separately descriptive, not grounds to change thresholds. + +## Integrity and progression + +Preregister sources, old input hashes and deterministic fixture hashes before any +model execution. Preserve failures; use a separately recorded new attempt for +implementation repairs. Do not change frozen artifacts. Save manifests/SHA-256. +Old five deterministic-v2 full-brain reference regressions must pass again. +Only then consider a short full-graph author comparison, followed by DoOR CAL; +never claim full-brain equivalence or learning from isolated test PASS. + +Author source/license/provenance are inherited read-only from 4AD. Supporting +primary documentation: https://numpy.org/doc/1.22/reference/generated/numpy.ufunc.at.html +and https://brian2.readthedocs.io/en/2.5.1/user/refractoriness.html . The fixed +generated source and actual boundary fixtures, not simplified prose, define timing. diff --git a/models/male-cns-lif/author-runtime-lab-v1/author_ext.cpp b/models/male-cns-lif/author-runtime-lab-v1/author_ext.cpp new file mode 100644 index 0000000..d0d2fd3 --- /dev/null +++ b/models/male-cns-lif/author-runtime-lab-v1/author_ext.cpp @@ -0,0 +1,18 @@ +#include + +void author_state_cuda(torch::Tensor v, torch::Tensor g, torch::Tensor ref, + torch::Tensor requests, torch::Tensor spikes, torch::Tensor counts, + double gd, double c0, double cg, double cv, double threshold, + double reset, double seed_volt, int64_t refractory_steps); +void author_fill_edges_cuda(torch::Tensor indptr, torch::Tensor sources, + torch::Tensor offsets, torch::Tensor output); +void author_arrivals_cuda(torch::Tensor edges, torch::Tensor starts, torch::Tensor targets, + torch::Tensor weights, torch::Tensor g, torch::Tensor ref); +void author_external_cuda(torch::Tensor external, torch::Tensor g, torch::Tensor ref); + +PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) { + m.def("state_step", &author_state_cuda, "Author NumPy-ordered integration/threshold/reset"); + m.def("fill_edges", &author_fill_edges_cuda, "Expand only active-source canonical CSR edges"); + m.def("apply_arrivals", &author_arrivals_cuda, "Sequential per-target arrival additions"); + m.def("apply_external", &author_external_cuda, "Post-anatomical external arrival additions"); +} diff --git a/models/male-cns-lif/author-runtime-lab-v1/author_ext.cu b/models/male-cns-lif/author-runtime-lab-v1/author_ext.cu new file mode 100644 index 0000000..3373bab --- /dev/null +++ b/models/male-cns-lif/author-runtime-lab-v1/author_ext.cu @@ -0,0 +1,213 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace { +constexpr int BLOCK = 128; + +void check_tensor(const torch::Tensor& x, const torch::Tensor& like, + at::ScalarType dtype, const char* name) { + TORCH_CHECK(x.is_cuda() && x.is_contiguous() && x.dim() == 1, + name, " must be a contiguous CUDA vector"); + TORCH_CHECK(x.device() == like.device(), name, " is on a different CUDA device"); + TORCH_CHECK(x.scalar_type() == dtype, name, " has the wrong dtype"); +} +void check_state(const torch::Tensor& g, const torch::Tensor& ref) { + TORCH_CHECK(g.scalar_type() == torch::kFloat32 || g.scalar_type() == torch::kFloat64, + "state must be float32 or float64"); + check_tensor(g, g, g.scalar_type(), "g"); + check_tensor(ref, g, torch::kInt32, "ref"); + TORCH_CHECK(g.numel() == ref.numel(), "g/ref length mismatch"); + TORCH_CHECK(g.numel() <= std::numeric_limits::max(), "too many neurons"); +} +void index_range(const torch::Tensor& x, int64_t upper, const char* name) { + if (x.numel()) { + TORCH_CHECK(x.min().item() >= 0 && x.max().item() < upper, + name, " index out of bounds"); + } +} + +template __device__ __forceinline__ T add_rn(T a, T b); +template <> __device__ __forceinline__ float add_rn(float a, float b) { return __fadd_rn(a, b); } +template <> __device__ __forceinline__ double add_rn(double a, double b) { return __dadd_rn(a, b); } +template __device__ __forceinline__ T mul_rn(T a, T b); +template <> __device__ __forceinline__ float mul_rn(float a, float b) { return __fmul_rn(a, b); } +template <> __device__ __forceinline__ double mul_rn(double a, double b) { return __dmul_rn(a, b); } + +template +__global__ void state_kernel(T* v, T* g, int32_t* ref, const uint8_t* requests, + uint8_t* spikes, int32_t* counts, int n, T gd, T c0, + T cg, T cv, T threshold, T reset, T seed_volt, int ref_steps) { + const int i = blockIdx.x * blockDim.x + threadIdx.x; + if (i >= n) return; + int r = ref[i]; + r = r > 0 ? r - 1 : 0; + const bool available = r == 0; + T vi = v[i]; + if (available) { + const T oldg = g[i]; + const T oldv = vi; + // Match NumPy float-array expression evaluation: each operation rounds in T. + g[i] = mul_rn(gd, oldg); + const T driven = mul_rn(cg, oldg); + const T leaked = mul_rn(cv, oldv); + vi = add_rn(c0, add_rn(driven, leaked)); + if (requests[i]) vi = seed_volt; + } + const bool fired = available && vi > threshold; + if (fired) { + vi = reset; + g[i] = T(0); + r = ref_steps; + counts[i] += 1; + } + // Nonavailable neurons retain V/g. Resetting fired cells before arrivals is + // equivalent to reset-after-arrivals because all their arrivals are rejected. + v[i] = vi; + ref[i] = r; + spikes[i] = fired ? 1 : 0; +} + +__global__ void fill_kernel(const int64_t* indptr, const int64_t* sources, + const int64_t* offsets, int64_t* output, int n) { + const int i = blockIdx.x * blockDim.x + threadIdx.x; + if (i >= n) return; + const int64_t source = sources[i]; + const int64_t begin = indptr[source]; + const int64_t end = indptr[source + 1]; + for (int64_t j = begin; j < end; ++j) output[offsets[i] + j - begin] = j; +} + +template +__global__ void arrival_kernel(const int64_t* edges, const int64_t* starts, + const int32_t* targets, const T* weights, T* g, + const int32_t* ref, int segments, int64_t edge_count) { + const int segment = blockIdx.x * blockDim.x + threadIdx.x; + if (segment >= segments) return; + const int target = targets[segment]; + if (ref[target] != 0) return; + const int64_t end = segment + 1 < segments ? starts[segment + 1] : edge_count; + // Start at existing g, never sum weights separately: cancellation can differ. + T accumulator = g[target]; + for (int64_t j = starts[segment]; j < end; ++j) + accumulator = add_rn(accumulator, weights[edges[j]]); + g[target] = accumulator; +} + +template +__global__ void external_kernel(const T* external, T* g, const int32_t* ref, int n) { + const int i = blockIdx.x * blockDim.x + threadIdx.x; + if (i < n && ref[i] == 0 && external[i] != T(0)) + g[i] = add_rn(g[i], external[i]); +} +} // namespace + +void author_state_cuda(torch::Tensor v, torch::Tensor g, torch::Tensor ref, + torch::Tensor requests, torch::Tensor spikes, torch::Tensor counts, + double gd, double c0, double cg, double cv, double threshold, + double reset, double seed_volt, int64_t refractory_steps) { + check_state(g, ref); + const c10::cuda::CUDAGuard guard(g.device()); + check_tensor(v, g, g.scalar_type(), "v"); + check_tensor(requests, g, torch::kUInt8, "requests"); + check_tensor(spikes, g, torch::kUInt8, "spikes"); + check_tensor(counts, g, torch::kInt32, "counts"); + const int64_t n = g.numel(); + TORCH_CHECK(v.numel() == n && requests.numel() == n && spikes.numel() == n && counts.numel() == n, + "state vector length mismatch"); + TORCH_CHECK(refractory_steps > 0 && refractory_steps <= std::numeric_limits::max(), + "invalid refractory length"); + for (double x : {gd, c0, cg, cv, threshold, reset, seed_volt}) + TORCH_CHECK(std::isfinite(x), "nonfinite coefficient"); + if (!n) return; + const auto stream = at::cuda::getCurrentCUDAStream(g.get_device()); + AT_DISPATCH_FLOATING_TYPES(g.scalar_type(), "author_state", [&] { + state_kernel<<<(n + BLOCK - 1) / BLOCK, BLOCK, 0, stream>>>( + v.data_ptr(), g.data_ptr(), ref.data_ptr(), + requests.data_ptr(), spikes.data_ptr(), counts.data_ptr(), + static_cast(n), static_cast(gd), static_cast(c0), + static_cast(cg), static_cast(cv), static_cast(threshold), + static_cast(reset), static_cast(seed_volt), static_cast(refractory_steps)); + }); + C10_CUDA_KERNEL_LAUNCH_CHECK(); +} + +void author_fill_edges_cuda(torch::Tensor indptr, torch::Tensor sources, + torch::Tensor offsets, torch::Tensor output) { + check_tensor(indptr, indptr, torch::kInt64, "indptr"); + const c10::cuda::CUDAGuard guard(indptr.device()); + check_tensor(sources, indptr, torch::kInt64, "sources"); + check_tensor(offsets, indptr, torch::kInt64, "offsets"); + check_tensor(output, indptr, torch::kInt64, "output"); + TORCH_CHECK(indptr.numel() >= 1 && sources.numel() == offsets.numel(), "CSR shape mismatch"); + TORCH_CHECK(sources.numel() <= std::numeric_limits::max(), "too many sources"); + TORCH_CHECK(indptr[0].item() == 0, "CSR indptr must begin at zero"); + if (indptr.numel() > 1) + TORCH_CHECK((indptr.slice(0, 1) >= indptr.slice(0, 0, -1)).all().item(), "CSR indptr not monotonic"); + index_range(sources, indptr.numel() - 1, "source"); + if (!sources.numel()) { + TORCH_CHECK(output.numel() == 0, "nonempty expansion for no active sources"); + return; + } + const auto degrees = indptr.index_select(0, sources + 1) - indptr.index_select(0, sources); + const auto expected_offsets = degrees.cumsum(0) - degrees; + TORCH_CHECK(torch::equal(offsets, expected_offsets), "incorrect output offsets"); + TORCH_CHECK(degrees.sum().item() == output.numel(), "incorrect expansion length"); + const auto stream = at::cuda::getCurrentCUDAStream(indptr.get_device()); + fill_kernel<<<(sources.numel() + BLOCK - 1) / BLOCK, BLOCK, 0, stream>>>( + indptr.data_ptr(), sources.data_ptr(), offsets.data_ptr(), + output.data_ptr(), static_cast(sources.numel())); + C10_CUDA_KERNEL_LAUNCH_CHECK(); +} + +void author_arrivals_cuda(torch::Tensor edges, torch::Tensor starts, torch::Tensor targets, + torch::Tensor weights, torch::Tensor g, torch::Tensor ref) { + check_state(g, ref); + const c10::cuda::CUDAGuard guard(g.device()); + check_tensor(edges, g, torch::kInt64, "edges"); + check_tensor(starts, g, torch::kInt64, "starts"); + check_tensor(targets, g, torch::kInt32, "targets"); + check_tensor(weights, g, g.scalar_type(), "weights"); + TORCH_CHECK(starts.numel() == targets.numel(), "segment count mismatch"); + TORCH_CHECK(starts.numel() <= std::numeric_limits::max(), "too many target segments"); + if (!starts.numel()) { + TORCH_CHECK(!edges.numel(), "edges without target segments"); + return; + } + index_range(edges, weights.numel(), "edge"); + index_range(starts, edges.numel(), "segment start"); + index_range(targets, g.numel(), "target"); + TORCH_CHECK(starts[0].item() == 0, "first segment must start at zero"); + if (starts.numel() > 1) { + TORCH_CHECK((starts.slice(0, 1) > starts.slice(0, 0, -1)).all().item(), "segment starts not increasing"); + TORCH_CHECK((targets.slice(0, 1) > targets.slice(0, 0, -1)).all().item(), "targets must be unique and increasing"); + } + const auto stream = at::cuda::getCurrentCUDAStream(g.get_device()); + AT_DISPATCH_FLOATING_TYPES(g.scalar_type(), "author_arrivals", [&] { + arrival_kernel<<<(starts.numel() + BLOCK - 1) / BLOCK, BLOCK, 0, stream>>>( + edges.data_ptr(), starts.data_ptr(), targets.data_ptr(), + weights.data_ptr(), g.data_ptr(), ref.data_ptr(), + static_cast(starts.numel()), edges.numel()); + }); + C10_CUDA_KERNEL_LAUNCH_CHECK(); +} + +void author_external_cuda(torch::Tensor external, torch::Tensor g, torch::Tensor ref) { + check_state(g, ref); + const c10::cuda::CUDAGuard guard(g.device()); + check_tensor(external, g, g.scalar_type(), "external"); + TORCH_CHECK(external.numel() == g.numel(), "external/state length mismatch"); + if (!g.numel()) return; + const auto stream = at::cuda::getCurrentCUDAStream(g.get_device()); + AT_DISPATCH_FLOATING_TYPES(g.scalar_type(), "author_external", [&] { + external_kernel<<<(g.numel() + BLOCK - 1) / BLOCK, BLOCK, 0, stream>>>( + external.data_ptr(), g.data_ptr(), ref.data_ptr(), static_cast(g.numel())); + }); + C10_CUDA_KERNEL_LAUNCH_CHECK(); +} diff --git a/models/male-cns-lif/author-runtime-lab-v1/checksums.sha256 b/models/male-cns-lif/author-runtime-lab-v1/checksums.sha256 new file mode 100644 index 0000000..da5fc46 --- /dev/null +++ b/models/male-cns-lif/author-runtime-lab-v1/checksums.sha256 @@ -0,0 +1,12 @@ +72601f46dde3202d62e71161958f620a3ce5b8f9c24cf1f5b7158289b5f9a3f0 PROTOCOL.md +208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15 author_ext.cpp +669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e author_ext.cu +356b6161576f6f6d79745af1927bb43b12a7c3d50922bf9e1bd29e473fcf2106 config.json +9eea9a592241cab7f4303850e969def7887eee3f4ec18421103605cafd258cf8 context.py +cb75d512ddf9a5ff344f3ac82eefb112406593bf7b414dfac79d7c5d730371ee finalize.py +03758d07572f4b44d272059d9308fac534268ad201b57bdd77d69fee95e67278 gpu_backend.py +32eb1c42383068ce52701d2139a376ce155ad7072cde019949f8ca2d55492409 oracle_stress.py +2519eaa2c50b2d91fd0c4f623aeabd6f5d212c5b537951d0a66bc81c569db78c prepare.py +92733a48921f95c3c0935bf16a704634b89b6540352f31cc1169ec6d3211b57a run_suite.py +720d04b379b6f1f64cae28a2203444a6d4c4e72ecb121cc69e93c2740fae69ab verify_frozen.py +7e8b0ac4adcd48eceabca7c9cc4f2c42a8746ebc673aee4490bae5a4746bbe12 manifest.json diff --git a/models/male-cns-lif/author-runtime-lab-v1/config.json b/models/male-cns-lif/author-runtime-lab-v1/config.json new file mode 100644 index 0000000..df4009b --- /dev/null +++ b/models/male-cns-lif/author-runtime-lab-v1/config.json @@ -0,0 +1,19 @@ +{ + "phase": "4AE", + "name": "author-runtime-lab-v1", + "human_authorization": "允许独立新模型分支测试动力学假设", + "seed": 410301, + "gpu_uuid": "GPU-79f3a85d-adce-7833-7003-6488140ca596", + "precisions": ["float64", "float32"], + "gpu_repeats": 3, + "max_abs_volt": {"float64": 1e-11, "float32": 1e-6}, + "exact_events_required": true, + "exact_refractory_required": true, + "exact_arrival_order_per_tick_target_required": true, + "training": false, + "whole_brain_author_backend_claimed": false, + "candidate_generation": false, + "synthetic_cases": ["ordered_cancellation", "fanin_bursts", "release_selfloop", "threshold_rounding", "signed_random"], + "real_cases": ["highest_indegree", "mixed_high_indegree"], + "prior_motifs": ["pair", "trio", "five", "feedforward", "no_input"] +} diff --git a/models/male-cns-lif/author-runtime-lab-v1/context.py b/models/male-cns-lif/author-runtime-lab-v1/context.py new file mode 100644 index 0000000..53306bf --- /dev/null +++ b/models/male-cns-lif/author-runtime-lab-v1/context.py @@ -0,0 +1,40 @@ +import hashlib +import json +from pathlib import Path + +MODEL=Path(__file__).resolve().parent +ROOT=Path('/data/digital-drosophila') +EXP=ROOT/'experiments/phase4ae-author-runtime' +AD=ROOT/'experiments/phase4ad-author-semantics' +CFG=json.loads((MODEL/'config.json').read_text()) + +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 sources(): + 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(): + p=json.loads((EXP/'protocol/preregistered.json').read_text()) + assert sources()==p['sources'],'Source changed after preregistration' + for row in p['inputs']:assert digest(ROOT/row['path'])==row['sha256'],row['path'] + for row in json.loads((EXP/'protocol/case-hashes.json').read_text()):assert digest(EXP/row['path'])==row['sha256'],row['path'] + return p + +def integrity(): + import sys + sys.path.insert(0,str(ROOT/'models/male-cns-lif/lif-semantics-audit-v1')) + import audit_semantics as old + r=old.integrity() + for rel in ('models/male-cns-lif/lif-semantics-audit-v1','experiments/phase4ac-lif-semantics', + 'registry/feedback-context-review-20260930','models/male-cns-lif/author-semantics-lab-v1','experiments/phase4ad-author-semantics'): + r[rel]=old.manifest_check(ROOT/rel,digest) + assert all(x['pass'] for x in r.values()) + return r diff --git a/models/male-cns-lif/author-runtime-lab-v1/finalize.py b/models/male-cns-lif/author-runtime-lab-v1/finalize.py new file mode 100644 index 0000000..add5ded --- /dev/null +++ b/models/male-cns-lif/author-runtime-lab-v1/finalize.py @@ -0,0 +1,52 @@ +"""Gate the diagnostic prototype, never promote it as learned/full-brain runtime.""" +import json +from pathlib import Path +import sys +from context import ROOT,EXP,MODEL,CFG,save,check,integrity,digest +from run_suite import load,compare + +def seal(root): + rows=[] + for p in sorted(root.rglob('*')): + if '__pycache__' in p.parts or '.venv' in p.parts:continue + if p.is_file():rows.append(dict(path=str(p.relative_to(root)),bytes=p.stat().st_size,sha256=digest(p))) + assert not (root/'manifest.json').exists() and not (root/'checksums.sha256').exists() + save(root/'manifest.json',dict(root=str(root),files=rows)) + with (root/'checksums.sha256').open('x') as f: + for r in rows:f.write(r['sha256']+' '+r['path']+'\n') + f.write(digest(root/'manifest.json')+' manifest.json\n') + +def main(): + check();after=integrity();save(EXP/'regression/old-integrity-after.json',after) + summary=json.loads((EXP/'regression/gpu-complete.json').read_text());ref=json.loads((EXP/'regression/frozen-five.json').read_text()) + expected=(len(CFG['synthetic_cases'])+len(CFG['real_cases'])+len(CFG['prior_motifs']))*len(CFG['precisions'])*CFG['gpu_repeats'] + assert len(summary['trials'])==expected + rows=[] + for record in summary['trials']: + name=record['case'];precision=record['precision'];repeat=record['repeat'];case=EXP/'cases'/name + oracle=load(EXP/'oracle'/(name+'-'+precision)/'state.npz');gpu=load(EXP/'gpu'/(name+'-'+precision+f'-r{repeat}')/'state.npz') + actual=compare(oracle,gpu,case,precision);assert actual==record['comparison'],'Stored report differs from raw states' + first=load(EXP/'gpu'/(name+'-'+precision+'-r0')/'state.npz') + import numpy as np + equal={k:bool(np.array_equal(v,gpu[k])) for k,v in first.items()};assert equal==record['repeat_arrays'] + rows.append(record) + passed=all(r['pass_all'] for r in rows) and ref['pass_all'] and all(x['pass'] for x in after.values()) + status='PASS-ISOLATED-GPU-NUMERICAL-GATE' if passed else 'FAIL-ISOLATED-GPU-NUMERICAL-GATE' + save(EXP/'audit/final-status.json',dict(status=status,pass_all=passed,cases=expected//6,gpu_runs=expected, + full_brain_author_equivalence=False,conditioning=False,learning_achieved=False,candidate_generated=False, + next_gate='Short full-graph same-precision author comparison, then fixed DoOR CAL only if numerical gates pass')) + lines=['# Phase 4AE GPU作者语义数值门禁','',f'状态：`{status}`。','', + '仅验证固定小网络，尚未证明全脑等价、生物学正确或学习可用。未训练、未修改冻结输入或旧模型。','', + '| case | precision | events | max V/g error V | exact whole history | pass |','|---|---|---:|---:|---|---|'] + for r in rows: + if r['repeat']:continue + c=r['comparison'];lines.append(f"| {r['case']} | {r['precision']} | {c['oracle_events']} | {c['max_abs_volt']} | {c['bitwise_history']} | {r['pass_all']} |") + lines+=['','每项GPU执行3次，检查原始事件、输入请求实际送达、逐目标到达顺序及guard、计数、不应期和完整状态。', + '大整数、随机图、重复/零边属于纯数值夹具，不是新增MaleCNS连接或生理假设。真实子图使用全部既有诱导边、原contact count与冻结transmitter sign。', + '原始冻结完整性与旧五组全脑deterministic-v2回归再次核验；该旧回归PASS不等于新动力学全脑PASS。', + '没有根据活动强度选择参数；尚须短时全图对照及嗅觉信息保持测试。',''] + with (EXP/'REPORT.md').open('x',encoding='utf-8') as f:f.write('\n'.join(lines)) + check();seal(MODEL);seal(EXP);print(status,flush=True) + if not passed:raise SystemExit(1) + +if __name__=='__main__':main() diff --git a/models/male-cns-lif/author-runtime-lab-v1/gpu_backend.py b/models/male-cns-lif/author-runtime-lab-v1/gpu_backend.py new file mode 100644 index 0000000..612b5f9 --- /dev/null +++ b/models/male-cns-lif/author-runtime-lab-v1/gpu_backend.py @@ -0,0 +1,275 @@ +"""Small-case diagnostic CUDA backend; SI states, explicit dtype rounding. + +run_gpu is serial, records CPU diagnostics, and is not a performance runtime. +Coefficients and optional weights must come from the same-precision Brian2 oracle. +""" +from functools import lru_cache +import hashlib +import json +import math +import os +from pathlib import Path +import time +import traceback + +import numpy as np +import torch +from torch.utils.cpp_extension import load + + +SOURCE_ROOT = Path(__file__).resolve().parent +COEFFICIENT_NAMES = ("gd", "c0", "cg", "cv", "threshold", "reset", "seed_volt") + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def write_json(path, data): + with Path(path).open("x", encoding="utf-8") as output: + json.dump(data, output, indent=2, allow_nan=False) + output.write("\n") + + +def digest(path): + checksum = hashlib.sha256() + with Path(path).open("rb") as source: + for block in iter(lambda: source.read(1 << 20), b""): + checksum.update(block) + return checksum.hexdigest() + + +@lru_cache(maxsize=None) +def _load_extension(build_path, signature): + build = Path(build_path) / ("author_cuda_" + signature[:16]) + build.mkdir(parents=True, exist_ok=True) + module = load(name="author_cuda_" + signature[:16], + sources=[str(SOURCE_ROOT / "author_ext.cpp"), str(SOURCE_ROOT / "author_ext.cu")], + build_directory=str(build), extra_cflags=["-O2"], + extra_cuda_cflags=["-O2", "--fmad=false", "--ftz=false", "--prec-div=true", "--prec-sqrt=true"], + verbose=False) + return module + + +def build_extension(build_root): + provenance = {"sources": {name: digest(SOURCE_ROOT / name) + for name in ("author_ext.cpp", "author_ext.cu")}, + "torch": torch.__version__, "torch_cuda": torch.version.cuda, + "arch_list": os.environ.get("TORCH_CUDA_ARCH_LIST"), + "cuda_flags": ["-O2", "--fmad=false", "--ftz=false", "--prec-div=true", "--prec-sqrt=true"]} + signature = hashlib.sha256(json.dumps(provenance, sort_keys=True).encode()).hexdigest() + return _load_extension(str(Path(build_root).resolve()), signature), provenance + + +def read_case(case_dir, precision, coefficients, weights): + case_dir = Path(case_dir) + require(precision in ("float32", "float64"), "precision must be float32 or float64") + dtype = np.dtype(precision) + with (case_dir / "spec.json").open(encoding="utf-8") as source: + spec = json.load(source) + for key in ("dt_ms", "steps", "duration_ms", "model"): + require(key in spec, "Missing spec field: " + key) + model = spec["model"] + for key in ("threshold_mv", "reset_potential_mv", "resting_potential_mv", + "synaptic_delay_ms", "refractory_ms", "w_syn_mv_per_anatomical_synapse"): + require(key in model and math.isfinite(float(model[key])), "Missing/nonfinite model field: " + key) + steps = spec["steps"] + require(type(steps) is int and 0 < steps < np.iinfo(np.int32).max, "Invalid step count") + dt = float(spec["dt_ms"]) + require(math.isfinite(dt) and dt > 0, "Invalid dt") + require(math.isfinite(float(spec["duration_ms"])) and + round(float(spec["duration_ms"]) / dt) == steps, "Duration/steps mismatch") + delay = round(float(model["synaptic_delay_ms"]) / dt) + refractory = round(float(model["refractory_ms"]) / dt) + require(delay == 18 and refractory == 22, "This declared backend requires delay=18 and refractory=22") + require(float(model["w_syn_mv_per_anatomical_synapse"]) == 0.275, "W_syn differs from frozen value") + coeff = {} + for key in COEFFICIENT_NAMES: + require(key in coefficients and math.isfinite(float(coefficients[key])), "Missing/nonfinite coefficient: " + key) + coeff[key] = float(coefficients[key]) + require(bool(np.isfinite(dtype.type(coeff[key]))), "Coefficient overflows requested dtype: " + key) + require(dtype.type(coeff["threshold"]) == dtype.type(float(model["threshold_mv"]) * .001), + "Oracle threshold differs from case spec") + require(dtype.type(coeff["reset"]) == dtype.type(float(model["reset_potential_mv"]) * .001), + "Oracle reset differs from case spec") + with np.load(case_dir / "arrays.npz", allow_pickle=False) as inputs: + arrays = {key: inputs[key].copy() for key in inputs.files} + required_types = {"nodes": "int32", "edge_id": "int64", "src": "int32", "dst": "int32", + "signed_raw": "int64", "requests": "uint8", "external_mv": "float64", + "initial_v_mv": "float64", "initial_g_mv": "float64"} + for key, expected in required_types.items(): + require(key in arrays and arrays[key].dtype == np.dtype(expected), "Missing/wrong array dtype: " + key) + nodes = arrays["nodes"] + require(nodes.ndim == 1 and len(np.unique(nodes)) == len(nodes), "Invalid neuron identities") + n = len(nodes) + require(n < 512, "This diagnostic backend is restricted to fewer than 512 cells") + edge_id = arrays["edge_id"] + require(edge_id.ndim == 1 and len(np.unique(edge_id)) == len(edge_id), "Invalid edge identities") + e = len(edge_id) + for key in ("src", "dst", "signed_raw"): + require(arrays[key].shape == (e,), "Edge vector shape mismatch: " + key) + for key in ("src", "dst"): + require(bool(np.all((arrays[key] >= 0) & (arrays[key] < n))), "Local edge endpoint out of bounds") + require(np.array_equal(np.lexsort((edge_id, arrays["src"])), np.arange(e)), + "Edges must already be canonical source/edge_id sorted; indices will not be silently reordered") + for key in ("requests", "external_mv"): + require(arrays[key].shape == (steps, n), "Trial array shape mismatch: " + key) + require(bool(np.all(arrays["requests"] <= 1)), "Request array is not Boolean uint8") + for key in ("initial_v_mv", "initial_g_mv"): + require(arrays[key].shape == (n,), "Initial state shape mismatch: " + key) + for key in ("external_mv", "initial_v_mv", "initial_g_mv"): + require(bool(np.isfinite(arrays[key]).all()), "Nonfinite case array: " + key) + if weights is None: + weight_array = np.asarray(arrays["signed_raw"] * (.275 * .001), dtype=dtype) + weight_origin = "signed_raw * (0.275 * 0.001), then cast to requested dtype" + else: + weight_array = np.asarray(weights, dtype=dtype) + weight_origin = "caller supplied oracle SI weight array" + require(weight_array.shape == (e,) and bool(np.isfinite(weight_array).all()), "Invalid SI weights") + for key in ("initial_v_mv", "initial_g_mv", "external_mv"): + converted = np.asarray(arrays[key] * .001, dtype=dtype) + require(bool(np.isfinite(converted).all()), "Conversion overflow: " + key) + return spec, arrays, coeff, np.ascontiguousarray(weight_array), weight_origin + + +def run_gpu(case_dir, out_dir, precision, coefficients, build_root, weights=None): + """Run one case; return state dict and save SI state plus GPU-selected arrivals. + + ``weights`` is optional SI volts in the original arrays.npz edge-row order. + Repeated calls share a cached extension; each needs a new exclusive out_dir. + """ + case_dir, out_dir = Path(case_dir), Path(out_dir) + require(not out_dir.exists(), "Refusing existing output directory: " + str(out_dir)) + spec, arrays, coeff, weight_array, weight_origin = read_case(case_dir, precision, coefficients, weights) + require(torch.cuda.is_available(), "CUDA unavailable") + require(torch.cuda.device_count() == 1 and "4090" in torch.cuda.get_device_name(), "Only the single declared RTX4090 is permitted") + out_dir.mkdir(parents=True, exist_ok=False) + start = time.perf_counter() + try: + ext, build_provenance = build_extension(build_root) + build_done = time.perf_counter() + device = torch.device("cuda", torch.cuda.current_device()) + torch.cuda.reset_peak_memory_stats(device) + dtype = torch.float32 if precision == "float32" else torch.float64 + numpy_dtype = np.dtype(precision) + n, steps = len(arrays["nodes"]), spec["steps"] + + def upload(value, target_dtype=None): + return torch.as_tensor(np.ascontiguousarray(value), device=device, dtype=target_dtype).contiguous() + + v = upload(np.asarray(arrays["initial_v_mv"] * .001, dtype=numpy_dtype), dtype) + g = upload(np.asarray(arrays["initial_g_mv"] * .001, dtype=numpy_dtype), dtype) + ref = torch.zeros(n, dtype=torch.int32, device=device) + counts = torch.zeros(n, dtype=torch.int32, device=device) + requests = upload(arrays["requests"], torch.uint8) + accepted_requests = torch.empty_like(requests) + rejected_requests = torch.empty_like(requests) + external = upload(np.asarray(arrays["external_mv"] * .001, dtype=numpy_dtype), dtype) + synaptic_weights = upload(weight_array, dtype) + dst = upload(arrays["dst"], torch.int32) + degrees_np = np.bincount(arrays["src"], minlength=n).astype(np.int64) + indptr_np = np.concatenate((np.zeros(1, np.int64), np.cumsum(degrees_np, dtype=np.int64))) + indptr = upload(indptr_np, torch.int64) + ring = torch.zeros((19, n), dtype=torch.uint8, device=device) + history = torch.empty((steps, 3, n), dtype=dtype, device=device) + event_steps, event_nodes = [], [] + arrival_steps, arrival_indices, arrival_accepted = [], [], [] + torch.cuda.synchronize(device) + simulation_start = time.perf_counter() + for step in range(steps): + spikes = ring[step % 19] + # The state kernel decrements refractory before considering a request. + # These diagnostics use that exact pre-kernel eligibility on the GPU. + available_after_decrement = ref <= 1 + accepted_requests[step].copy_(requests[step] & available_after_decrement.to(torch.uint8)) + rejected_requests[step].copy_(requests[step] & (~available_after_decrement).to(torch.uint8)) + ext.state_step(v, g, ref, requests[step], spikes, counts, + *[coeff[key] for key in COEFFICIENT_NAMES], 22) + if step >= 18: + due = ring[(step - 18) % 19] + sources = torch.nonzero(due, as_tuple=False).flatten().contiguous() + if sources.numel(): + degrees = indptr[sources + 1] - indptr[sources] + offsets = (torch.cumsum(degrees, dim=0) - degrees).contiguous() + edge_count = int(degrees.sum().item()) + expanded = torch.empty(edge_count, device=device, dtype=torch.int64) + ext.fill_edges(indptr, sources, offsets, expanded) + if edge_count: + destination = dst[expanded] + order = torch.argsort(destination, stable=True) + edge_indices = expanded[order].contiguous() + ordered_targets = destination[order] + boundary = torch.ones(edge_count, dtype=torch.bool, device=device) + boundary[1:] = ordered_targets[1:] != ordered_targets[:-1] + starts = torch.nonzero(boundary, as_tuple=False).flatten().contiguous() + targets = ordered_targets[starts].contiguous() + accepted = (ref[ordered_targets.long()] == 0).to(torch.uint8) + # Capture the actual CUDA-expanded and GPU-stable-sorted edge stream. + arrival_steps.append(np.full(edge_count, step, dtype=np.int32)) + arrival_indices.append(edge_indices.cpu().numpy().copy()) + arrival_accepted.append(accepted.cpu().numpy().copy()) + ext.apply_arrivals(edge_indices, starts, targets, synaptic_weights, g, ref) + ext.apply_external(external[step], g, ref) + history[step, 0].copy_(v) + history[step, 1].copy_(g) + history[step, 2].copy_(ref) + fired = torch.nonzero(spikes, as_tuple=False).flatten().cpu().numpy() + if len(fired): + event_steps.append(np.full(len(fired), step, dtype=np.int32)) + event_nodes.append(arrays["nodes"][fired]) + torch.cuda.synchronize(device) + simulation_done = time.perf_counter() + + def joined(chunks, dt): + return np.concatenate(chunks).astype(dt, copy=False) if chunks else np.empty(0, dtype=dt) + + result = {"nodes": arrays["nodes"], "history": history.cpu().numpy(), + "counts": counts.cpu().numpy(), "v": v.cpu().numpy(), "g": g.cpu().numpy(), + "ref": ref.cpu().numpy(), "weights": synaptic_weights.cpu().numpy(), + "step": joined(event_steps, np.int32), "neuron_idx": joined(event_nodes, np.int32), + "request_attempted": arrays["requests"].copy(), + "request_accepted": accepted_requests.cpu().numpy(), + "request_rejected": rejected_requests.cpu().numpy()} + arrival_index = joined(arrival_indices, np.int64) + arrivals = {"step": joined(arrival_steps, np.int32), "edge_index": arrival_index, + "edge_id": arrays["edge_id"][arrival_index], + "target_local": arrays["dst"][arrival_index], + "accepted": joined(arrival_accepted, np.uint8)} + result.update(arrival_step=arrivals["step"], arrival_edge_index=arrivals["edge_index"], + arrival_accepted=arrivals["accepted"]) + with (out_dir / "state.npz").open("xb") as target: + np.savez_compressed(target, **result) + with (out_dir / "arrival-order.npz").open("xb") as target: + np.savez_compressed(target, **arrivals) + finite = bool(all(np.isfinite(value).all() for value in result.values())) + metrics = {"precision": precision, "state_units": "SI volts; refractory is steps", + "coefficients_double_input": coeff, + "coefficients_effective_dtype": {key: float(numpy_dtype.type(value)) for key, value in coeff.items()}, + "weights_origin": weight_origin, "nodes": n, "edges": len(weight_array), "steps": steps, + "total_spikes": len(result["step"]), "arriving_edges": len(arrival_index), + "accepted_arriving_edges": int(np.count_nonzero(arrivals["accepted"])), + "requested": int(np.count_nonzero(result["request_attempted"])), + "accepted_requests": int(np.count_nonzero(result["request_accepted"])), + "rejected_requests": int(np.count_nonzero(result["request_rejected"])), + "all_finite": finite, "delay_steps": 18, "refractory_steps": 22, + "build_or_cache_seconds": build_done - start, + "diagnostic_simulation_seconds": simulation_done - simulation_start, + "wall_seconds": time.perf_counter() - start, + "gpu": torch.cuda.get_device_name(device), "device": str(device), + "peak_allocated_vram_bytes": int(torch.cuda.max_memory_allocated(device)), + "peak_reserved_vram_bytes": int(torch.cuda.max_memory_reserved(device)), + "build": build_provenance, + "input_sha256": {name: digest(case_dir / name) for name in ("spec.json", "arrays.npz")}, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": False, "oracle_validation_claim": False, + "whole_brain_run": False, "learning": False, + "cpu_transfer_each_step_for_diagnostics": True} + write_json(out_dir / "metrics.json", metrics) + require(finite, "Nonfinite GPU state; raw trace preserved") + return result + except Exception as error: + write_json(out_dir / "error.json", {"type": type(error).__name__, "message": str(error), + "traceback": traceback.format_exc(), "precision": precision, + "validation_pass": False}) + raise diff --git a/models/male-cns-lif/author-runtime-lab-v1/manifest.json b/models/male-cns-lif/author-runtime-lab-v1/manifest.json new file mode 100644 index 0000000..5b3266b --- /dev/null +++ b/models/male-cns-lif/author-runtime-lab-v1/manifest.json @@ -0,0 +1,60 @@ +{ + "root": "/data/digital-drosophila/models/male-cns-lif/author-runtime-lab-v1", + "files": [ + { + "path": "PROTOCOL.md", + "bytes": 4188, + "sha256": "72601f46dde3202d62e71161958f620a3ce5b8f9c24cf1f5b7158289b5f9a3f0" + }, + { + "path": "author_ext.cpp", + "bytes": 1203, + "sha256": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15" + }, + { + "path": "author_ext.cu", + "bytes": 10422, + "sha256": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + { + "path": "config.json", + "bytes": 805, + "sha256": "356b6161576f6f6d79745af1927bb43b12a7c3d50922bf9e1bd29e473fcf2106" + }, + { + "path": "context.py", + "bytes": 1707, + "sha256": "9eea9a592241cab7f4303850e969def7887eee3f4ec18421103605cafd258cf8" + }, + { + "path": "finalize.py", + "bytes": 3814, + "sha256": "cb75d512ddf9a5ff344f3ac82eefb112406593bf7b414dfac79d7c5d730371ee" + }, + { + "path": "gpu_backend.py", + "bytes": 16277, + "sha256": "03758d07572f4b44d272059d9308fac534268ad201b57bdd77d69fee95e67278" + }, + { + "path": "oracle_stress.py", + "bytes": 29235, + "sha256": "32eb1c42383068ce52701d2139a376ce155ad7072cde019949f8ca2d55492409" + }, + { + "path": "prepare.py", + "bytes": 8828, + "sha256": "2519eaa2c50b2d91fd0c4f623aeabd6f5d212c5b537951d0a66bc81c569db78c" + }, + { + "path": "run_suite.py", + "bytes": 5318, + "sha256": "92733a48921f95c3c0935bf16a704634b89b6540352f31cc1169ec6d3211b57a" + }, + { + "path": "verify_frozen.py", + "bytes": 2157, + "sha256": "720d04b379b6f1f64cae28a2203444a6d4c4e72ecb121cc69e93c2740fae69ab" + } + ] +} diff --git a/models/male-cns-lif/author-runtime-lab-v1/oracle_stress.py b/models/male-cns-lif/author-runtime-lab-v1/oracle_stress.py new file mode 100644 index 0000000..f187140 --- /dev/null +++ b/models/male-cns-lif/author-runtime-lab-v1/oracle_stress.py @@ -0,0 +1,502 @@ +"""Small, fixed-input Brian2 2.5.1 stress oracle for Phase 4AE. + +The archived author source, equations, reset, parameters, and synapses are left +unchanged. Diagnostic initial states and the old common request interface are +explicit inputs. This file does not install packages or run whole-brain cases. +""" +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_PATH = Path("/data/digital-drosophila/experiments/phase4ad-author-semantics/external-resources/model.py") +AUTHOR_SHA256 = "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e" +AUTHOR_COMMIT = "91bdd1e7dcf193f3e7ca5a8933497fcef63b7960" +LIO_NAMES = {"gd": "_lio_2", "c0": "_lio_8", "cg": "_lio_9", "cv": "_lio_10"} + + +def _save(path: Path, value) -> None: + with path.open("x", encoding="utf-8") as handle: + json.dump(value, handle, indent=2, sort_keys=True, allow_nan=False) + handle.write("\n") + + +def _save_arrays(path: Path, arrays: dict) -> None: + with path.open("xb") as handle: + np.savez_compressed(handle, **arrays) + + +def _digest(path: Path) -> str: + h = hashlib.sha256() + with path.open("rb") as handle: + for block in iter(lambda: handle.read(8 << 20), b""): + h.update(block) + return h.hexdigest() + + +def _check(condition, message: str) -> None: + if not condition: + raise ValueError(message) + + +def _load_case(case_dir: Path) -> tuple[dict, dict]: + spec = json.loads((case_dir / "spec.json").read_text(encoding="utf-8")) + with np.load(case_dir / "arrays.npz", allow_pickle=False) as archive: + arrays = {name: archive[name].copy() for name in archive.files} + expected_types = {"nodes": "int32", "edge_id": "int64", "src": "int32", + "dst": "int32", "signed_raw": "int64", "requests": "uint8", + "external_mv": "float64", "initial_v_mv": "float64", + "initial_g_mv": "float64"} + for name, dtype in expected_types.items(): + _check(name in arrays, f"Missing input array: {name}") + _check(arrays[name].dtype == np.dtype(dtype), f"{name} must have dtype {dtype}") + nodes = arrays["nodes"] + _check(nodes.ndim == 1 and 1 <= len(nodes) <= 512, "Stress cases require 1..512 nodes") + _check(np.all(np.diff(nodes.astype(np.int64)) > 0), "nodes must be sorted and unique") + steps = int(spec["steps"]) + _check(steps == spec["steps"] and 1 <= steps <= 1000, "steps must be an integer in 1..1000") + _check(float(spec["dt_ms"]) == .1, "The fixed stress protocol requires dt_ms=0.1") + if "duration_ms" in spec: + _check(np.isclose(float(spec["duration_ms"]), steps * .1, rtol=0, atol=1e-12), + "duration_ms disagrees with steps and dt_ms") + if "dt_ms" in spec["model"]: + _check(float(spec["model"]["dt_ms"]) == .1, "model dt_ms disagrees with case dt_ms") + edge_count = len(arrays["edge_id"]) + # The unchanged author calls Synapses.connect(i=[], j=[]), which Brian2 + # 2.5.1 does not support. Empty-network fixtures must explicitly provide + # a documented zero-weight synthetic edge in the input case. + _check(edge_count > 0, "Use an explicit zero-weight fixture edge instead of empty connectivity") + for name in ("edge_id", "src", "dst", "signed_raw"): + _check(arrays[name].shape == (edge_count,), f"{name} has an inconsistent shape") + _check(len(np.unique(arrays["edge_id"])) == edge_count, "edge_id must be unique") + for name in ("src", "dst"): + _check(np.all((arrays[name] >= 0) & (arrays[name] < len(nodes))), f"{name} is out of local range") + _check(np.array_equal(np.lexsort((arrays["edge_id"], arrays["src"])), np.arange(edge_count)), + "Edges must be in canonical source-then-edge order") + for name in ("requests", "external_mv"): + _check(arrays[name].shape == (steps, len(nodes)), f"{name} must have shape (steps, N)") + _check(np.all(arrays["requests"] <= 1), "requests must contain only 0 or 1") + for name in ("initial_v_mv", "initial_g_mv"): + _check(arrays[name].shape == (len(nodes),), f"{name} must have shape (N,)") + for name in ("external_mv", "initial_v_mv", "initial_g_mv"): + _check(np.isfinite(arrays[name]).all(), f"{name} contains a nonfinite value") + return spec, arrays + + +def _code_records(network) -> list: + records = [] + for obj in network.sorted_objects: + row = {"name": obj.name, "type": type(obj).__name__, + "when": obj.when, "order": int(obj.order), "active": bool(obj.active)} + if hasattr(obj, "abstract_code"): + abstract = obj.abstract_code + row["abstract_code"] = abstract if isinstance(abstract, (str, dict)) else str(abstract) + row["code_objects"] = [ + {"name": code.name, "generated_code": str(code.code)} + for code in getattr(obj, "code_objects", ())] + records.append(row) + return records + + +class _QueueReadProxy: + """Forward the queue unchanged; copy only observations from peek().""" + + def __init__(self, queue, get_tick, get_available, targets, observations, counters): + self._original_queue = queue + self._get_tick = get_tick + self._get_available = get_available + self._targets = targets + self._observations = observations + self._counters = counters + + def peek(self, *args, **kwargs): + value = self._original_queue.peek(*args, **kwargs) + edge_indices = np.asarray(value, dtype=np.int64).copy() + if np.any(edge_indices < 0) or np.any(edge_indices >= len(self._targets)): + raise AssertionError("The anatomical queue returned an invalid local edge index") + tick = self._get_tick() + accepted = np.asarray(self._get_available(), dtype=bool)[self._targets[edge_indices]].astype(np.uint8) + self._observations.append((tick, edge_indices, accepted)) + self._counters["peek_calls"] += 1 + return value + + def advance(self, *args, **kwargs): + self._counters["advance_calls"] += 1 + return self._original_queue.advance(*args, **kwargs) + + def __getattr__(self, name): + return getattr(self._original_queue, name) + + +def _scalar_namespace(code_runner, name: str): + for code in getattr(code_runner, "code_objects", ()): + if name in code.namespace: + value = np.asarray(code.namespace[name]) + if value.ndim == 0 and np.isfinite(value): + return float(value), {"source": "CodeObject.namespace", "code_object": code.name, + "name": name, "namespace_dtype": str(value.dtype)} + return None, None + + +def _coefficients(neu, parameters, b2, dt_seconds: float) -> dict: + generated = "\n".join(str(code.code) for code in neu.state_updater.code_objects) + _check("_lio_2 * g" in generated and + "_lio_8 + ((_lio_9 * g) + (_lio_10 * v))" in generated, + "Generated state expression changed; the recorded _lio-to-GPU mapping is not valid") + dt = np.float64(dt_seconds) + tau = np.float64(parameters["tau"] / b2.second) + membrane = np.float64(parameters["t_mbr"] / b2.second) + rest = np.float64(parameters["v_0"] / b2.volt) + # This is the actual scalar expression order emitted by the pinned Brian + # state updater, not an algebraically rearranged analytic solution. + lio_1 = (-dt) / tau + lio_3 = tau / (membrane - tau) + lio_4 = dt / membrane + lio_5 = dt / tau + lio_6 = (-dt) / membrane + fallback = { + "gd": np.exp(lio_1), "c0": rest - (rest * np.exp(lio_6)), + "cg": ((lio_3 * ((-np.exp(lio_4)) + np.exp(lio_5))) * np.exp(lio_6)) * np.exp(lio_1), + "cv": np.exp(lio_6), + } + result, provenance = {}, {} + for key, name in LIO_NAMES.items(): + value, record = _scalar_namespace(neu.state_updater, name) + if value is None: + value = float(fallback[key]) + record = {"source": "same generated scalar expression evaluated with numpy.float64", "name": name} + result[key], provenance[key] = value, record + for key, runner, name, author_key in ( + ("threshold", neu.thresholder["spike"], "v_th", "v_th"), + ("reset", neu.resetter["spike"], "v_rst", "v_rst"), + ): + value, record = _scalar_namespace(runner, name) + if value is None: + value = float(parameters[author_key] / b2.volt) + record = {"source": "unchanged author parameter", "name": name} + result[key], provenance[key] = value, record + result["seed_volt"] = float((parameters["v_th"] + 1 * b2.mV) / b2.volt) + provenance["seed_volt"] = {"source": "common request interface: unchanged v_th + 1 mV"} + result["metadata"] = { + "units": "SI volts and dimensionless coefficients", "names": LIO_NAMES, + "provenance": provenance, "hex": {key: value.hex() for key, value in result.items()}, + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))", + "g_expression": "gd * old_g", + "constant_values_are_double": True, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + } + return result + + +def _parameters_match(parameters, model, b2) -> dict: + rows = {} + 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), + ): + requested, actual = float(model[config_key]), float(parameters[author_key] / unit) + _check(np.isfinite(requested) and np.isclose(requested, actual, rtol=0, atol=1e-12), + f"Model parameter {config_key} differs from the archived author") + rows[config_key] = {"case": requested, "author": actual} + return rows + + +def _run_once(spec, arrays, precision, output, source_bytes, trace_queue): + import brian2 as b2 + from brian2.core.base import BrianObject + + output.mkdir(parents=True, exist_ok=False) + saved = {key: b2.prefs[key] for key in ( + "codegen.target", "core.default_float_dtype", "legacy.refractory_timing")} + old_dt = b2.defaultclock.dt + dtype = np.dtype(precision) + steps, nodes = int(spec["steps"]), arrays["nodes"] + dt_ms, dt_seconds = float(spec["dt_ms"]), float(spec["dt_ms"]) * .001 + 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 + author = types.ModuleType("phase4ae_author_" + precision) + author.__file__ = str(AUTHOR_PATH) + exec(compile(source_bytes, str(AUTHOR_PATH), "exec"), author.__dict__) + parameters = dict(author.default_params) + parameter_checks = _parameters_match(parameters, spec["model"], b2) + completeness = pd.DataFrame({"local_index": np.arange(len(nodes), dtype=np.int32)}, + index=pd.Index(nodes, name="global_neuron_idx")) + connectivity = pd.DataFrame({ + "Presynaptic_Index": arrays["src"], "Postsynaptic_Index": arrays["dst"], + "Excitatory x Connectivity": arrays["signed_raw"], "edge_id": arrays["edge_id"], + "source_neuron_idx": nodes[arrays["src"]], "target_neuron_idx": nodes[arrays["dst"]], + }) + comp_path, con_path = output / "completeness.csv", output / "connectivity.parquet" + completeness.to_csv(comp_path) + connectivity.to_parquet(con_path, engine="pyarrow", index=False) + neu, syn, spikes = author.create_model(comp_path, con_path, parameters) + _check(np.dtype(neu.variables["v"].dtype) == dtype and np.dtype(neu.variables["g"].dtype) == dtype, + "Brian state dtype disagrees with the precision arm") + _check(np.dtype(syn.variables["w"].dtype) == dtype, "Brian synaptic weight dtype disagrees") + np.testing.assert_array_equal(np.asarray(syn.i[:]), arrays["src"]) + np.testing.assert_array_equal(np.asarray(syn.j[:]), arrays["dst"]) + neu.v = arrays["initial_v_mv"] * b2.mV + neu.g = arrays["initial_g_mv"] * b2.mV + initial_v = np.asarray(neu.v_[:], dtype=dtype).copy() + initial_g = np.asarray(neu.g_[:], dtype=dtype).copy() + attempted = arrays["requests"].copy() + accepted = np.zeros_like(attempted) + rejected = np.zeros_like(attempted) + request_slots_seen = np.zeros(steps, dtype=np.uint8) + + def current_tick(): + return int(round(float(neu.clock.t / b2.second) / dt_seconds)) + + def requests_before_thresholds(): + tick = current_tick() + if tick < 0 or tick >= steps or request_slots_seen[tick]: + raise AssertionError("Common request operation executed outside its unique tick") + request_slots_seen[tick] = 1 + request = attempted[tick].astype(bool) + available = np.asarray(neu.not_refractory[:], dtype=bool) + permitted = request & available + accepted[tick] = permitted + rejected[tick] = request & ~available + if permitted.any(): + neu.v[np.flatnonzero(permitted)] = parameters["v_th"] + 1 * b2.mV + + request_op = b2.NetworkOperation(requests_before_thresholds, clock=neu.clock, + when="before_thresholds", order=0, name="oracle_common_requests") + objects = [neu, syn, spikes, request_op] + ext_ticks, ext_targets = np.nonzero(arrays["external_mv"]) + external_weights = np.empty(0, dtype=dtype) + if len(ext_ticks): + ext_ids = np.arange(len(ext_ticks), dtype=np.int32) + ext_source = b2.SpikeGeneratorGroup(len(ext_ticks), ext_ids, + ext_ticks.astype(np.float64) * dt_ms * b2.ms, sorted=True, + clock=neu.clock, name="zz_external_sources") + ext_syn = b2.Synapses(ext_source, neu, "w : volt", on_pre="g_post += w", + delay=0 * b2.ms, name="zz_external_arrivals") + ext_syn.connect(i=ext_ids, j=ext_targets) + ext_syn.w = arrays["external_mv"][ext_ticks, ext_targets] * b2.mV + ext_syn.pre.order = 0 + _check(syn.pre.when == ext_syn.pre.when == "synapses" and syn.pre.order < 0, + "External delivery must follow the original anatomical pathway") + external_weights = np.asarray(ext_syn.w_[:], dtype=dtype).copy() + objects.extend([ext_source, ext_syn]) + + observations = [] + queue_counters = {"peek_calls": 0, "advance_calls": 0, "installations": []} + if trace_queue: + class QueueInstaller(BrianObject): + def __init__(self): + super().__init__(clock=neu.clock, when="end", order=1_000_000, + name="zz_oracle_queue_installer") + + def before_run(self, run_namespace): + # Network.before_run traverses sorted objects. All original + # code runners have compiled before this last end-slot object. + installed = [] + for code in syn.pre.code_objects: + if "_queue" not in code.namespace or "_queue.peek()" not in str(code.code): + continue + original = code.namespace["_queue"] + if isinstance(original, _QueueReadProxy): + original = original._original_queue + code.namespace["_queue"] = _QueueReadProxy( + original, current_tick, lambda: neu.not_refractory[:], + arrays["dst"], observations, queue_counters) + installed.append(code.name) + if len(installed) != 1: + raise AssertionError(f"Expected exactly one anatomical queue consumer, got {installed}") + queue_counters["installations"].append(installed[0]) + + objects.append(QueueInstaller()) + + trace = b2.StateMonitor(neu, ["v", "g", "lastspike", "not_refractory"], + record=True, when="end", order=0, name="oracle_end_state") + objects.append(trace) + network = b2.Network(*objects) + _save(output / "schedule.json", {"schedule": list(network.schedule), + "summary": str(network.scheduling_summary())}) + _save(output / "input-audit.json", { + "source_sha256": AUTHOR_SHA256, "parameter_checks": parameter_checks, + "source_parameters_modified": False, "precision": precision, + "dt_ms": dt_ms, "steps": steps, "request_interface": "before_thresholds; v=v_th+1mV only if not_refractory", + "poisson_helper_used": False, "all_neurons_keep_original_rfc": True, + "queue_trace_enabled": trace_queue, "state_units": "SI volts, original dtype", + "completeness_sha256": _digest(comp_path), "connectivity_sha256": _digest(con_path), + }) + network.run(0 * b2.ms, namespace={}) + _save(output / "compiled-code.json", _code_records(network)) + if request_slots_seen.any() or observations: + raise AssertionError("Zero-duration compilation unexpectedly advanced the case") + network.run(steps * dt_ms * b2.ms, namespace={}) + _save(output / "generated-code.json", _code_records(network)) + _check(np.all(request_slots_seen == 1), "Not every request tick was observed exactly once") + + event_float = np.asarray(spikes.t[:] / b2.second, dtype=np.float64) / dt_seconds + event_ticks = np.rint(event_float).astype(np.int32) + _check(np.allclose(event_float, event_ticks, rtol=0, atol=1e-6), "Spike time is off the integer clock") + local_indices = np.asarray(spikes.i[:], dtype=np.int32).copy() + order = np.lexsort((nodes[local_indices], event_ticks)) + event_ticks, local_indices = event_ticks[order], local_indices[order] + fired = np.zeros_like(attempted) + fired[event_ticks, local_indices] = 1 + counts = np.asarray(spikes.count[:], dtype=np.int32).copy() + _check(np.array_equal(fired.sum(axis=0), counts), "Events and per-neuron counts disagree") + _check(not np.any(accepted & ~fired), "An applicable common request did not produce a real spike") + _check(np.array_equal(attempted, accepted + rejected), "Request accounting is incomplete") + state_ticks = np.asarray(trace.t[:] / b2.second, dtype=np.float64) / dt_seconds + _check(state_ticks.shape == (steps,) and np.allclose(state_ticks, np.arange(steps), rtol=0, atol=1e-6), + "StateMonitor does not cover the exact requested ticks") + voltage = np.asarray(trace.v_, dtype=dtype).T.copy() + conductance = np.asarray(trace.g_, dtype=dtype).T.copy() + last = np.asarray(trace.lastspike_, dtype=np.float64).T + seen = np.isfinite(last) & (last >= 0) + last_ticks = np.zeros(last.shape, dtype=np.int64) + last_ticks[seen] = np.rint(last[seen] / dt_seconds).astype(np.int64) + refractory_steps = int(round(float(parameters["t_rfc"] / b2.ms) / dt_ms)) + remaining = np.where(seen, np.maximum(refractory_steps - (np.arange(steps)[:, None] - last_ticks), 0), 0).astype(np.int32) + available_end = np.asarray(trace.not_refractory, dtype=bool).T + _check(np.array_equal(remaining == 0, available_end), "Refractory flag and integer countdown disagree") + history = np.stack([voltage, conductance, remaining.astype(dtype)], axis=1) + _check(np.isfinite(history).all(), "Author state became nonfinite") + arrival_step = np.empty(0, dtype=np.int32) + arrival_edge = np.empty(0, dtype=np.int64) + arrival_accepted = np.empty(0, dtype=np.uint8) + if trace_queue: + _check(queue_counters["peek_calls"] == steps and queue_counters["advance_calls"] == steps, + "Queue proxy did not observe exactly one peek and advance per tick") + _check([entry[0] for entry in observations] == list(range(steps)), "Queue peek ticks are not complete and ordered") + arrival_step = np.concatenate([np.full(len(ids), tick, dtype=np.int32) for tick, ids, _ in observations]) + arrival_edge = np.concatenate([ids for _, ids, _ in observations]).astype(np.int64, copy=False) + arrival_accepted = np.concatenate([mask for _, _, mask in observations]).astype(np.uint8, copy=False) + delay_steps = int(round(float(parameters["t_dly"] / b2.ms) / dt_ms)) + if len(arrival_step): + _check(np.all(arrival_step >= delay_steps), "An anatomical event arrived before the fixed delay") + _check(np.all(fired[arrival_step - delay_steps, arrays["src"][arrival_edge]]), + "A queued arrival has no matching presynaptic spike at the author delay") + _check(np.array_equal(arrival_accepted, + available_end[arrival_step, arrays["dst"][arrival_edge]].astype(np.uint8)), + "Observed arrival gating disagrees with the post-threshold refractory state") + source_counts_due = fired[:max(0, steps - delay_steps)].sum(axis=0, dtype=np.int64) + expected_arrivals = int(source_counts_due[arrays["src"]].sum(dtype=np.int64)) + _check(len(arrival_edge) == expected_arrivals, "Queue trace omitted or duplicated an anatomical arrival") + result = { + "nodes": nodes.copy(), "step": event_ticks, "local_idx": local_indices, + "neuron_idx": nodes[local_indices], "counts": counts, + "v": voltage[-1].copy(), "g": conductance[-1].copy(), "ref": remaining[-1].copy(), + "history": history, "ref_history": remaining, + "not_refractory": available_end.astype(np.uint8), + "weights": np.asarray(syn.w_[:], dtype=dtype).copy(), + "initial_v": initial_v, "initial_g": initial_g, + "request_attempted": attempted, "request_accepted": accepted, "request_rejected": rejected, + "request_count": attempted.sum(axis=1, dtype=np.int32), + "applicable_count": accepted.sum(axis=1, dtype=np.int32), + "rejected_count": rejected.sum(axis=1, dtype=np.int32), "fired": fired, + "arrival_step": arrival_step, "arrival_edge_index": arrival_edge, + "arrival_accepted": arrival_accepted, + "external_step": ext_ticks.astype(np.int32), "external_target": ext_targets.astype(np.int32), + "external_weights": external_weights, + "external_accepted": available_end[ext_ticks, ext_targets].astype(np.uint8), + } + coefficients = _coefficients(neu, parameters, b2, dt_seconds) + _save(output / "coefficients.json", coefficients) + _save(output / "queue-audit.json", { + **queue_counters, "trace_enabled": trace_queue, "due_events": len(arrival_edge), + "accepted_due_events": int(arrival_accepted.sum()), + "all_due_events_preserved": True if trace_queue else None, + "ordering": "raw anatomical queue.peek local edge-index sequence; no sorting or filtering", + "proxy_contract": "peek returns original object; advance and all other methods forward unchanged", + }) + _save_arrays(output / "state.npz", result) + return result, coefficients + except Exception as error: + _save(output / "error.json", {"type": type(error).__name__, "message": str(error)}) + raise + finally: + for key, value in saved.items(): + b2.prefs[key] = value + b2.defaultclock.dt = old_dt + + +def run_case(case_dir: Path, out_dir: Path, precision: str) -> dict: + """Run one <=512-node, <=1000-step fixed case with exclusive outputs. + + Main outputs are ``state.npz`` and ``coefficients.json``. Queue tracing is + enabled by default. ``spec.trace_queue`` can disable it; when enabled, + ``spec.validate_queue_proxy`` defaults to True and repeats the same case + without instrumentation. That repeat must match every non-arrival array + exactly. An opt-out is recorded as unverified, never as a successful check. + This function changes global Brian preferences temporarily; run it serially. + """ + _check(precision in ("float64", "float32"), "precision must be float64 or float32") + case_dir, out_dir = Path(case_dir).resolve(strict=True), Path(out_dir).resolve() + spec, arrays = _load_case(case_dir) + source_bytes = AUTHOR_PATH.read_bytes() + source_hash = hashlib.sha256(source_bytes).hexdigest() + _check(source_hash == AUTHOR_SHA256, "Archived author source hash mismatch") + trace_queue = spec.get("trace_queue", True) + validate_proxy = spec.get("validate_queue_proxy", trace_queue) + _check(isinstance(trace_queue, bool) and isinstance(validate_proxy, bool), "Queue switches must be JSON booleans") + _check(not validate_proxy or trace_queue, "Proxy validation requires queue tracing") + out_dir.mkdir(parents=True, exist_ok=False) + try: + versions = {} + for name in ("brian2", "numpy", "pandas", "scipy", "pyarrow", "sympy", "cython"): + versions[name] = importlib.metadata.version(name) + _save(out_dir / "environment.json", {"python": sys.version, "platform": platform.platform(), + "packages": versions, "backend": "Brian2 numpy runtime"}) + _check(versions["brian2"] == "2.5.1", "The stress oracle requires Brian2 2.5.1") + _check(versions["numpy"] == "1.22.3", "The stress oracle requires the recorded NumPy 1.22.3 promotion rules") + _save(out_dir / "case.json", {"spec": spec, "precision": precision, + "author_path": str(AUTHOR_PATH), "author_commit": AUTHOR_COMMIT, "author_sha256": source_hash, + "case_spec_sha256": _digest(case_dir / "spec.json"), "case_arrays_sha256": _digest(case_dir / "arrays.npz"), + "trace_queue": trace_queue, "validate_queue_proxy": validate_proxy, + "common_interface_preserved": True, "original_poi_interface_adopted": False, + "whole_brain": False, "learning": False}) + result, coefficients = _run_once(spec, arrays, precision, out_dir / "instrumented", + source_bytes, trace_queue) + # Preserve the primary result even if the independent proxy check fails. + _save_arrays(out_dir / "state.npz", result) + _save(out_dir / "coefficients.json", coefficients) + validation = {"performed": False, "pass": None, + "reason": "Disabled by explicit case switch" if not validate_proxy else None} + if validate_proxy: + baseline, baseline_coefficients = _run_once(spec, arrays, precision, out_dir / "unwrapped-audit", + source_bytes, False) + checks = {key: bool(np.array_equal(value, baseline[key])) + for key, value in result.items() if not key.startswith("arrival_")} + coefficient_keys = ["gd", "c0", "cg", "cv", "threshold", "reset", "seed_volt"] + checks["coefficients"] = all(coefficients[key] == baseline_coefficients[key] for key in coefficient_keys) + validation = {"performed": True, "pass": bool(all(checks.values())), + "exact_arrays": checks, + "arrival_arrays_excluded": "An unwrapped queue is deliberately not observed"} + _save(out_dir / "proxy-validation.json", validation) + _check(not validate_proxy or validation["pass"], "Queue proxy changed an author result") + _check(_digest(AUTHOR_PATH) == source_hash, "Author source changed during the stress case") + summary = {"name": spec["name"], "precision": precision, "steps": int(spec["steps"]), + "nodes": len(arrays["nodes"]), "edges": len(arrays["edge_id"]), + "spikes": len(result["step"]), "requests": int(result["request_count"].sum()), + "applicable_requests": int(result["applicable_count"].sum()), + "rejected_requests": int(result["rejected_count"].sum()), + "due_arrivals": len(result["arrival_step"]), + "queue_trace_enabled": trace_queue, "queue_proxy_validated": validation["pass"], + "source_unchanged": True, "state_file": str(out_dir / "state.npz"), + "coefficient_file": str(out_dir / "coefficients.json"), "complete": True} + _save(out_dir / "summary.json", summary) + return {"arrays": result, "coefficients": coefficients, "summary": summary} + except Exception as error: + _save(out_dir / "error.json", {"type": type(error).__name__, "message": str(error)}) + raise diff --git a/models/male-cns-lif/author-runtime-lab-v1/prepare.py b/models/male-cns-lif/author-runtime-lab-v1/prepare.py new file mode 100644 index 0000000..7029402 --- /dev/null +++ b/models/male-cns-lif/author-runtime-lab-v1/prepare.py @@ -0,0 +1,103 @@ +"""Read-only selection and deterministic fixtures, before observing any dynamics.""" +from datetime import datetime,timezone +import json +import subprocess +import numpy as np +import pandas as pd +import yaml +from context import MODEL,ROOT,EXP,AD,CFG,digest,save,sources,integrity + +M=json.loads((AD/'protocol/preregistered.json').read_text())['config']['model'] + +def put(name,nodes,src,dst,raw,steps,description,edge_id=None,requests=None,external=None,v=None,g=None,metadata=None): + n=len(nodes);src=np.asarray(src,np.int32);dst=np.asarray(dst,np.int32);raw=np.asarray(raw,np.int64) + eid=np.arange(len(src),dtype=np.int64) if edge_id is None else np.asarray(edge_id,np.int64) + order=np.lexsort((eid,src));src,dst,raw,eid=src[order],dst[order],raw[order],eid[order] + assert len(src) and len(src)==len(dst)==len(raw) and np.all((src>=0)&(src=0)&(dst0],minlength=166700);neg=np.bincount(dst[signs[src]<0],minlength=166700) + ranked=np.lexsort((np.arange(166700),-degree));targets=[int(ranked[0]),int(next(i for i in ranked if pos[i]>=64 and neg[i]>=63))] + for name,target in zip(CFG['real_cases'],targets): + incoming=np.flatnonzero((dst==target)&(src!=target));incoming=incoming[np.lexsort((src[incoming],-raw[incoming]))] + if name=='highest_indegree':chosen=incoming[:127] + else: + pp=incoming[signs[src[incoming]]>0][:64];nn=incoming[signs[src[incoming]]<0][:63] + assert len(pp)==64 and len(nn)==63,'Insufficient mixed partners for predeclared graph' + chosen=np.r_[pp,nn] + nodes=np.sort(np.unique(np.r_[src[chosen],target])).astype(np.int32);assert len(nodes)==128 + lookup=np.full(166700,-1,np.int32);lookup[nodes]=np.arange(len(nodes),dtype=np.int32) + ids=np.concatenate([np.arange(ptr[s],ptr[s+1],dtype=np.int64) for s in nodes]);ids=ids[lookup[dst[ids]]>=0] + local_src=lookup[src[ids]];local_dst=lookup[dst[ids]];signed=raw[ids]*signs[src[ids]] + req=np.zeros((500,len(nodes)),np.uint8);stim=np.sort(src[chosen[:16]]) + for tick in (0,25,50,100,150,200):req[tick,lookup[stim]]=1 + put(name,nodes,local_src,local_dst,signed,500,'Deterministically selected real induced graph; canonical edge IDs/counts and frozen signs.',edge_id=ids,requests=req, + metadata=dict(target_neuron_idx=target,target_body_id=int(meta.body_id.iloc[target]),global_in_degree=int(degree[target]),positive_in_edges=int(pos[target]),negative_in_edges=int(neg[target]),stimulated_neuron_idx=stim.tolist())) + meta.iloc[nodes][['neuron_idx','body_id','annotation_type','neurotransmitter']].to_csv(EXP/'cases'/name/'identities.csv',index=False) + pd.DataFrame(dict(edge_id=ids,source_neuron_idx=src[ids],target_neuron_idx=dst[ids],raw_count=raw[ids],source_sign=signs[src[ids]],signed_raw=signed)).to_csv(EXP/'cases'/name/'anatomical-edges.csv',index=False) + ac=ROOT/'experiments/phase4ac-lif-semantics' + for name in CFG['prior_motifs']: + e=pd.read_csv(ac/'motifs'/f'{name}-edges.csv');nodes=np.load(ac/'motifs'/f'{name}-state.npz')['nodes'];look={int(v):i for i,v in enumerate(nodes)} + req=np.zeros((1000,len(nodes)),np.uint8) + if name!='no_input':req[0,look[1381]]=1 + put('motif_'+name,nodes,[look[int(x)] for x in e.source_neuron_idx],[look[int(x)] for x in e.target_neuron_idx],e.raw_count.to_numpy()*signs[e.source_neuron_idx],1000, + 'Same selected4AC/4AD motif,100ms prefix; no new edge or weight.',edge_id=e.edge_id.to_numpy(),requests=req) + +def main(): + assert not (EXP/'protocol').exists() + for d in ('protocol','cases','oracle','gpu','regression','audit','performance'):(EXP/d).mkdir() + can=ROOT/'datasets/male-cns-v1.0/processed/neuron-only' + inputs=[can/'gpu/csr-indptr.int64.npy',can/'gpu/csr-indices.int32.npy',can/'gpu/csr-weights.int64.npy',can/'neuron-index/unified-metadata.parquet',ROOT/'models/male-cns-lif/runtime-v1/phase4c.yaml',AD/'external-resources/model.py',AD/'manifest.json'] + save(EXP/'protocol/preregistered.json',dict(timestamp_utc=datetime.now(timezone.utc).isoformat(),config=CFG,sources=sources(), + inputs=[dict(path=str(p.relative_to(ROOT)),sha256=digest(p)) for p in inputs],before_model_execution=True, + parent_commit=subprocess.check_output(['git','-C',str(ROOT),'rev-parse','HEAD'],text=True).strip())) + save(EXP/'regression/old-integrity-before.json',integrity()) + synthetic();real() + save(EXP/'protocol/case-hashes.json',[dict(path=str(p.relative_to(EXP)),sha256=digest(p)) for p in sorted((EXP/'cases').rglob('*')) if p.is_file()]) + print('PREPARED',len(list((EXP/'cases').iterdir())),'fixed cases; old integrity PASS',flush=True) + +if __name__=='__main__':main() diff --git a/models/male-cns-lif/author-runtime-lab-v1/run_suite.py b/models/male-cns-lif/author-runtime-lab-v1/run_suite.py new file mode 100644 index 0000000..b027dc0 --- /dev/null +++ b/models/male-cns-lif/author-runtime-lab-v1/run_suite.py @@ -0,0 +1,87 @@ +"""Fixed Brian/GPU stress suite, with source-checked immutable inputs.""" +import argparse +import json +import os +from pathlib import Path +import sys +import time +import numpy as np +from context import ROOT,MODEL,EXP,CFG,save,check + +def load(path): + with np.load(path,allow_pickle=False) as f:return {k:f[k].copy() for k in f.files} + +def compare(a,b,case,precision): + checks={k:bool(np.array_equal(a[k],b[k])) for k in ('step','neuron_idx','counts','ref')} + ah=np.asarray(a['history'],np.float64);bh=np.asarray(b['history'],np.float64) + assert ah.shape==bh.shape + delta=np.abs(ah[:,:2]-bh[:,:2]);limit=CFG['max_abs_volt'][precision] + checks['history_ref_exact']=bool(np.array_equal(ah[:,2],bh[:,2])) + checks['finite_states']=bool(np.isfinite(ah).all() and np.isfinite(bh).all()) + checks['state_tolerance']=bool(delta.max()<=limit) + checks['weights_exact']=bool(np.array_equal(a['weights'],b['weights'])) + # Distinguish logical event requests from realised requests after refractory. + for key in ('request_attempted','request_accepted','request_rejected'): + checks[key+'_exact']=bool(key in a and key in b and np.array_equal(a[key],b[key])) + data=load(case/'arrays.npz');targets=data['dst'] + def arrival_sequence(result): + tick=result['arrival_step'];eid=result['arrival_edge_index'];guard=result['arrival_accepted'] + assert tick.shape==eid.shape==guard.shape + # Different targets can interleave; order of writes to one target cannot. + order=np.lexsort((np.arange(len(eid)),targets[eid],tick)) + return np.stack((tick[order],eid[order],guard[order]),axis=1) + aa=arrival_sequence(a);bb=arrival_sequence(b) + checks['arrival_order_and_guard_exact']=bool(np.array_equal(aa,bb)) + first=None + for t in range(len(ah)): + if not np.array_equal(a['neuron_idx'][a['step']==t],b['neuron_idx'][b['step']==t]):first=t;break + bits_equal=a['history'].dtype==b['history'].dtype and np.array_equal(np.ascontiguousarray(a['history']).view(np.uint8),np.ascontiguousarray(b['history']).view(np.uint8)) + return dict(pass_all=all(checks.values()),checks=checks,bitwise_history=bool(bits_equal), + max_abs_volt=float(delta.max()),mean_abs_volt=float(delta.mean()),fixed_limit_volt=limit, + first_event_divergence_step=first,oracle_events=int(len(a['step'])),gpu_events=int(len(b['step'])), + due_edges=int(len(aa)),accepted_edges=int(a['arrival_accepted'].sum()), + attempted_requests=int(a['request_attempted'].sum()),accepted_requests=int(a['request_accepted'].sum())) + +def oracle(): + from oracle_stress import run_case + t0=time.perf_counter();rows=[] + for case in sorted((EXP/'cases').iterdir()): + for precision in CFG['precisions']: + output=EXP/'oracle'/(case.name+'-'+precision) + run_case(case,output,precision) + r=load(output/'state.npz');assert np.isfinite(r['history']).all() + rows.append(dict(case=case.name,precision=precision,events=len(r['step']))) + print(json.dumps(rows[-1]),flush=True) + save(EXP/'regression/oracle-complete.json',dict(cases=rows,wall_seconds=time.perf_counter()-t0)) + +def gpu(): + assert (EXP/'regression/oracle-complete.json').exists(),'No complete oracle suite' + os.environ['CUDA_VISIBLE_DEVICES']=CFG['gpu_uuid'];os.environ['CUDA_HOME']='/usr/local/cuda' + os.environ['PATH']=str(ROOT/'models/male-cns-lif/.venv/bin')+':/usr/local/cuda/bin:'+os.environ['PATH'] + os.environ['MAX_JOBS']='2';os.environ['TORCH_CUDA_ARCH_LIST']='8.9' + sys.path.insert(0,str(ROOT/'models/male-cns-lif/terminal-scope-diagnostic-v1')) + from diagnostic import queues + queues() + from gpu_backend import run_gpu + t0=time.perf_counter();rows=[] + for case in sorted((EXP/'cases').iterdir()): + for precision in CFG['precisions']: + queues();refdir=EXP/'oracle'/(case.name+'-'+precision) + reference=load(refdir/'state.npz');coeff=json.loads((refdir/'coefficients.json').read_text());first=None + for repeat in range(CFG['gpu_repeats']): + out=EXP/'gpu'/(case.name+'-'+precision+f'-r{repeat}') + run_gpu(case,out,precision,coeff,EXP/'extension-build',weights=reference['weights']) + result=load(out/'state.npz');cmp=compare(reference,result,case,precision) + if first is None:first=result + rep={k:bool(np.array_equal(v,result[k])) for k,v in first.items()} + row=dict(case=case.name,precision=precision,repeat=repeat,comparison=cmp,repeat_arrays=rep, + pass_all=cmp['pass_all'] and all(rep.values())) + save(out/'comparison.json',row);rows.append(row) + print(json.dumps(dict(case=case.name,precision=precision,repeat=repeat,pass_all=row['pass_all'], + error_volt=cmp['max_abs_volt'],events=cmp['oracle_events'],bitwise_history=cmp['bitwise_history'])),flush=True) + save(EXP/'regression/gpu-complete.json',dict(pass_all=all(x['pass_all'] for x in rows),trials=rows, + wall_seconds=time.perf_counter()-t0,whole_brain_tested=False,learning_achieved=False)) + +if __name__=='__main__': + p=argparse.ArgumentParser();p.add_argument('mode',choices=['oracle','gpu']);args=p.parse_args() + check();globals()[args.mode]() diff --git a/models/male-cns-lif/author-runtime-lab-v1/verify_frozen.py b/models/male-cns-lif/author-runtime-lab-v1/verify_frozen.py new file mode 100644 index 0000000..69f0d1a --- /dev/null +++ b/models/male-cns-lif/author-runtime-lab-v1/verify_frozen.py @@ -0,0 +1,33 @@ +"""Run old frozen trials into new output only; no author-model equivalence claim.""" +import os +import sys +import time +import numpy as np +import pandas as pd +import yaml +from context import ROOT,EXP,CFG,save,check + +def main(): + check();assert not (EXP/'regression/frozen-five.json').exists() + rtpath=ROOT/'models/male-cns-lif/deterministic-runtime-v2';pc=yaml.safe_load((rtpath/'phase4p.yaml').read_text()) + os.environ['CUDA_VISIBLE_DEVICES']=CFG['gpu_uuid'];os.environ['CUDA_HOME']='/usr/local/cuda' + os.environ['PATH']=str(ROOT/'models/male-cns-lif/.venv/bin')+':/usr/local/cuda/bin:'+os.environ['PATH'] + os.environ['MAX_JOBS']='2';os.environ['TORCH_CUDA_ARCH_LIST']='8.9' + sys.path.insert(0,str(ROOT/'models/male-cns-lif/terminal-scope-diagnostic-v1')) + from diagnostic import queues + queues();sys.path.insert(0,str(ROOT/'models/male-cns-lif'));sys.path.insert(0,str(rtpath)) + import torch,phase4p + assert torch.cuda.mem_get_info()[0]>2*1024**3 + torch.cuda.reset_peak_memory_stats();t0=time.perf_counter();rt=phase4p.CanonicalRuntime(pc,rtpath,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') + ref=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']) + row=dict(trial=spec['name'],exact={k:bool(np.array_equal(v,r[k])) for k,v in ref.items()},wall_seconds=r['metrics']['wall_seconds']) + rows.append(row);print(row,flush=True) + save(EXP/'regression/frozen-five.json',dict(pass_all=all(all(r['exact'].values()) for r in rows),trials=rows, + wall_seconds=time.perf_counter()-t0,peak_allocated_vram=int(torch.cuda.max_memory_allocated()),oracle='old frozen deterministic-v2 only')) + assert all(all(r['exact'].values()) for r in rows) + +if __name__=='__main__':main() diff --git a/registry/phase4ae-author-runtime/cross-precision-description.json b/registry/phase4ae-author-runtime/cross-precision-description.json new file mode 100644 index 0000000..a105e25 --- /dev/null +++ b/registry/phase4ae-author-runtime/cross-precision-description.json @@ -0,0 +1,149 @@ +{ + "cases": [ + { + "case": "fanin_bursts", + "event_equal": true, + "events_float64": 1539, + "events_float32": 1539, + "first_event_divergence_step": null, + "max_vg_abs_volt": 1.538265524056448e-07, + "input_hashes": { + "experiments/phase4ae-author-runtime/oracle/fanin_bursts-float64/state.npz": "48d4cf57a0fd4cd83dfad8497042063022a3a6b2214106080da69deaaaf5fa9e", + "experiments/phase4ae-author-runtime/oracle/fanin_bursts-float32/state.npz": "660c10c905097d76d91bea09c67ca861534196fc720d0e12102bac074a8525f5" + } + }, + { + "case": "highest_indegree", + "event_equal": true, + "events_float64": 101, + "events_float32": 101, + "first_event_divergence_step": null, + "max_vg_abs_volt": 2.132226918638569e-07, + "input_hashes": { + "experiments/phase4ae-author-runtime/oracle/highest_indegree-float64/state.npz": "768d39cdeaa17a8b0fa7a64be5ffbe771e4d00c8db2709c4c5cdb0749f6c3455", + "experiments/phase4ae-author-runtime/oracle/highest_indegree-float32/state.npz": "11de500da330704334d9ce2d128aa2bba32decef851c75bc720a59f91fe534d2" + } + }, + { + "case": "mixed_high_indegree", + "event_equal": true, + "events_float64": 106, + "events_float32": 106, + "first_event_divergence_step": null, + "max_vg_abs_volt": 2.1416214047303983e-07, + "input_hashes": { + "experiments/phase4ae-author-runtime/oracle/mixed_high_indegree-float64/state.npz": "c267e765682525fce86a72d5a86eb921c2d1cef4200172cdc48d1fb41634d727", + "experiments/phase4ae-author-runtime/oracle/mixed_high_indegree-float32/state.npz": "5df4b542b303e747bbbfbdb057da15e522465e54d6617349ee99f7192e1603f9" + } + }, + { + "case": "motif_feedforward", + "event_equal": true, + "events_float64": 3, + "events_float32": 3, + "first_event_divergence_step": null, + "max_vg_abs_volt": 2.0734813362816018e-07, + "input_hashes": { + "experiments/phase4ae-author-runtime/oracle/motif_feedforward-float64/state.npz": "21f5487f461f02c60c8b23be2f7def85c52d54f95fd00dbcd9b5f1d16d933c3a", + "experiments/phase4ae-author-runtime/oracle/motif_feedforward-float32/state.npz": "e24ef4caddd186832c767df704c0073253735a6bbfa4381d76a23614ef7c0f8f" + } + }, + { + "case": "motif_five", + "event_equal": true, + "events_float64": 60, + "events_float32": 60, + "first_event_divergence_step": null, + "max_vg_abs_volt": 1.8507321130484256e-07, + "input_hashes": { + "experiments/phase4ae-author-runtime/oracle/motif_five-float64/state.npz": "cf6ac75da0a75ccdd5ab6ac1b282fae8b8a07128f3e0a3f0106739348f75dfbb", + "experiments/phase4ae-author-runtime/oracle/motif_five-float32/state.npz": "3463e35fa10471d5abfd8090db1967fd5c2046364ef4e6b7974b710eb225fff2" + } + }, + { + "case": "motif_no_input", + "event_equal": true, + "events_float64": 0, + "events_float32": 0, + "first_event_divergence_step": null, + "max_vg_abs_volt": 1.0728836014051168e-09, + "input_hashes": { + "experiments/phase4ae-author-runtime/oracle/motif_no_input-float64/state.npz": "4f8b98d81b6b91aeccdf59788e7cfa6a770fe1ac59753fa8c4777776e559fbe1", + "experiments/phase4ae-author-runtime/oracle/motif_no_input-float32/state.npz": "fbf19ad2fa292ecfcfbf893047ed0ee1dc411fd7825f728b21147349085177ad" + } + }, + { + "case": "motif_pair", + "event_equal": true, + "events_float64": 22, + "events_float32": 22, + "first_event_divergence_step": null, + "max_vg_abs_volt": 3.596376418196767e-08, + "input_hashes": { + "experiments/phase4ae-author-runtime/oracle/motif_pair-float64/state.npz": "236fcb984139a2e376b026fe33e5fb079a1c3a9a4f1090925fbe2643c92fa31b", + "experiments/phase4ae-author-runtime/oracle/motif_pair-float32/state.npz": "016d9e6cd2e38e3ac4bf5dcd4526771f30885a7152b77e703bfa6debbed047f1" + } + }, + { + "case": "motif_trio", + "event_equal": true, + "events_float64": 45, + "events_float32": 45, + "first_event_divergence_step": null, + "max_vg_abs_volt": 3.596376418196767e-08, + "input_hashes": { + "experiments/phase4ae-author-runtime/oracle/motif_trio-float64/state.npz": "bf670c8bc344163408fb96baf2df5d0fab9804f134fdd9011205ff6873d2084a", + "experiments/phase4ae-author-runtime/oracle/motif_trio-float32/state.npz": "ce04a18d25df422285be6ee80d36c949da506ebc885a87d31e109ee3d31f292b" + } + }, + { + "case": "ordered_cancellation", + "event_equal": true, + "events_float64": 32, + "events_float32": 32, + "first_event_divergence_step": null, + "max_vg_abs_volt": 0.00012916631594562123, + "input_hashes": { + "experiments/phase4ae-author-runtime/oracle/ordered_cancellation-float64/state.npz": "1ad4991463a440d466ec28bc32bb35572f84b351716a8150ed6360d90d36942b", + "experiments/phase4ae-author-runtime/oracle/ordered_cancellation-float32/state.npz": "c937b1ec1e1ec63d1f0aedd3ab91b506f745849f3b66d8223d0d831bd9a689b0" + } + }, + { + "case": "release_selfloop", + "event_equal": true, + "events_float64": 8, + "events_float32": 8, + "first_event_divergence_step": null, + "max_vg_abs_volt": 3.4269942050801916e-08, + "input_hashes": { + "experiments/phase4ae-author-runtime/oracle/release_selfloop-float64/state.npz": "2615645c5ae1bea1d9ba279c6639e35209907e4e103db6d10c05ad23dc11919d", + "experiments/phase4ae-author-runtime/oracle/release_selfloop-float32/state.npz": "dd8c3ac01e4d8035d94d0772efbb81948ba427f5ef66caf8d104f4819845a3cc" + } + }, + { + "case": "signed_random", + "event_equal": true, + "events_float64": 400, + "events_float32": 400, + "first_event_divergence_step": null, + "max_vg_abs_volt": 1.4282541487831146e-06, + "input_hashes": { + "experiments/phase4ae-author-runtime/oracle/signed_random-float64/state.npz": "148f6098bb58c952afe07b680a79355091cfb7d6c21e2fc49fc4c902a191cafd", + "experiments/phase4ae-author-runtime/oracle/signed_random-float32/state.npz": "8657a63c2ea9703b8e37b0339eb63c24f31c597cf20cf214bb5e088312489d4a" + } + }, + { + "case": "threshold_rounding", + "event_equal": false, + "events_float64": 4, + "events_float32": 3, + "first_event_divergence_step": 0, + "max_vg_abs_volt": 0.006999998211860661, + "input_hashes": { + "experiments/phase4ae-author-runtime/oracle/threshold_rounding-float64/state.npz": "2b7071d125814ce8855806157f8ff5b778f554076e6ab8f2488ad99fd8b447e0", + "experiments/phase4ae-author-runtime/oracle/threshold_rounding-float32/state.npz": "e225d3b95c5455cfb5f850e8fc3b3c97e99b4bd87bbfce6c2e6f764f32432a44" + } + } + ], + "meaning": "Descriptive only; no changed tolerances, no variant selected by activity. Each GPU arm is validated against its own precision Brian oracle." +} diff --git a/registry/phase4ae-author-runtime/evidence-index.json b/registry/phase4ae-author-runtime/evidence-index.json new file mode 100644 index 0000000..8b86592 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence-index.json @@ -0,0 +1,3770 @@ +[ + { + "source": "experiments/phase4ae-author-runtime/REPORT.md", + "copy": "evidence/REPORT.md", + "sha256": "b868f1af329c95f5c264e42b05f53b13b6a86ef4a8a4ffb728cb8eee1e6f4223", + "bytes": 2195 + }, + { + "source": "experiments/phase4ae-author-runtime/audit/final-status.json", + "copy": "evidence/audit/final-status.json", + "sha256": "ea2305390f21d0aa35de76efae59819cb5548391b6cab57b9d72a3472d017013", + "bytes": 351 + }, + { + "source": "experiments/phase4ae-author-runtime/cases/fanin_bursts/spec.json", + "copy": "evidence/cases/fanin_bursts/spec.json", + "sha256": "90850d6968a7832e415d0966b57e216a65f5ba8f63e488e497148b6525806d79", + "bytes": 561 + }, + { + "source": "experiments/phase4ae-author-runtime/cases/highest_indegree/anatomical-edges.csv", + "copy": "evidence/cases/highest_indegree/anatomical-edges.csv", + "sha256": "aec331ee87f0da905d55b4dbb61a7e72fae734246ae6fbf462d7f6348dcdae1b", + "bytes": 7936 + }, + { + "source": "experiments/phase4ae-author-runtime/cases/highest_indegree/identities.csv", + "copy": "evidence/cases/highest_indegree/identities.csv", + "sha256": "5a837548ac8d45d495765d012f4495f4f68b2c9b0eda3eabd759869fc793fe77", + "bytes": 3895 + }, + { + "source": "experiments/phase4ae-author-runtime/cases/highest_indegree/spec.json", + "copy": "evidence/cases/highest_indegree/spec.json", + "sha256": "eab2c18f120fd3e9f067f489cee0a4c07477607facf3094083d3e3fa60bfd1ef", + "bytes": 956 + }, + { + "source": "experiments/phase4ae-author-runtime/cases/mixed_high_indegree/anatomical-edges.csv", + "copy": "evidence/cases/mixed_high_indegree/anatomical-edges.csv", + "sha256": "4bb7f2b5344916035a87bffec9b26570ef21842010fcf78ff1a71230496c4757", + "bytes": 6625 + }, + { + "source": "experiments/phase4ae-author-runtime/cases/mixed_high_indegree/identities.csv", + "copy": "evidence/cases/mixed_high_indegree/identities.csv", + "sha256": "ad8f92fab6e2c38ed2b369b7f03c5b75d3c26433ad43bde6e2fc76f8058dd009", + "bytes": 3634 + }, + { + "source": "experiments/phase4ae-author-runtime/cases/mixed_high_indegree/spec.json", + "copy": "evidence/cases/mixed_high_indegree/spec.json", + "sha256": "11f07dd0a3e62b6ee66373022539a68daad766dce26fa759654f0201599f6703", + "bytes": 959 + }, + { + "source": "experiments/phase4ae-author-runtime/cases/motif_feedforward/spec.json", + "copy": "evidence/cases/motif_feedforward/spec.json", + "sha256": "1bb9ef28864e46336581d23fc15eaf80a329ee4d1a439abd0fc18c52f87a2b77", + "bytes": 540 + }, + { + "source": "experiments/phase4ae-author-runtime/cases/motif_five/spec.json", + "copy": "evidence/cases/motif_five/spec.json", + "sha256": "f78ba9423ed1dfb686cd79a0a003cda0bf9e7603d37e8d318118e08766ece7b3", + "bytes": 533 + }, + { + "source": "experiments/phase4ae-author-runtime/cases/motif_no_input/spec.json", + "copy": "evidence/cases/motif_no_input/spec.json", + "sha256": "02adfcd0717aa2d98eb571107136eae7186166ce1c7d7eb87df23bedb452fbd9", + "bytes": 537 + }, + { + "source": "experiments/phase4ae-author-runtime/cases/motif_pair/spec.json", + "copy": "evidence/cases/motif_pair/spec.json", + "sha256": "faee4cdcdc93293b4b5e15d852a6a97b76767ce6aa7c534b12c6f204264daa7a", + "bytes": 533 + }, + { + "source": "experiments/phase4ae-author-runtime/cases/motif_trio/spec.json", + "copy": "evidence/cases/motif_trio/spec.json", + "sha256": "da4b6cea0b8a33ca15e552425b55ce699d74ddf81660b02eeb30d5edcc4494cd", + "bytes": 533 + }, + { + "source": "experiments/phase4ae-author-runtime/cases/ordered_cancellation/spec.json", + "copy": "evidence/cases/ordered_cancellation/spec.json", + "sha256": "1866003021cc39ad50858fe0d9f56d74e8dd16bd574eef15c0625b604cd987b2", + "bytes": 569 + }, + { + "source": "experiments/phase4ae-author-runtime/cases/release_selfloop/spec.json", + "copy": "evidence/cases/release_selfloop/spec.json", + "sha256": "f63a2d3a4e99220a42944461a3223c459e3a1e7c02d22dc5e30cd129dd9452d1", + "bytes": 538 + }, + { + "source": "experiments/phase4ae-author-runtime/cases/signed_random/spec.json", + "copy": "evidence/cases/signed_random/spec.json", + "sha256": "7c6af1bf5fd8f68c84fe000ec6b4977d05f6db17f4b9338d8ad49376036cbf32", + "bytes": 571 + }, + { + "source": "experiments/phase4ae-author-runtime/cases/threshold_rounding/spec.json", + "copy": "evidence/cases/threshold_rounding/spec.json", + "sha256": "8a000b9052226e0d4db020cc1dbfc839ac2aa98f01cb9361de2209dbe8706495", + "bytes": 577 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/fanin_bursts-float32-r0/comparison.json", + "copy": "evidence/gpu/fanin_bursts-float32-r0/comparison.json", + "sha256": "12310d970a3122d98925e90a6ee852f93b89ac7c65740bce766fbdab104ae95e", + "bytes": 1216 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/fanin_bursts-float32-r0/metrics.json", + "copy": "evidence/gpu/fanin_bursts-float32-r0/metrics.json", + "sha256": "947e74fc7788cd190e804764757beb5f5ac56be1b2b55a4d415c171e33a71e36", + "bytes": 2153 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/fanin_bursts-float32-r1/comparison.json", + "copy": "evidence/gpu/fanin_bursts-float32-r1/comparison.json", + "sha256": "e5b955928b916af14e464a65207e1a3ce06e74b5b7a92fd7969d0a3f9a7fd18a", + "bytes": 1216 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/fanin_bursts-float32-r1/metrics.json", + "copy": "evidence/gpu/fanin_bursts-float32-r1/metrics.json", + "sha256": "452d8917e29a03cbd1d217c397dd9e8e085dc33c2ee27517cde6dd7d0c6694ed", + "bytes": 2155 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/fanin_bursts-float32-r2/comparison.json", + "copy": "evidence/gpu/fanin_bursts-float32-r2/comparison.json", + "sha256": "045405c14e0929e4875ad8be6cd617db29f2367f53b1db03cb80604c081b0857", + "bytes": 1216 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/fanin_bursts-float32-r2/metrics.json", + "copy": "evidence/gpu/fanin_bursts-float32-r2/metrics.json", + "sha256": "329b1be64ff13f3ef0fe4849ec9ef6bc5d4cf3cfe8bc731d82c8d12e07403f3f", + "bytes": 2153 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/fanin_bursts-float64-r0/comparison.json", + "copy": "evidence/gpu/fanin_bursts-float64-r0/comparison.json", + "sha256": "eeca2cf7cee7c8a2bb672cc2f9cb8ffe2fee5d7cebef5a7ac2168ce0d0c7bf55", + "bytes": 1216 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/fanin_bursts-float64-r0/metrics.json", + "copy": "evidence/gpu/fanin_bursts-float64-r0/metrics.json", + "sha256": "0427ff2e3ee46fd3a40a71bfb36af193fc4c30a17d209e288be4f4e21b8d13ef", + "bytes": 2121 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/fanin_bursts-float64-r1/comparison.json", + "copy": "evidence/gpu/fanin_bursts-float64-r1/comparison.json", + "sha256": "21795525db57f8890dda1d50b7c9dd8988f951127488c2a6da544501c7ed43c4", + "bytes": 1216 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/fanin_bursts-float64-r1/metrics.json", + "copy": "evidence/gpu/fanin_bursts-float64-r1/metrics.json", + "sha256": "45a9bcbe167e2ef3436060ffc2ea08b11670adc744a3e60db75ac0264de6db36", + "bytes": 2127 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/fanin_bursts-float64-r2/comparison.json", + "copy": "evidence/gpu/fanin_bursts-float64-r2/comparison.json", + "sha256": "486c36e6e182d820201fd18a1b38b7eedbbd8aa4295a92b3145265dad8f0a170", + "bytes": 1216 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/fanin_bursts-float64-r2/metrics.json", + "copy": "evidence/gpu/fanin_bursts-float64-r2/metrics.json", + "sha256": "b28d29cc60d80ddbd76c0bd309141e2eb44fcf00a0dd877ca92a4968530e8254", + "bytes": 2126 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/highest_indegree-float32-r0/comparison.json", + "copy": "evidence/gpu/highest_indegree-float32-r0/comparison.json", + "sha256": "1f2def177229390bcde1b9a2c94819da9d68d4336f8dfc73b1be545e44ba9278", + "bytes": 1212 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/highest_indegree-float32-r0/metrics.json", + "copy": "evidence/gpu/highest_indegree-float32-r0/metrics.json", + "sha256": "afff8582869eb807dc43a62d1ec84fd9c6300822afaa839f138cefface1b51ae", + "bytes": 2144 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/highest_indegree-float32-r1/comparison.json", + "copy": "evidence/gpu/highest_indegree-float32-r1/comparison.json", + "sha256": "246c89aa41573e512506057ff3f3a827cc0747453515e084e4aff4cd9013d221", + "bytes": 1212 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/highest_indegree-float32-r1/metrics.json", + "copy": "evidence/gpu/highest_indegree-float32-r1/metrics.json", + "sha256": "d5e3527c34e46cc7f46327fdfde3e894e8f10c07b69c9970a327b19a4d096c31", + "bytes": 2146 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/highest_indegree-float32-r2/comparison.json", + "copy": "evidence/gpu/highest_indegree-float32-r2/comparison.json", + "sha256": "8ab5759412dda7e8cdba5692ed62e667873e647155ac86ba31e5f539388fd43c", + "bytes": 1212 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/highest_indegree-float32-r2/metrics.json", + "copy": "evidence/gpu/highest_indegree-float32-r2/metrics.json", + "sha256": "c106130ad03b70bca3f31d0074d19ed2f50fe760b57359fec00f682050ff759a", + "bytes": 2144 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/highest_indegree-float64-r0/comparison.json", + "copy": "evidence/gpu/highest_indegree-float64-r0/comparison.json", + "sha256": "9bf9fb86fef1ebc866de0e8152f34067cb68e3434d3b232bf02c5207f57ff885", + "bytes": 1212 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/highest_indegree-float64-r0/metrics.json", + "copy": "evidence/gpu/highest_indegree-float64-r0/metrics.json", + "sha256": "a8b920d40fa3366874b08048c6b29dbfa1d1526e462cd3a444c40809e7ba37f2", + "bytes": 2117 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/highest_indegree-float64-r1/comparison.json", + "copy": "evidence/gpu/highest_indegree-float64-r1/comparison.json", + "sha256": "462d36b713564bd81ffe28a3707ce208ab1c413437e1fffc869c5c1054728e2f", + "bytes": 1212 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/highest_indegree-float64-r1/metrics.json", + "copy": "evidence/gpu/highest_indegree-float64-r1/metrics.json", + "sha256": "e655f6d65f52678ecd4e5acce372a34c5ea8a52a222cb36496e85dcdb54f5e73", + "bytes": 2117 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/highest_indegree-float64-r2/comparison.json", + "copy": "evidence/gpu/highest_indegree-float64-r2/comparison.json", + "sha256": "e3fec806eb2608554720b0bd9667f1aee75c0ad269a613e36104ea4c4d95f82e", + "bytes": 1212 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/highest_indegree-float64-r2/metrics.json", + "copy": "evidence/gpu/highest_indegree-float64-r2/metrics.json", + "sha256": "e1474af65ed69ce0707ca5c4f6fadf97e3606da14dad54664995646d57791012", + "bytes": 2117 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/mixed_high_indegree-float32-r0/comparison.json", + "copy": "evidence/gpu/mixed_high_indegree-float32-r0/comparison.json", + "sha256": "044aac9e7e4d3090c12050da10a3d9d229bf4b0ae1df0cd0535fe942af809d39", + "bytes": 1215 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/mixed_high_indegree-float32-r0/metrics.json", + "copy": "evidence/gpu/mixed_high_indegree-float32-r0/metrics.json", + "sha256": "f813da02775ee2a2afb9a746f296a73f37c9b3f075dafcca2bd3c0419eca633d", + "bytes": 2145 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/mixed_high_indegree-float32-r1/comparison.json", + "copy": "evidence/gpu/mixed_high_indegree-float32-r1/comparison.json", + "sha256": "55f6b0bdb442a9acd960e192afac270ea94c2ca3e98025a6e3079062f7100f5a", + "bytes": 1215 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/mixed_high_indegree-float32-r1/metrics.json", + "copy": "evidence/gpu/mixed_high_indegree-float32-r1/metrics.json", + "sha256": "42a0a24721e7b82b2f4917772e31ef7b44b9e18c2425acf5cac70dbc17e94a76", + "bytes": 2145 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/mixed_high_indegree-float32-r2/comparison.json", + "copy": "evidence/gpu/mixed_high_indegree-float32-r2/comparison.json", + "sha256": "62059fef31d576e96845b35ee83b6c28fab57377b63818fda89dd8ee151c5ebc", + "bytes": 1215 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/mixed_high_indegree-float32-r2/metrics.json", + "copy": "evidence/gpu/mixed_high_indegree-float32-r2/metrics.json", + "sha256": "132437c4c769a5b576b10c846355029af268c337ebfe19e1ae2b2a5ed37cc0c2", + "bytes": 2146 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/mixed_high_indegree-float64-r0/comparison.json", + "copy": "evidence/gpu/mixed_high_indegree-float64-r0/comparison.json", + "sha256": "7a5187b10bdfa9e2af4db7d6597d8aa02faadf4901a233ced2ed0be2450f124d", + "bytes": 1215 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/mixed_high_indegree-float64-r0/metrics.json", + "copy": "evidence/gpu/mixed_high_indegree-float64-r0/metrics.json", + "sha256": "bcc2f3f5918c514523b959f691cde82c3c9f3000c45d17191cc1d77c85edc005", + "bytes": 2118 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/mixed_high_indegree-float64-r1/comparison.json", + "copy": "evidence/gpu/mixed_high_indegree-float64-r1/comparison.json", + "sha256": "73cc0c59195c1a2c3d4bc16da431aff42a885286679ca0cd809bc182c8e8d792", + "bytes": 1215 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/mixed_high_indegree-float64-r1/metrics.json", + "copy": "evidence/gpu/mixed_high_indegree-float64-r1/metrics.json", + "sha256": "f98a32f498450333889a7e486c4d5277b2746f2d206f61ec0b146c6124a0cdd9", + "bytes": 2118 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/mixed_high_indegree-float64-r2/comparison.json", + "copy": "evidence/gpu/mixed_high_indegree-float64-r2/comparison.json", + "sha256": "d5d6ad513373ccc7d48a795f51c7705427c1a92124f8cd75e173575aed40d5dc", + "bytes": 1215 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/mixed_high_indegree-float64-r2/metrics.json", + "copy": "evidence/gpu/mixed_high_indegree-float64-r2/metrics.json", + "sha256": "7f893e0fe56dcaa98d3748056c103a7eee7d10139ef8f970dc0f108d356bfeb2", + "bytes": 2117 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/motif_feedforward-float32-r0/comparison.json", + "copy": "evidence/gpu/motif_feedforward-float32-r0/comparison.json", + "sha256": "f722721c2ed148c0afa53ef49f5914a828b01b877972eb6b56134f7839fb1731", + "bytes": 1203 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/motif_feedforward-float32-r0/metrics.json", + "copy": "evidence/gpu/motif_feedforward-float32-r0/metrics.json", + "sha256": "31f5a7526d2d67c8d984c1527a274663c2c365da746132b210bccbf65ea94623", + "bytes": 2133 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/motif_feedforward-float32-r1/comparison.json", + "copy": "evidence/gpu/motif_feedforward-float32-r1/comparison.json", + "sha256": "450453289e7fb360414c8938478e1780bc935d8d408cc5c4b8bb280b35ec343f", + "bytes": 1203 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/motif_feedforward-float32-r1/metrics.json", + "copy": "evidence/gpu/motif_feedforward-float32-r1/metrics.json", + "sha256": "189d25ed00771d2c8d38e72ad63563324f5840c244fda0e7331b380a2fb072bf", + "bytes": 2132 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/motif_feedforward-float32-r2/comparison.json", + "copy": "evidence/gpu/motif_feedforward-float32-r2/comparison.json", + "sha256": "65471b4a94fde3168e213673053c36031c466c2ff072ffb2152486319fa01acd", + "bytes": 1203 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/motif_feedforward-float32-r2/metrics.json", + "copy": "evidence/gpu/motif_feedforward-float32-r2/metrics.json", + "sha256": "bd413aff41252ec4ee5ac7d4da2bc6afbd3a6841e42bccdbe7fc94db0ddaa12a", + "bytes": 2131 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/motif_feedforward-float64-r0/comparison.json", + "copy": "evidence/gpu/motif_feedforward-float64-r0/comparison.json", + "sha256": "81cab1ca080eeabb69b85affba0a9f14b0106d6eeee58ab7db612d989000a1f0", + "bytes": 1203 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/motif_feedforward-float64-r0/metrics.json", + "copy": "evidence/gpu/motif_feedforward-float64-r0/metrics.json", + "sha256": "3e8cde3092183a88c0b060af8db47b0e0f50231e7e36f7aa10c78e5317b7fd36", + "bytes": 2103 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/motif_feedforward-float64-r1/comparison.json", + "copy": "evidence/gpu/motif_feedforward-float64-r1/comparison.json", + "sha256": "3c0e6b05be5d9bb32fd4f38a2a32524dc8ce3193fe24a9b55fbffc63d37c1573", + "bytes": 1203 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/motif_feedforward-float64-r1/metrics.json", + "copy": "evidence/gpu/motif_feedforward-float64-r1/metrics.json", + "sha256": "ff0e89efa83ecc0f81ad09841d2d44de327ce6ede08615b563a7d81d9dc35795", + "bytes": 2104 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/motif_feedforward-float64-r2/comparison.json", + "copy": "evidence/gpu/motif_feedforward-float64-r2/comparison.json", + "sha256": "171023bfd3fe1fb454affa1f84064422b2b318aa84a28126ce6c2cfc8f99edbb", + "bytes": 1203 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/motif_feedforward-float64-r2/metrics.json", + "copy": "evidence/gpu/motif_feedforward-float64-r2/metrics.json", + "sha256": "a04dbd55eba875b163d0e63f8600bf7d12e54c4fd71df93c620982179da70e4c", + "bytes": 2105 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/motif_five-float32-r0/comparison.json", + "copy": "evidence/gpu/motif_five-float32-r0/comparison.json", + "sha256": "8e7bf7c087c98d80068f16f8b18cba08e82be69c7c0fe7bd2175fbb1a3e1e127", + "bytes": 1202 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/motif_five-float32-r0/metrics.json", + "copy": "evidence/gpu/motif_five-float32-r0/metrics.json", + "sha256": "1cde729f2b204cb2a0dd2aee5144d68df18d35b2964126cfedef6f276d7e735b", + "bytes": 2139 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/motif_five-float32-r1/comparison.json", + "copy": "evidence/gpu/motif_five-float32-r1/comparison.json", + "sha256": "2ce1a054f63f1b70e9b517d4804bbce40846a2758a6f225edf8f2d92323097ed", + "bytes": 1202 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/motif_five-float32-r1/metrics.json", + "copy": "evidence/gpu/motif_five-float32-r1/metrics.json", + "sha256": "c77ef2df1ebf63edc5bf05f2ff5dd0a25973b68a445e515cca47f67dc586e0ab", + "bytes": 2139 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/motif_five-float32-r2/comparison.json", + "copy": "evidence/gpu/motif_five-float32-r2/comparison.json", + "sha256": "a9e790b00eef82de3d39dbc219bd5b893cc751e199dc4d6792488b4098cca0ca", + "bytes": 1202 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/motif_five-float32-r2/metrics.json", + "copy": "evidence/gpu/motif_five-float32-r2/metrics.json", + "sha256": "be2a565f4b3100f4250815a71274723e491495abc561a6c4e477ac1e49946ed9", + "bytes": 2138 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/motif_five-float64-r0/comparison.json", + "copy": "evidence/gpu/motif_five-float64-r0/comparison.json", + "sha256": "676f5af243f754f5e747f8d66e6308fe2246c119b250432897a6276351a576e8", + "bytes": 1202 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/motif_five-float64-r0/metrics.json", + "copy": "evidence/gpu/motif_five-float64-r0/metrics.json", + "sha256": "b524fea4b29c5575610cbfbf282f7cd0f5e3400ce7b2feae54990eb42236db91", + "bytes": 2110 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/motif_five-float64-r1/comparison.json", + "copy": "evidence/gpu/motif_five-float64-r1/comparison.json", + "sha256": "5c5fdee60d3131fd6454ec0af496d3f34630314c8b0dc6ba2d7cf6c24b20979d", + "bytes": 1202 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/motif_five-float64-r1/metrics.json", + "copy": "evidence/gpu/motif_five-float64-r1/metrics.json", + "sha256": "91117647bac42fc9d3f234a3380641863fd6b4a51eab24221f2bb8fba852162a", + "bytes": 2109 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/motif_five-float64-r2/comparison.json", + "copy": "evidence/gpu/motif_five-float64-r2/comparison.json", + "sha256": "a412787c057a232b2d1274cadfa010b5029836a0a6599c0539186c9671f08691", + "bytes": 1202 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/motif_five-float64-r2/metrics.json", + "copy": "evidence/gpu/motif_five-float64-r2/metrics.json", + "sha256": "6901ec19e9c344c62d9248d707391e5e4fdeec68ab59669049b8aadde35e81be", + "bytes": 2111 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/motif_no_input-float32-r0/comparison.json", + "copy": "evidence/gpu/motif_no_input-float32-r0/comparison.json", + "sha256": "069cc644ac74aba235f5de81f8d425b6730fd02111e5fd916dc4a20e5d50f547", + "bytes": 1200 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/motif_no_input-float32-r0/metrics.json", + "copy": "evidence/gpu/motif_no_input-float32-r0/metrics.json", + "sha256": "e76b9edb18ad6665b7eb2e737ac910fdb4e841b8fa5fb474c1263715898c0f24", + "bytes": 2134 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/motif_no_input-float32-r1/comparison.json", + "copy": "evidence/gpu/motif_no_input-float32-r1/comparison.json", + "sha256": "0cc735ae6f634ea4427e04f6591b808f057ca44ab33170f5d8e1e7a988fc9e8b", + "bytes": 1200 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/motif_no_input-float32-r1/metrics.json", + "copy": "evidence/gpu/motif_no_input-float32-r1/metrics.json", + "sha256": "4d01c6d9616275aa788a6a485f2278b07e46c114d0c1d7bbf1399f71fc8fe59f", + "bytes": 2134 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/motif_no_input-float32-r2/comparison.json", + "copy": "evidence/gpu/motif_no_input-float32-r2/comparison.json", + "sha256": "6696d8a5168715a985464d7893d0261813bacb3eff85b4a3edadd9b781fe5d84", + "bytes": 1200 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/motif_no_input-float32-r2/metrics.json", + "copy": "evidence/gpu/motif_no_input-float32-r2/metrics.json", + "sha256": "4cc9848437df51ac61fc9c9734070f0c09ee87c6fadc48009dd6d8d9fc0610e9", + "bytes": 2133 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/motif_no_input-float64-r0/comparison.json", + "copy": "evidence/gpu/motif_no_input-float64-r0/comparison.json", + "sha256": "b9f97cc5134b6506c8ca1bbfcc0e1b5542c7c26051053446128fd29e67eca866", + "bytes": 1200 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/motif_no_input-float64-r0/metrics.json", + "copy": "evidence/gpu/motif_no_input-float64-r0/metrics.json", + "sha256": "e064174f4fc484ea2b6efa3246dd85cb2c8b3113cf9bd199ac25387ecda23e16", + "bytes": 2105 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/motif_no_input-float64-r1/comparison.json", + "copy": "evidence/gpu/motif_no_input-float64-r1/comparison.json", + "sha256": "60f034535db6d3d897805cb82c33a702e4d87eeededae8e8af95d7cbcd600ee5", + "bytes": 1200 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/motif_no_input-float64-r1/metrics.json", + "copy": "evidence/gpu/motif_no_input-float64-r1/metrics.json", + "sha256": "7c16b3e776a8ebc161114a76899097c7fe41c94618bc6b21aa1c06e5dcdc6ec8", + "bytes": 2107 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/motif_no_input-float64-r2/comparison.json", + "copy": "evidence/gpu/motif_no_input-float64-r2/comparison.json", + "sha256": "aea6fd5b29d1d2b301fad4dcd45baca49d2e68a1b8e236f44d41847565eee984", + "bytes": 1200 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/motif_no_input-float64-r2/metrics.json", + "copy": "evidence/gpu/motif_no_input-float64-r2/metrics.json", + "sha256": "993b0d94f5f35149c25c304f19d453707e21335901fd60affdc2f8e54950f8a5", + "bytes": 2104 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/motif_pair-float32-r0/comparison.json", + "copy": "evidence/gpu/motif_pair-float32-r0/comparison.json", + "sha256": "e19afca3976bf288cff894efc55e7bd8c12f671544031c4c4ea85c0e29c7a095", + "bytes": 1200 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/motif_pair-float32-r0/metrics.json", + "copy": "evidence/gpu/motif_pair-float32-r0/metrics.json", + "sha256": "f4059a737e317bd31a4fc5444a088c5d16fb8e6ab3dff1a50c97f36229c9737b", + "bytes": 2135 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/motif_pair-float32-r1/comparison.json", + "copy": "evidence/gpu/motif_pair-float32-r1/comparison.json", + "sha256": "79dd0b8acd03a41c9218986b6389bf4361dd61efc219a128310532318532dac5", + "bytes": 1200 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/motif_pair-float32-r1/metrics.json", + "copy": "evidence/gpu/motif_pair-float32-r1/metrics.json", + "sha256": "58383925af6d7de1043600e27a5be51da709ce00caccaf824883a115715fb671", + "bytes": 2135 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/motif_pair-float32-r2/comparison.json", + "copy": "evidence/gpu/motif_pair-float32-r2/comparison.json", + "sha256": "5bd76b86940c87422c7a45c123943503fb796fc32746e6da9a167378286359fa", + "bytes": 1200 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/motif_pair-float32-r2/metrics.json", + "copy": "evidence/gpu/motif_pair-float32-r2/metrics.json", + "sha256": "68c7c486c42eea81dcd1f6af2236c422154edfaa21761efec4ccd3a12cc3cd30", + "bytes": 2136 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/motif_pair-float64-r0/comparison.json", + "copy": "evidence/gpu/motif_pair-float64-r0/comparison.json", + "sha256": "9d8c54acd5ae46ebef18e28d0284f9dc5dccfc5548690bb40b463348f7e434da", + "bytes": 1200 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/motif_pair-float64-r0/metrics.json", + "copy": "evidence/gpu/motif_pair-float64-r0/metrics.json", + "sha256": "4dda6a7c1efb337de1d4045001c34c8c753be1a9f6a2e8b7dd554d2bcaea26c1", + "bytes": 2106 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/motif_pair-float64-r1/comparison.json", + "copy": "evidence/gpu/motif_pair-float64-r1/comparison.json", + "sha256": "7447ab06a506aa0ca2a69c64fedd79973c8249ec120c67e0e882f7f8773b77d8", + "bytes": 1200 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/motif_pair-float64-r1/metrics.json", + "copy": "evidence/gpu/motif_pair-float64-r1/metrics.json", + "sha256": "3605b358e707431fb11428ff58ded32c0a2a1b580a8a3b30960a361c3092e1eb", + "bytes": 2105 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/motif_pair-float64-r2/comparison.json", + "copy": "evidence/gpu/motif_pair-float64-r2/comparison.json", + "sha256": "ed5ed460d0f71c371f053e0bef2e1434db9733461715075b45135ab51821b896", + "bytes": 1200 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/motif_pair-float64-r2/metrics.json", + "copy": "evidence/gpu/motif_pair-float64-r2/metrics.json", + "sha256": "1bd7c6284304465170973724b3892c3c5fdf7710a4b7bdc1022cd95148385abd", + "bytes": 2105 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/motif_trio-float32-r0/comparison.json", + "copy": "evidence/gpu/motif_trio-float32-r0/comparison.json", + "sha256": "06070c6028ab04a0ff1062021a30aa9916c3d57be951373cd9c5cf85b435e83a", + "bytes": 1200 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/motif_trio-float32-r0/metrics.json", + "copy": "evidence/gpu/motif_trio-float32-r0/metrics.json", + "sha256": "fdd59ec33881edc9d8e8b7523cd01167da730aa4b4a095cabaf520ba488c623d", + "bytes": 2135 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/motif_trio-float32-r1/comparison.json", + "copy": "evidence/gpu/motif_trio-float32-r1/comparison.json", + "sha256": "2ab4f0357307ec6137eb80bf0e3194d67227fb7bc256b68076effe8e25868db7", + "bytes": 1200 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/motif_trio-float32-r1/metrics.json", + "copy": "evidence/gpu/motif_trio-float32-r1/metrics.json", + "sha256": "6fb4a69f6963b2541254f0051e9df99a3f32472b9d90cfc775fbe857c50a16f6", + "bytes": 2136 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/motif_trio-float32-r2/comparison.json", + "copy": "evidence/gpu/motif_trio-float32-r2/comparison.json", + "sha256": "c433bb2c1f27208ab7a92577fe5421a0dce9422ad8009251e006d147e94068db", + "bytes": 1200 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/motif_trio-float32-r2/metrics.json", + "copy": "evidence/gpu/motif_trio-float32-r2/metrics.json", + "sha256": "3e8ccdd69164d8efb32d6c57dca3f9654eed7d7a2251331b1bd3623ef820964b", + "bytes": 2135 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/motif_trio-float64-r0/comparison.json", + "copy": "evidence/gpu/motif_trio-float64-r0/comparison.json", + "sha256": "67dfe0b913635f72363d85a720a93ed95c90f5b554319676ef5d86e366d6d454", + "bytes": 1200 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/motif_trio-float64-r0/metrics.json", + "copy": "evidence/gpu/motif_trio-float64-r0/metrics.json", + "sha256": "9c7a3e46de47a43265fbc6a0fc3b7fff2dcf638edd1584c78a4af57f9d58ce31", + "bytes": 2108 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/motif_trio-float64-r1/comparison.json", + "copy": "evidence/gpu/motif_trio-float64-r1/comparison.json", + "sha256": "4925f8501521d159702d6b701d815499c9369bb148003afd7a5d3987f913f218", + "bytes": 1200 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/motif_trio-float64-r1/metrics.json", + "copy": "evidence/gpu/motif_trio-float64-r1/metrics.json", + "sha256": "31fbb95cceb1da812335ca8b9dd7717f65a930359d83bc7a863bd9f25d660220", + "bytes": 2108 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/motif_trio-float64-r2/comparison.json", + "copy": "evidence/gpu/motif_trio-float64-r2/comparison.json", + "sha256": "75734d45ab6bc68268ab2bfa8d1c978e74289f1733f12c3e093e25b0e62c2412", + "bytes": 1200 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/motif_trio-float64-r2/metrics.json", + "copy": "evidence/gpu/motif_trio-float64-r2/metrics.json", + "sha256": "6b4701ce099dcdb7847a106437b6a227cc1c7f48e7b943bfd1112b388381e4d8", + "bytes": 2109 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/ordered_cancellation-float32-r0/comparison.json", + "copy": "evidence/gpu/ordered_cancellation-float32-r0/comparison.json", + "sha256": "97e70b9338f2bd351f477de44423eaf23dfc096f3763267d6b36ac82f879fd1f", + "bytes": 1212 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/ordered_cancellation-float32-r0/metrics.json", + "copy": "evidence/gpu/ordered_cancellation-float32-r0/metrics.json", + "sha256": "e1c51742ddab9b387935ce91750317ba78ce46384420263fcf7398551c062f6e", + "bytes": 2141 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/ordered_cancellation-float32-r1/comparison.json", + "copy": "evidence/gpu/ordered_cancellation-float32-r1/comparison.json", + "sha256": "e08c95274102540fe4201f6d708388853fe87f39a0c1cc54035cccc1f819fc79", + "bytes": 1212 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/ordered_cancellation-float32-r1/metrics.json", + "copy": "evidence/gpu/ordered_cancellation-float32-r1/metrics.json", + "sha256": "d4e1ea55b64bd29dd691c3b61ec51c53d2407190cc3260a6288d86ecc6c5ee0a", + "bytes": 2141 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/ordered_cancellation-float32-r2/comparison.json", + "copy": "evidence/gpu/ordered_cancellation-float32-r2/comparison.json", + "sha256": "863173342d260b41f003ea3cf231460390ce62266b4c87bad99940811355f946", + "bytes": 1212 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/ordered_cancellation-float32-r2/metrics.json", + "copy": "evidence/gpu/ordered_cancellation-float32-r2/metrics.json", + "sha256": "3f7e854fe53979703c4641a4be9b22ad91d063885aac8f18bc4883bcfa4aaa6e", + "bytes": 2141 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/ordered_cancellation-float64-r0/comparison.json", + "copy": "evidence/gpu/ordered_cancellation-float64-r0/comparison.json", + "sha256": "ce34e9cb3dd179e507d258f6c1dada410890dc609510d2baa1cba2034d7819b7", + "bytes": 1212 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/ordered_cancellation-float64-r0/metrics.json", + "copy": "evidence/gpu/ordered_cancellation-float64-r0/metrics.json", + "sha256": "c783ddcb8f98072d3aeb3d5008cefa52a7df093c1e21c01168ec0d94ad494848", + "bytes": 2111 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/ordered_cancellation-float64-r1/comparison.json", + "copy": "evidence/gpu/ordered_cancellation-float64-r1/comparison.json", + "sha256": "f4198ff2aa762a34bf811def8a89f521deea5d348fb6d83c689f6e2e9f7503b6", + "bytes": 1212 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/ordered_cancellation-float64-r1/metrics.json", + "copy": "evidence/gpu/ordered_cancellation-float64-r1/metrics.json", + "sha256": "fe5ab94117a5e9db792fc4b1cd2dcb832d70d3f3f3ca99ed78dae7b05fd4b783", + "bytes": 2112 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/ordered_cancellation-float64-r2/comparison.json", + "copy": "evidence/gpu/ordered_cancellation-float64-r2/comparison.json", + "sha256": "62cfbc2eb26389d75968fa6d5e65dfc59293484a947c94a49656e03192953142", + "bytes": 1212 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/ordered_cancellation-float64-r2/metrics.json", + "copy": "evidence/gpu/ordered_cancellation-float64-r2/metrics.json", + "sha256": "170294aa0b4eb36d5be2e9bf1e2c8fac999a751263a56e351c07066acfa2e800", + "bytes": 2112 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/release_selfloop-float32-r0/comparison.json", + "copy": "evidence/gpu/release_selfloop-float32-r0/comparison.json", + "sha256": "9096f1e0b7bd2f0636f982c7e9d336b335630de1475988507f42570ee5ec8fbc", + "bytes": 1203 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/release_selfloop-float32-r0/metrics.json", + "copy": "evidence/gpu/release_selfloop-float32-r0/metrics.json", + "sha256": "943c2eb1ebb59d266ed472d5ed765f594a7d726d0b0abd36fda0120617d02246", + "bytes": 2135 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/release_selfloop-float32-r1/comparison.json", + "copy": "evidence/gpu/release_selfloop-float32-r1/comparison.json", + "sha256": "93d69eba07971c0bdd620b2bf036ffae73c6e2cdba0297ac9c6fa62c58a3f70c", + "bytes": 1203 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/release_selfloop-float32-r1/metrics.json", + "copy": "evidence/gpu/release_selfloop-float32-r1/metrics.json", + "sha256": "a7873bb08820fc2bc1700259cefea2e144d150dee2d63bf9612a066d0a87c7c5", + "bytes": 2134 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/release_selfloop-float32-r2/comparison.json", + "copy": "evidence/gpu/release_selfloop-float32-r2/comparison.json", + "sha256": "4dc94196990f8acaa09c656a216d72d2c5da008262da634221466faaed129914", + "bytes": 1203 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/release_selfloop-float32-r2/metrics.json", + "copy": "evidence/gpu/release_selfloop-float32-r2/metrics.json", + "sha256": "762363b9400578440025f92904222bcb5f8d43f9449618c55755d89bf2e60bf2", + "bytes": 2134 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/release_selfloop-float64-r0/comparison.json", + "copy": "evidence/gpu/release_selfloop-float64-r0/comparison.json", + "sha256": "0b1d71d2572f4aee6f0860cb7c942007e86385d4b89d86c8bed4781b9a18f693", + "bytes": 1203 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/release_selfloop-float64-r0/metrics.json", + "copy": "evidence/gpu/release_selfloop-float64-r0/metrics.json", + "sha256": "b81cc105366bd6cb500d4a30447250eef46d6c4f4ecfba56476a12a2604cee4a", + "bytes": 2105 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/release_selfloop-float64-r1/comparison.json", + "copy": "evidence/gpu/release_selfloop-float64-r1/comparison.json", + "sha256": "31c9f680ff76a56c66aa1c9e931dc5cd20a98466982ba198af898d9a5303b41e", + "bytes": 1203 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/release_selfloop-float64-r1/metrics.json", + "copy": "evidence/gpu/release_selfloop-float64-r1/metrics.json", + "sha256": "3799bdeaef2d1243500774ca38b33e188b9a684e887fb742583e1ea3df19a0b1", + "bytes": 2106 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/release_selfloop-float64-r2/comparison.json", + "copy": "evidence/gpu/release_selfloop-float64-r2/comparison.json", + "sha256": "5b8436161d014ac5e8182363dabe071d2fad9c3941773fa850b45dfe6ccafcb6", + "bytes": 1203 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/release_selfloop-float64-r2/metrics.json", + "copy": "evidence/gpu/release_selfloop-float64-r2/metrics.json", + "sha256": "786ff8d1e2203fe101596ad802bf3f3aa2fbb75a93c973647d224864ff3d68e9", + "bytes": 2106 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/signed_random-float32-r0/comparison.json", + "copy": "evidence/gpu/signed_random-float32-r0/comparison.json", + "sha256": "a1ace6d4c542a2bf257f09424dd564caf5f13f876833baf0d213bc301f564740", + "bytes": 1211 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/signed_random-float32-r0/metrics.json", + "copy": "evidence/gpu/signed_random-float32-r0/metrics.json", + "sha256": "ac2c60aed61a50d169d0f30974c7d609cf05c39604ad10c36807129f05044296", + "bytes": 2147 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/signed_random-float32-r1/comparison.json", + "copy": "evidence/gpu/signed_random-float32-r1/comparison.json", + "sha256": "293390081bb82b98456e07efb2be5ac2ea75ca61e583c47df3e2893df624eae5", + "bytes": 1211 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/signed_random-float32-r1/metrics.json", + "copy": "evidence/gpu/signed_random-float32-r1/metrics.json", + "sha256": "42b06a42e3821a6b042b775bd9120a5cd5cd9ae49fc90f233e9f15972390bbc7", + "bytes": 2145 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/signed_random-float32-r2/comparison.json", + "copy": "evidence/gpu/signed_random-float32-r2/comparison.json", + "sha256": "ab194323647dc23c0f79b310146c4ed63f01634147b41c286337ba4c995747b1", + "bytes": 1211 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/signed_random-float32-r2/metrics.json", + "copy": "evidence/gpu/signed_random-float32-r2/metrics.json", + "sha256": "4f177d07d8f8510414aba5d75e6de7d9b61a856bae5f2c84ae1484f3275d7b06", + "bytes": 2148 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/signed_random-float64-r0/comparison.json", + "copy": "evidence/gpu/signed_random-float64-r0/comparison.json", + "sha256": "dcbc03b01b1bab61256546c12bacdabb1067d0cf862198333b56158331d50285", + "bytes": 1211 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/signed_random-float64-r0/metrics.json", + "copy": "evidence/gpu/signed_random-float64-r0/metrics.json", + "sha256": "2067336a1093ecb37540c92b4d52ba5988a3631b72cc0a41fafbc5f3347ac4be", + "bytes": 2121 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/signed_random-float64-r1/comparison.json", + "copy": "evidence/gpu/signed_random-float64-r1/comparison.json", + "sha256": "57b6a2e47242160623c0fd85467e0c49987f8c94bb46484047effbebc676c872", + "bytes": 1211 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/signed_random-float64-r1/metrics.json", + "copy": "evidence/gpu/signed_random-float64-r1/metrics.json", + "sha256": "b22191dccd7f29e70fc5af69a4ef1cbee82054fa47e15155b13871d52a60687f", + "bytes": 2121 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/signed_random-float64-r2/comparison.json", + "copy": "evidence/gpu/signed_random-float64-r2/comparison.json", + "sha256": "e3a1de9283170ef928d9f9178f8620f5ae251819c8d28b15e567d54d506210c0", + "bytes": 1211 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/signed_random-float64-r2/metrics.json", + "copy": "evidence/gpu/signed_random-float64-r2/metrics.json", + "sha256": "a0d5d7816d48e15f19c8343f0c2e7cf9205334c3255baa70c625546dbbcd7ecf", + "bytes": 2120 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/threshold_rounding-float32-r0/comparison.json", + "copy": "evidence/gpu/threshold_rounding-float32-r0/comparison.json", + "sha256": "8739225c90857ab6c2b9e8e486c224e12ec65466e10129f71ce288fab6266c7d", + "bytes": 1204 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/threshold_rounding-float32-r0/metrics.json", + "copy": "evidence/gpu/threshold_rounding-float32-r0/metrics.json", + "sha256": "ae27ea25d3c1e39716bc1ec6c81897efc528398ce45fa39e0e49bdaecac3ca2b", + "bytes": 2135 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/threshold_rounding-float32-r1/comparison.json", + "copy": "evidence/gpu/threshold_rounding-float32-r1/comparison.json", + "sha256": "a10bb1a007ef61c4cb33ff5e0f640ce9a396d7b32b3c80ca6de48bff4f0491ed", + "bytes": 1204 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/threshold_rounding-float32-r1/metrics.json", + "copy": "evidence/gpu/threshold_rounding-float32-r1/metrics.json", + "sha256": "58858c943191b48a6defe7dc9e5171997f06a4cb70b7244d511cf287ba12bf88", + "bytes": 2135 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/threshold_rounding-float32-r2/comparison.json", + "copy": "evidence/gpu/threshold_rounding-float32-r2/comparison.json", + "sha256": "96bdc33ff14f50247dd4a4224ce0bb3d734c80a437147c0baed69588ea3b48f2", + "bytes": 1204 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/threshold_rounding-float32-r2/metrics.json", + "copy": "evidence/gpu/threshold_rounding-float32-r2/metrics.json", + "sha256": "86a77aec3230eea856d5b81f12ad7737807ffbaa9e23e78553208dd3a4f2cb93", + "bytes": 2134 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/threshold_rounding-float64-r0/comparison.json", + "copy": "evidence/gpu/threshold_rounding-float64-r0/comparison.json", + "sha256": "61fede1ddcd6e65c014a6310189521df46f437e711ac7659cf7b1bda068edf41", + "bytes": 1204 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/threshold_rounding-float64-r0/metrics.json", + "copy": "evidence/gpu/threshold_rounding-float64-r0/metrics.json", + "sha256": "ebee8abadabeae92dca41ba2afe81d68d919bf3652320c02d241d3c75834ff4e", + "bytes": 2107 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/threshold_rounding-float64-r1/comparison.json", + "copy": "evidence/gpu/threshold_rounding-float64-r1/comparison.json", + "sha256": "04edfac5ddd74456202aa89df3d3062fd07abe42445b17a038921667715c6a6b", + "bytes": 1204 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/threshold_rounding-float64-r1/metrics.json", + "copy": "evidence/gpu/threshold_rounding-float64-r1/metrics.json", + "sha256": "89324a2e788074ea518da354f93396643ecf16ff16c1ce4fddffa86b4c3323af", + "bytes": 2106 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/threshold_rounding-float64-r2/comparison.json", + "copy": "evidence/gpu/threshold_rounding-float64-r2/comparison.json", + "sha256": "c7c9b6572f20a1478827ce792c139bc49461dc113bd3cacc6be9f508b8b14201", + "bytes": 1204 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu/threshold_rounding-float64-r2/metrics.json", + "copy": "evidence/gpu/threshold_rounding-float64-r2/metrics.json", + "sha256": "c129a9cc8dd60ac96152d5651edc7731851a7812ad48b89441139fdcb87e3aeb", + "bytes": 2103 + }, + { + "source": "experiments/phase4ae-author-runtime/gpu-reference/extension.json", + "copy": "evidence/gpu-reference/extension.json", + "sha256": "fa7fb04108f2688fed47132c0af29c283727a999161c11e219ed010c15d6147c", + "bytes": 442 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/fanin_bursts-float32/case.json", + "copy": "evidence/oracle/fanin_bursts-float32/case.json", + "sha256": "859d9f55df89add3344e082081644fd81520756118e9106ecec181d3ba0268f2", + "bytes": 1265 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/fanin_bursts-float32/coefficients.json", + "copy": "evidence/oracle/fanin_bursts-float32/coefficients.json", + "sha256": "934af1eecfdadd2a5cca6313b602b9bbba115e87793a68cc36f7352bc38fca65", + "bytes": 2329 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/fanin_bursts-float32/environment.json", + "copy": "evidence/oracle/fanin_bursts-float32/environment.json", + "sha256": "8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6", + "bytes": 352 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/fanin_bursts-float32/instrumented/coefficients.json", + "copy": "evidence/oracle/fanin_bursts-float32/instrumented/coefficients.json", + "sha256": "934af1eecfdadd2a5cca6313b602b9bbba115e87793a68cc36f7352bc38fca65", + "bytes": 2329 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/fanin_bursts-float32/instrumented/compiled-code.json", + "copy": "evidence/oracle/fanin_bursts-float32/instrumented/compiled-code.json", + "sha256": "dfbcf815d17465e4c83a54320687e77c3035c5064f6a81a11bffc5ce35ec0dd1", + "bytes": 14949 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/fanin_bursts-float32/instrumented/completeness.csv", + "copy": "evidence/oracle/fanin_bursts-float32/instrumented/completeness.csv", + "sha256": "d8163907696aec1bf853ecccbe301c50efb4abd5b1c76b9a3dfa34f0e9e36c20", + "bytes": 2125 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/fanin_bursts-float32/instrumented/generated-code.json", + "copy": "evidence/oracle/fanin_bursts-float32/instrumented/generated-code.json", + "sha256": "20705f7f0f81917eb9630b91808b5121c36345e87a7bc9fc026aaf59dcb6cf41", + "bytes": 14965 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/fanin_bursts-float32/instrumented/input-audit.json", + "copy": "evidence/oracle/fanin_bursts-float32/instrumented/input-audit.json", + "sha256": "33a8b070a595bbd95b4d1db7db92b73fa3f1b2e07a2065485f2114b9b73e4f56", + "bytes": 1236 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/fanin_bursts-float32/instrumented/queue-audit.json", + "copy": "evidence/oracle/fanin_bursts-float32/instrumented/queue-audit.json", + "sha256": "65d8941a3f1ffaa814d17fb334abe65d9ceb851dd3f35e6861bad6aacfe764c8", + "bytes": 462 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/fanin_bursts-float32/instrumented/schedule.json", + "copy": "evidence/oracle/fanin_bursts-float32/instrumented/schedule.json", + "sha256": "8d5492b7968694e913d3321b10d5779137045d4689fe50ec50b1ef7637d8fc04", + "bytes": 1984 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/fanin_bursts-float32/proxy-validation.json", + "copy": "evidence/oracle/fanin_bursts-float32/proxy-validation.json", + "sha256": "87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09", + "bytes": 774 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/fanin_bursts-float32/summary.json", + "copy": "evidence/oracle/fanin_bursts-float32/summary.json", + "sha256": "16fddc439b2ab0090f17f66231b5e2f293f5e9d1d29bcb608434bca256a81cb7", + "bytes": 586 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/fanin_bursts-float32/unwrapped-audit/coefficients.json", + "copy": "evidence/oracle/fanin_bursts-float32/unwrapped-audit/coefficients.json", + "sha256": "2caa1990718d199f371dbf5e685543bc61df67e08a5ad9a2c8bb1e2834a153a4", + "bytes": 2329 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/fanin_bursts-float32/unwrapped-audit/compiled-code.json", + "copy": "evidence/oracle/fanin_bursts-float32/unwrapped-audit/compiled-code.json", + "sha256": "82868f03604ec2a12efea07718960e3bfb1c8152950c3b6bc4fd8e1b1d46cf8d", + "bytes": 14785 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/fanin_bursts-float32/unwrapped-audit/completeness.csv", + "copy": "evidence/oracle/fanin_bursts-float32/unwrapped-audit/completeness.csv", + "sha256": "d8163907696aec1bf853ecccbe301c50efb4abd5b1c76b9a3dfa34f0e9e36c20", + "bytes": 2125 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/fanin_bursts-float32/unwrapped-audit/generated-code.json", + "copy": "evidence/oracle/fanin_bursts-float32/unwrapped-audit/generated-code.json", + "sha256": "d0a06d99f840cee691987410486bf9537202d3b57177bbd1a9ae8602232b89a4", + "bytes": 14801 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/fanin_bursts-float32/unwrapped-audit/input-audit.json", + "copy": "evidence/oracle/fanin_bursts-float32/unwrapped-audit/input-audit.json", + "sha256": "aa47b175208838c2cc1f99a3d4b7317c4f5e3158901c11a86b957aa64a23ac5e", + "bytes": 1237 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/fanin_bursts-float32/unwrapped-audit/queue-audit.json", + "copy": "evidence/oracle/fanin_bursts-float32/unwrapped-audit/queue-audit.json", + "sha256": "33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7", + "bytes": 371 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/fanin_bursts-float32/unwrapped-audit/schedule.json", + "copy": "evidence/oracle/fanin_bursts-float32/unwrapped-audit/schedule.json", + "sha256": "42679bfcc102a0ec20fafe7fdf9cc82b02a0b8809931a49502ac6efd669fc9cd", + "bytes": 1807 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/fanin_bursts-float64/case.json", + "copy": "evidence/oracle/fanin_bursts-float64/case.json", + "sha256": "c5403a077e0a8ab4836f49de38fec39080b73b4571ec55d2440995b5aae48218", + "bytes": 1265 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/fanin_bursts-float64/coefficients.json", + "copy": "evidence/oracle/fanin_bursts-float64/coefficients.json", + "sha256": "bde79d95ef0097b827d5faf4d5658eafc009d8e9fcef1fddd645c953823e3f64", + "bytes": 2329 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/fanin_bursts-float64/environment.json", + "copy": "evidence/oracle/fanin_bursts-float64/environment.json", + "sha256": "8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6", + "bytes": 352 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/fanin_bursts-float64/instrumented/coefficients.json", + "copy": "evidence/oracle/fanin_bursts-float64/instrumented/coefficients.json", + "sha256": "bde79d95ef0097b827d5faf4d5658eafc009d8e9fcef1fddd645c953823e3f64", + "bytes": 2329 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/fanin_bursts-float64/instrumented/compiled-code.json", + "copy": "evidence/oracle/fanin_bursts-float64/instrumented/compiled-code.json", + "sha256": "dfbcf815d17465e4c83a54320687e77c3035c5064f6a81a11bffc5ce35ec0dd1", + "bytes": 14949 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/fanin_bursts-float64/instrumented/completeness.csv", + "copy": "evidence/oracle/fanin_bursts-float64/instrumented/completeness.csv", + "sha256": "d8163907696aec1bf853ecccbe301c50efb4abd5b1c76b9a3dfa34f0e9e36c20", + "bytes": 2125 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/fanin_bursts-float64/instrumented/generated-code.json", + "copy": "evidence/oracle/fanin_bursts-float64/instrumented/generated-code.json", + "sha256": "c2767fee958084c4c7b6ebd99e8863ac01cdf8da2c315e77124480853ba4aa3e", + "bytes": 14965 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/fanin_bursts-float64/instrumented/input-audit.json", + "copy": "evidence/oracle/fanin_bursts-float64/instrumented/input-audit.json", + "sha256": "81ae40f8b9d83c115b2cbfcdbd1f11f0e00856dea3f0c7b8aab81f7079449cec", + "bytes": 1236 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/fanin_bursts-float64/instrumented/queue-audit.json", + "copy": "evidence/oracle/fanin_bursts-float64/instrumented/queue-audit.json", + "sha256": "7aa923702ed6527afc381ed6c13c94faea41dbf81f75fd9b596265eb3c31588a", + "bytes": 462 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/fanin_bursts-float64/instrumented/schedule.json", + "copy": "evidence/oracle/fanin_bursts-float64/instrumented/schedule.json", + "sha256": "8d5492b7968694e913d3321b10d5779137045d4689fe50ec50b1ef7637d8fc04", + "bytes": 1984 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/fanin_bursts-float64/proxy-validation.json", + "copy": "evidence/oracle/fanin_bursts-float64/proxy-validation.json", + "sha256": "87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09", + "bytes": 774 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/fanin_bursts-float64/summary.json", + "copy": "evidence/oracle/fanin_bursts-float64/summary.json", + "sha256": "d8fc44ae9ed135ef63ae84b5901282c987bfb6daa7a1d912402a940f74a2c179", + "bytes": 586 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/fanin_bursts-float64/unwrapped-audit/coefficients.json", + "copy": "evidence/oracle/fanin_bursts-float64/unwrapped-audit/coefficients.json", + "sha256": "934af1eecfdadd2a5cca6313b602b9bbba115e87793a68cc36f7352bc38fca65", + "bytes": 2329 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/fanin_bursts-float64/unwrapped-audit/compiled-code.json", + "copy": "evidence/oracle/fanin_bursts-float64/unwrapped-audit/compiled-code.json", + "sha256": "82868f03604ec2a12efea07718960e3bfb1c8152950c3b6bc4fd8e1b1d46cf8d", + "bytes": 14785 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/fanin_bursts-float64/unwrapped-audit/completeness.csv", + "copy": "evidence/oracle/fanin_bursts-float64/unwrapped-audit/completeness.csv", + "sha256": "d8163907696aec1bf853ecccbe301c50efb4abd5b1c76b9a3dfa34f0e9e36c20", + "bytes": 2125 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/fanin_bursts-float64/unwrapped-audit/generated-code.json", + "copy": "evidence/oracle/fanin_bursts-float64/unwrapped-audit/generated-code.json", + "sha256": "f131e05fd1393703981f20a4efb5330eb1ec59a6d35688e5a1f2cdc7805e2d74", + "bytes": 14801 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/fanin_bursts-float64/unwrapped-audit/input-audit.json", + "copy": "evidence/oracle/fanin_bursts-float64/unwrapped-audit/input-audit.json", + "sha256": "32eb33dcf7559fd63fc25806236b5e5328ab6ebb4fd7602b0cd4786bbde28822", + "bytes": 1237 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/fanin_bursts-float64/unwrapped-audit/queue-audit.json", + "copy": "evidence/oracle/fanin_bursts-float64/unwrapped-audit/queue-audit.json", + "sha256": "33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7", + "bytes": 371 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/fanin_bursts-float64/unwrapped-audit/schedule.json", + "copy": "evidence/oracle/fanin_bursts-float64/unwrapped-audit/schedule.json", + "sha256": "42679bfcc102a0ec20fafe7fdf9cc82b02a0b8809931a49502ac6efd669fc9cd", + "bytes": 1807 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/highest_indegree-float32/case.json", + "copy": "evidence/oracle/highest_indegree-float32/case.json", + "sha256": "69211934e3e3f935bc3425652d6c38eeb6513353a88383973a7182078dd26abc", + "bytes": 1708 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/highest_indegree-float32/coefficients.json", + "copy": "evidence/oracle/highest_indegree-float32/coefficients.json", + "sha256": "75bd398fd03ade662c9ca5fd3be0f0e745fd0e8deb87354bd3c0c116386a9f3a", + "bytes": 2329 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/highest_indegree-float32/environment.json", + "copy": "evidence/oracle/highest_indegree-float32/environment.json", + "sha256": "8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6", + "bytes": 352 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/highest_indegree-float32/instrumented/coefficients.json", + "copy": "evidence/oracle/highest_indegree-float32/instrumented/coefficients.json", + "sha256": "75bd398fd03ade662c9ca5fd3be0f0e745fd0e8deb87354bd3c0c116386a9f3a", + "bytes": 2329 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/highest_indegree-float32/instrumented/compiled-code.json", + "copy": "evidence/oracle/highest_indegree-float32/instrumented/compiled-code.json", + "sha256": "d37bbac320791543bdc13106f71c8aab50c345ca93aeee06d49ce26131e5e198", + "bytes": 11202 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/highest_indegree-float32/instrumented/completeness.csv", + "copy": "evidence/oracle/highest_indegree-float32/instrumented/completeness.csv", + "sha256": "e90a4d12741fbd0bd0b5fdcf447c2664f7dfcdba7930f4e9e7f05811f0b530f4", + "bytes": 1196 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/highest_indegree-float32/instrumented/generated-code.json", + "copy": "evidence/oracle/highest_indegree-float32/instrumented/generated-code.json", + "sha256": "d75ed5f1158d321ceadcdad048ba8a5e65a38d62bfa99f04d50c25bfca6b98c9", + "bytes": 11214 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/highest_indegree-float32/instrumented/input-audit.json", + "copy": "evidence/oracle/highest_indegree-float32/instrumented/input-audit.json", + "sha256": "d60cc4f72357f4669296c0e49c7f9ae387a044fd2d5faf53868566775c919359", + "bytes": 1236 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/highest_indegree-float32/instrumented/queue-audit.json", + "copy": "evidence/oracle/highest_indegree-float32/instrumented/queue-audit.json", + "sha256": "fe89d26cc141038c4741f890ac07043d24dfc0bc9101a05c2bddbd1d0cd5411e", + "bytes": 460 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/highest_indegree-float32/instrumented/schedule.json", + "copy": "evidence/oracle/highest_indegree-float32/instrumented/schedule.json", + "sha256": "0db2d5f73709934bf7a91db2908a8dc3301614d09490769bf369aad96ee4f0fb", + "bytes": 1574 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/highest_indegree-float32/proxy-validation.json", + "copy": "evidence/oracle/highest_indegree-float32/proxy-validation.json", + "sha256": "87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09", + "bytes": 774 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/highest_indegree-float32/summary.json", + "copy": "evidence/oracle/highest_indegree-float32/summary.json", + "sha256": "d5b91ade99a1407bfa464c75af655c36fb8329ba252967de13ed4829560a788d", + "bytes": 590 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/highest_indegree-float32/unwrapped-audit/coefficients.json", + "copy": "evidence/oracle/highest_indegree-float32/unwrapped-audit/coefficients.json", + "sha256": "7cfc3cd553fcac4fe52bfa455c5f440a8e98a1a621a135500e9a4b16551f6297", + "bytes": 2329 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/highest_indegree-float32/unwrapped-audit/compiled-code.json", + "copy": "evidence/oracle/highest_indegree-float32/unwrapped-audit/compiled-code.json", + "sha256": "9ef07e82240727c9761386ecdd054475050156677e9b0a3a6bc37b845c1f602c", + "bytes": 11038 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/highest_indegree-float32/unwrapped-audit/completeness.csv", + "copy": "evidence/oracle/highest_indegree-float32/unwrapped-audit/completeness.csv", + "sha256": "e90a4d12741fbd0bd0b5fdcf447c2664f7dfcdba7930f4e9e7f05811f0b530f4", + "bytes": 1196 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/highest_indegree-float32/unwrapped-audit/generated-code.json", + "copy": "evidence/oracle/highest_indegree-float32/unwrapped-audit/generated-code.json", + "sha256": "1d622ac2f0e046e2edde7dfb62b3fb7b2ce247c3324410782300eeabb1db4253", + "bytes": 11050 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/highest_indegree-float32/unwrapped-audit/input-audit.json", + "copy": "evidence/oracle/highest_indegree-float32/unwrapped-audit/input-audit.json", + "sha256": "38747cbcc998615df238c4b2497b88b85bc706e4e95ecde3ef0ed5029a104a39", + "bytes": 1237 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/highest_indegree-float32/unwrapped-audit/queue-audit.json", + "copy": "evidence/oracle/highest_indegree-float32/unwrapped-audit/queue-audit.json", + "sha256": "33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7", + "bytes": 371 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/highest_indegree-float32/unwrapped-audit/schedule.json", + "copy": "evidence/oracle/highest_indegree-float32/unwrapped-audit/schedule.json", + "sha256": "af9f8f7b182f3c780b23e1448888728ad89be2bbaf7ebe5631d6bff7c7ae77db", + "bytes": 1411 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/highest_indegree-float64/case.json", + "copy": "evidence/oracle/highest_indegree-float64/case.json", + "sha256": "f838e4bdc1ed3b3641c4da1414bf0d83f788c7f91a5dc18caef9851685a8ca5e", + "bytes": 1708 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/highest_indegree-float64/coefficients.json", + "copy": "evidence/oracle/highest_indegree-float64/coefficients.json", + "sha256": "2caa1990718d199f371dbf5e685543bc61df67e08a5ad9a2c8bb1e2834a153a4", + "bytes": 2329 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/highest_indegree-float64/environment.json", + "copy": "evidence/oracle/highest_indegree-float64/environment.json", + "sha256": "8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6", + "bytes": 352 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/highest_indegree-float64/instrumented/coefficients.json", + "copy": "evidence/oracle/highest_indegree-float64/instrumented/coefficients.json", + "sha256": "2caa1990718d199f371dbf5e685543bc61df67e08a5ad9a2c8bb1e2834a153a4", + "bytes": 2329 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/highest_indegree-float64/instrumented/compiled-code.json", + "copy": "evidence/oracle/highest_indegree-float64/instrumented/compiled-code.json", + "sha256": "d37bbac320791543bdc13106f71c8aab50c345ca93aeee06d49ce26131e5e198", + "bytes": 11202 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/highest_indegree-float64/instrumented/completeness.csv", + "copy": "evidence/oracle/highest_indegree-float64/instrumented/completeness.csv", + "sha256": "e90a4d12741fbd0bd0b5fdcf447c2664f7dfcdba7930f4e9e7f05811f0b530f4", + "bytes": 1196 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/highest_indegree-float64/instrumented/generated-code.json", + "copy": "evidence/oracle/highest_indegree-float64/instrumented/generated-code.json", + "sha256": "4d9691fc82adf6450724f20815681730f7103910537d43c0255fc617cc9d3ef1", + "bytes": 11214 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/highest_indegree-float64/instrumented/input-audit.json", + "copy": "evidence/oracle/highest_indegree-float64/instrumented/input-audit.json", + "sha256": "ee66710153714e771bc38056901694ecf0eeb56c302fa2ef83f8ba43ca4ef432", + "bytes": 1236 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/highest_indegree-float64/instrumented/queue-audit.json", + "copy": "evidence/oracle/highest_indegree-float64/instrumented/queue-audit.json", + "sha256": "05e668a0b1691bc44d4a2a363a5511afe4d8c930b70e7c24642316eb74226b97", + "bytes": 460 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/highest_indegree-float64/instrumented/schedule.json", + "copy": "evidence/oracle/highest_indegree-float64/instrumented/schedule.json", + "sha256": "0db2d5f73709934bf7a91db2908a8dc3301614d09490769bf369aad96ee4f0fb", + "bytes": 1574 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/highest_indegree-float64/proxy-validation.json", + "copy": "evidence/oracle/highest_indegree-float64/proxy-validation.json", + "sha256": "87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09", + "bytes": 774 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/highest_indegree-float64/summary.json", + "copy": "evidence/oracle/highest_indegree-float64/summary.json", + "sha256": "42ce5d10de1b489f5bd17201b7123fe2361f63f0d82ef9cac3c7250461f47b57", + "bytes": 590 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/highest_indegree-float64/unwrapped-audit/coefficients.json", + "copy": "evidence/oracle/highest_indegree-float64/unwrapped-audit/coefficients.json", + "sha256": "75bd398fd03ade662c9ca5fd3be0f0e745fd0e8deb87354bd3c0c116386a9f3a", + "bytes": 2329 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/highest_indegree-float64/unwrapped-audit/compiled-code.json", + "copy": "evidence/oracle/highest_indegree-float64/unwrapped-audit/compiled-code.json", + "sha256": "9ef07e82240727c9761386ecdd054475050156677e9b0a3a6bc37b845c1f602c", + "bytes": 11038 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/highest_indegree-float64/unwrapped-audit/completeness.csv", + "copy": "evidence/oracle/highest_indegree-float64/unwrapped-audit/completeness.csv", + "sha256": "e90a4d12741fbd0bd0b5fdcf447c2664f7dfcdba7930f4e9e7f05811f0b530f4", + "bytes": 1196 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/highest_indegree-float64/unwrapped-audit/generated-code.json", + "copy": "evidence/oracle/highest_indegree-float64/unwrapped-audit/generated-code.json", + "sha256": "1cc7dd07015c0edd32145475c9d07b106b43b029636a1b33ba9df39a079c26a3", + "bytes": 11050 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/highest_indegree-float64/unwrapped-audit/input-audit.json", + "copy": "evidence/oracle/highest_indegree-float64/unwrapped-audit/input-audit.json", + "sha256": "f051b4f6988c9f27e955d416e38fb077d8172e80605e0c306cfdc6d9a4006791", + "bytes": 1237 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/highest_indegree-float64/unwrapped-audit/queue-audit.json", + "copy": "evidence/oracle/highest_indegree-float64/unwrapped-audit/queue-audit.json", + "sha256": "33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7", + "bytes": 371 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/highest_indegree-float64/unwrapped-audit/schedule.json", + "copy": "evidence/oracle/highest_indegree-float64/unwrapped-audit/schedule.json", + "sha256": "af9f8f7b182f3c780b23e1448888728ad89be2bbaf7ebe5631d6bff7c7ae77db", + "bytes": 1411 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/mixed_high_indegree-float32/case.json", + "copy": "evidence/oracle/mixed_high_indegree-float32/case.json", + "sha256": "ff8f69144e361d8e27616e8755a01cace95850383bc337025639f24abd7b31c5", + "bytes": 1711 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/mixed_high_indegree-float32/coefficients.json", + "copy": "evidence/oracle/mixed_high_indegree-float32/coefficients.json", + "sha256": "74615669642e49f242e93e6a9c42d22c21438cbcbc0143d6ddca294465e543da", + "bytes": 2329 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/mixed_high_indegree-float32/environment.json", + "copy": "evidence/oracle/mixed_high_indegree-float32/environment.json", + "sha256": "8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6", + "bytes": 352 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/mixed_high_indegree-float32/instrumented/coefficients.json", + "copy": "evidence/oracle/mixed_high_indegree-float32/instrumented/coefficients.json", + "sha256": "74615669642e49f242e93e6a9c42d22c21438cbcbc0143d6ddca294465e543da", + "bytes": 2329 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/mixed_high_indegree-float32/instrumented/compiled-code.json", + "copy": "evidence/oracle/mixed_high_indegree-float32/instrumented/compiled-code.json", + "sha256": "d37bbac320791543bdc13106f71c8aab50c345ca93aeee06d49ce26131e5e198", + "bytes": 11202 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/mixed_high_indegree-float32/instrumented/completeness.csv", + "copy": "evidence/oracle/mixed_high_indegree-float32/instrumented/completeness.csv", + "sha256": "1f01bd89fa27a1fc11336336d420c1100171017febe074713369fcf51db27363", + "bytes": 1188 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/mixed_high_indegree-float32/instrumented/generated-code.json", + "copy": "evidence/oracle/mixed_high_indegree-float32/instrumented/generated-code.json", + "sha256": "200ebe53ec57bdf2edf72a520a4a32468d99dc813b1a3720cc72bb3c973dec5a", + "bytes": 11214 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/mixed_high_indegree-float32/instrumented/input-audit.json", + "copy": "evidence/oracle/mixed_high_indegree-float32/instrumented/input-audit.json", + "sha256": "45d8d642b41dd122cb262e54654784511353488320cce35add03becabc059912", + "bytes": 1236 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/mixed_high_indegree-float32/instrumented/queue-audit.json", + "copy": "evidence/oracle/mixed_high_indegree-float32/instrumented/queue-audit.json", + "sha256": "e6b73b067ea95c9bd09c21dd9c83da230b7923edabc41a9a7c0ff00d8c1e5ca4", + "bytes": 460 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/mixed_high_indegree-float32/instrumented/schedule.json", + "copy": "evidence/oracle/mixed_high_indegree-float32/instrumented/schedule.json", + "sha256": "0db2d5f73709934bf7a91db2908a8dc3301614d09490769bf369aad96ee4f0fb", + "bytes": 1574 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/mixed_high_indegree-float32/proxy-validation.json", + "copy": "evidence/oracle/mixed_high_indegree-float32/proxy-validation.json", + "sha256": "87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09", + "bytes": 774 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/mixed_high_indegree-float32/summary.json", + "copy": "evidence/oracle/mixed_high_indegree-float32/summary.json", + "sha256": "2984b25862d977a9158164931e10f987fc6eb9364e2ab714df1c3c3fe45af415", + "bytes": 599 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/mixed_high_indegree-float32/unwrapped-audit/coefficients.json", + "copy": "evidence/oracle/mixed_high_indegree-float32/unwrapped-audit/coefficients.json", + "sha256": "ec5e4c7e313291d044a1447c276582cbb16ade5cc052675bd83c1016a924942e", + "bytes": 2329 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/mixed_high_indegree-float32/unwrapped-audit/compiled-code.json", + "copy": "evidence/oracle/mixed_high_indegree-float32/unwrapped-audit/compiled-code.json", + "sha256": "9ef07e82240727c9761386ecdd054475050156677e9b0a3a6bc37b845c1f602c", + "bytes": 11038 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/mixed_high_indegree-float32/unwrapped-audit/completeness.csv", + "copy": "evidence/oracle/mixed_high_indegree-float32/unwrapped-audit/completeness.csv", + "sha256": "1f01bd89fa27a1fc11336336d420c1100171017febe074713369fcf51db27363", + "bytes": 1188 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/mixed_high_indegree-float32/unwrapped-audit/generated-code.json", + "copy": "evidence/oracle/mixed_high_indegree-float32/unwrapped-audit/generated-code.json", + "sha256": "0711324a1fd18d75f5b243deba0dae9dd992aa54ecd12d5727b91331c1d7faf0", + "bytes": 11050 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/mixed_high_indegree-float32/unwrapped-audit/input-audit.json", + "copy": "evidence/oracle/mixed_high_indegree-float32/unwrapped-audit/input-audit.json", + "sha256": "ce31b2c18c0c434c9d09ad8428945de9db815145d7cd97ac6cf64c8319830ddd", + "bytes": 1237 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/mixed_high_indegree-float32/unwrapped-audit/queue-audit.json", + "copy": "evidence/oracle/mixed_high_indegree-float32/unwrapped-audit/queue-audit.json", + "sha256": "33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7", + "bytes": 371 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/mixed_high_indegree-float32/unwrapped-audit/schedule.json", + "copy": "evidence/oracle/mixed_high_indegree-float32/unwrapped-audit/schedule.json", + "sha256": "af9f8f7b182f3c780b23e1448888728ad89be2bbaf7ebe5631d6bff7c7ae77db", + "bytes": 1411 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/mixed_high_indegree-float64/case.json", + "copy": "evidence/oracle/mixed_high_indegree-float64/case.json", + "sha256": "73216eb4215f0caa690415f883ee1d1edafbab28701a1c0b2dfa0efc6202c622", + "bytes": 1711 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/mixed_high_indegree-float64/coefficients.json", + "copy": "evidence/oracle/mixed_high_indegree-float64/coefficients.json", + "sha256": "5e605becd694eac6bfd450c8590626dce715dc0de442c3e98272567a81503e12", + "bytes": 2329 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/mixed_high_indegree-float64/environment.json", + "copy": "evidence/oracle/mixed_high_indegree-float64/environment.json", + "sha256": "8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6", + "bytes": 352 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/mixed_high_indegree-float64/instrumented/coefficients.json", + "copy": "evidence/oracle/mixed_high_indegree-float64/instrumented/coefficients.json", + "sha256": "5e605becd694eac6bfd450c8590626dce715dc0de442c3e98272567a81503e12", + "bytes": 2329 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/mixed_high_indegree-float64/instrumented/compiled-code.json", + "copy": "evidence/oracle/mixed_high_indegree-float64/instrumented/compiled-code.json", + "sha256": "d37bbac320791543bdc13106f71c8aab50c345ca93aeee06d49ce26131e5e198", + "bytes": 11202 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/mixed_high_indegree-float64/instrumented/completeness.csv", + "copy": "evidence/oracle/mixed_high_indegree-float64/instrumented/completeness.csv", + "sha256": "1f01bd89fa27a1fc11336336d420c1100171017febe074713369fcf51db27363", + "bytes": 1188 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/mixed_high_indegree-float64/instrumented/generated-code.json", + "copy": "evidence/oracle/mixed_high_indegree-float64/instrumented/generated-code.json", + "sha256": "c342dd96ec558d76650bc92d6e3905b2dca5f984757a65e7313eb7b5fc879d8e", + "bytes": 11214 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/mixed_high_indegree-float64/instrumented/input-audit.json", + "copy": "evidence/oracle/mixed_high_indegree-float64/instrumented/input-audit.json", + "sha256": "2ede5c192bca9326d35a9d24ec98eb460e120684d8d25f37223afdfdcd010f2e", + "bytes": 1236 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/mixed_high_indegree-float64/instrumented/queue-audit.json", + "copy": "evidence/oracle/mixed_high_indegree-float64/instrumented/queue-audit.json", + "sha256": "7dbd83f1582516800c4fa4fc7f4a843bf72cff4666556177a42aea474dd0f720", + "bytes": 460 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/mixed_high_indegree-float64/instrumented/schedule.json", + "copy": "evidence/oracle/mixed_high_indegree-float64/instrumented/schedule.json", + "sha256": "0db2d5f73709934bf7a91db2908a8dc3301614d09490769bf369aad96ee4f0fb", + "bytes": 1574 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/mixed_high_indegree-float64/proxy-validation.json", + "copy": "evidence/oracle/mixed_high_indegree-float64/proxy-validation.json", + "sha256": "87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09", + "bytes": 774 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/mixed_high_indegree-float64/summary.json", + "copy": "evidence/oracle/mixed_high_indegree-float64/summary.json", + "sha256": "d7e89190cf331bd4624b12e4863a72abe6c330ba205f72e3a1adba6976d2b1e1", + "bytes": 599 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/mixed_high_indegree-float64/unwrapped-audit/coefficients.json", + "copy": "evidence/oracle/mixed_high_indegree-float64/unwrapped-audit/coefficients.json", + "sha256": "7cfc3cd553fcac4fe52bfa455c5f440a8e98a1a621a135500e9a4b16551f6297", + "bytes": 2329 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/mixed_high_indegree-float64/unwrapped-audit/compiled-code.json", + "copy": "evidence/oracle/mixed_high_indegree-float64/unwrapped-audit/compiled-code.json", + "sha256": "9ef07e82240727c9761386ecdd054475050156677e9b0a3a6bc37b845c1f602c", + "bytes": 11038 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/mixed_high_indegree-float64/unwrapped-audit/completeness.csv", + "copy": "evidence/oracle/mixed_high_indegree-float64/unwrapped-audit/completeness.csv", + "sha256": "1f01bd89fa27a1fc11336336d420c1100171017febe074713369fcf51db27363", + "bytes": 1188 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/mixed_high_indegree-float64/unwrapped-audit/generated-code.json", + "copy": "evidence/oracle/mixed_high_indegree-float64/unwrapped-audit/generated-code.json", + "sha256": "1d622ac2f0e046e2edde7dfb62b3fb7b2ce247c3324410782300eeabb1db4253", + "bytes": 11050 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/mixed_high_indegree-float64/unwrapped-audit/input-audit.json", + "copy": "evidence/oracle/mixed_high_indegree-float64/unwrapped-audit/input-audit.json", + "sha256": "a4324de251964451d25ce4cd4bbe1a3383de9a9930108d22959ac1303655be6f", + "bytes": 1237 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/mixed_high_indegree-float64/unwrapped-audit/queue-audit.json", + "copy": "evidence/oracle/mixed_high_indegree-float64/unwrapped-audit/queue-audit.json", + "sha256": "33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7", + "bytes": 371 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/mixed_high_indegree-float64/unwrapped-audit/schedule.json", + "copy": "evidence/oracle/mixed_high_indegree-float64/unwrapped-audit/schedule.json", + "sha256": "af9f8f7b182f3c780b23e1448888728ad89be2bbaf7ebe5631d6bff7c7ae77db", + "bytes": 1411 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_feedforward-float32/case.json", + "copy": "evidence/oracle/motif_feedforward-float32/case.json", + "sha256": "514451ef42e4a1eef22998de3fe9263d84cdc45e83771194d855859b05057eef", + "bytes": 1244 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_feedforward-float32/coefficients.json", + "copy": "evidence/oracle/motif_feedforward-float32/coefficients.json", + "sha256": "ec5e4c7e313291d044a1447c276582cbb16ade5cc052675bd83c1016a924942e", + "bytes": 2329 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_feedforward-float32/environment.json", + "copy": "evidence/oracle/motif_feedforward-float32/environment.json", + "sha256": "8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6", + "bytes": 352 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_feedforward-float32/instrumented/coefficients.json", + "copy": "evidence/oracle/motif_feedforward-float32/instrumented/coefficients.json", + "sha256": "ec5e4c7e313291d044a1447c276582cbb16ade5cc052675bd83c1016a924942e", + "bytes": 2329 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_feedforward-float32/instrumented/compiled-code.json", + "copy": "evidence/oracle/motif_feedforward-float32/instrumented/compiled-code.json", + "sha256": "d37bbac320791543bdc13106f71c8aab50c345ca93aeee06d49ce26131e5e198", + "bytes": 11202 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_feedforward-float32/instrumented/completeness.csv", + "copy": "evidence/oracle/motif_feedforward-float32/instrumented/completeness.csv", + "sha256": "301ae4572c658aa307fc998e009377e9c82467d97d66aa1ac4b3f518385ec5a5", + "bytes": 68 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_feedforward-float32/instrumented/generated-code.json", + "copy": "evidence/oracle/motif_feedforward-float32/instrumented/generated-code.json", + "sha256": "9587d16853d78dac3cc8193142de3210c1b2bd3eddd076e0da070cb8544ebd6a", + "bytes": 11214 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_feedforward-float32/instrumented/input-audit.json", + "copy": "evidence/oracle/motif_feedforward-float32/instrumented/input-audit.json", + "sha256": "7198a08c9241603eb8f0c5c89272ff19c0b8bb4ed7ecc44f3fcdd25a37224287", + "bytes": 1237 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_feedforward-float32/instrumented/queue-audit.json", + "copy": "evidence/oracle/motif_feedforward-float32/instrumented/queue-audit.json", + "sha256": "b4a57dfcb794a3168dbcc76688e07696769def8bada0bd896ddba7355a3a2fdd", + "bytes": 458 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_feedforward-float32/instrumented/schedule.json", + "copy": "evidence/oracle/motif_feedforward-float32/instrumented/schedule.json", + "sha256": "0db2d5f73709934bf7a91db2908a8dc3301614d09490769bf369aad96ee4f0fb", + "bytes": 1574 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_feedforward-float32/proxy-validation.json", + "copy": "evidence/oracle/motif_feedforward-float32/proxy-validation.json", + "sha256": "87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09", + "bytes": 774 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_feedforward-float32/summary.json", + "copy": "evidence/oracle/motif_feedforward-float32/summary.json", + "sha256": "ebb76b8c5795e16816072f00049b59182e6dc8b2dad826d76e65f5fbd4711f4b", + "bytes": 584 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_feedforward-float32/unwrapped-audit/coefficients.json", + "copy": "evidence/oracle/motif_feedforward-float32/unwrapped-audit/coefficients.json", + "sha256": "0bf9991cf8a66dc9eed742d7e613b3f1e3ee89bf59e37080324c8f84cbd34a2d", + "bytes": 2329 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_feedforward-float32/unwrapped-audit/compiled-code.json", + "copy": "evidence/oracle/motif_feedforward-float32/unwrapped-audit/compiled-code.json", + "sha256": "9ef07e82240727c9761386ecdd054475050156677e9b0a3a6bc37b845c1f602c", + "bytes": 11038 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_feedforward-float32/unwrapped-audit/completeness.csv", + "copy": "evidence/oracle/motif_feedforward-float32/unwrapped-audit/completeness.csv", + "sha256": "301ae4572c658aa307fc998e009377e9c82467d97d66aa1ac4b3f518385ec5a5", + "bytes": 68 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_feedforward-float32/unwrapped-audit/generated-code.json", + "copy": "evidence/oracle/motif_feedforward-float32/unwrapped-audit/generated-code.json", + "sha256": "aa9a755267ea52baca9275599baef199f7a12023b030e9727821fc4ba34cfa89", + "bytes": 11050 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_feedforward-float32/unwrapped-audit/input-audit.json", + "copy": "evidence/oracle/motif_feedforward-float32/unwrapped-audit/input-audit.json", + "sha256": "85af6959aad3022a8db686ab9b6b295c231d88c85a3b5eeb7cde56bc09438014", + "bytes": 1238 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_feedforward-float32/unwrapped-audit/queue-audit.json", + "copy": "evidence/oracle/motif_feedforward-float32/unwrapped-audit/queue-audit.json", + "sha256": "33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7", + "bytes": 371 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_feedforward-float32/unwrapped-audit/schedule.json", + "copy": "evidence/oracle/motif_feedforward-float32/unwrapped-audit/schedule.json", + "sha256": "af9f8f7b182f3c780b23e1448888728ad89be2bbaf7ebe5631d6bff7c7ae77db", + "bytes": 1411 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_feedforward-float64/case.json", + "copy": "evidence/oracle/motif_feedforward-float64/case.json", + "sha256": "9cee3048169b8298e2510b1578a762939cff01f14ff213de17e1a862b6a2362c", + "bytes": 1244 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_feedforward-float64/coefficients.json", + "copy": "evidence/oracle/motif_feedforward-float64/coefficients.json", + "sha256": "7cfc3cd553fcac4fe52bfa455c5f440a8e98a1a621a135500e9a4b16551f6297", + "bytes": 2329 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_feedforward-float64/environment.json", + "copy": "evidence/oracle/motif_feedforward-float64/environment.json", + "sha256": "8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6", + "bytes": 352 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_feedforward-float64/instrumented/coefficients.json", + "copy": "evidence/oracle/motif_feedforward-float64/instrumented/coefficients.json", + "sha256": "7cfc3cd553fcac4fe52bfa455c5f440a8e98a1a621a135500e9a4b16551f6297", + "bytes": 2329 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_feedforward-float64/instrumented/compiled-code.json", + "copy": "evidence/oracle/motif_feedforward-float64/instrumented/compiled-code.json", + "sha256": "d37bbac320791543bdc13106f71c8aab50c345ca93aeee06d49ce26131e5e198", + "bytes": 11202 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_feedforward-float64/instrumented/completeness.csv", + "copy": "evidence/oracle/motif_feedforward-float64/instrumented/completeness.csv", + "sha256": "301ae4572c658aa307fc998e009377e9c82467d97d66aa1ac4b3f518385ec5a5", + "bytes": 68 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_feedforward-float64/instrumented/generated-code.json", + "copy": "evidence/oracle/motif_feedforward-float64/instrumented/generated-code.json", + "sha256": "f0e4d7b069925eb0132b7ef2e8779d64cfa4eb2fabed7664222944d7338fbff6", + "bytes": 11214 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_feedforward-float64/instrumented/input-audit.json", + "copy": "evidence/oracle/motif_feedforward-float64/instrumented/input-audit.json", + "sha256": "df729fbad17510beab496ddd2801ecfc3aa0c17e5e3034bbdd2011a544c174c3", + "bytes": 1237 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_feedforward-float64/instrumented/queue-audit.json", + "copy": "evidence/oracle/motif_feedforward-float64/instrumented/queue-audit.json", + "sha256": "9cb637d33e2e387f22516c317c6e07f622f03b077af0dc2023e14138f0d900d1", + "bytes": 458 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_feedforward-float64/instrumented/schedule.json", + "copy": "evidence/oracle/motif_feedforward-float64/instrumented/schedule.json", + "sha256": "0db2d5f73709934bf7a91db2908a8dc3301614d09490769bf369aad96ee4f0fb", + "bytes": 1574 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_feedforward-float64/proxy-validation.json", + "copy": "evidence/oracle/motif_feedforward-float64/proxy-validation.json", + "sha256": "87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09", + "bytes": 774 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_feedforward-float64/summary.json", + "copy": "evidence/oracle/motif_feedforward-float64/summary.json", + "sha256": "6b600b1c3aca917738398e5ed03b0cc7dc4793df7c03b5a2dbdd07747e331b1f", + "bytes": 584 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_feedforward-float64/unwrapped-audit/coefficients.json", + "copy": "evidence/oracle/motif_feedforward-float64/unwrapped-audit/coefficients.json", + "sha256": "ec5e4c7e313291d044a1447c276582cbb16ade5cc052675bd83c1016a924942e", + "bytes": 2329 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_feedforward-float64/unwrapped-audit/compiled-code.json", + "copy": "evidence/oracle/motif_feedforward-float64/unwrapped-audit/compiled-code.json", + "sha256": "9ef07e82240727c9761386ecdd054475050156677e9b0a3a6bc37b845c1f602c", + "bytes": 11038 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_feedforward-float64/unwrapped-audit/completeness.csv", + "copy": "evidence/oracle/motif_feedforward-float64/unwrapped-audit/completeness.csv", + "sha256": "301ae4572c658aa307fc998e009377e9c82467d97d66aa1ac4b3f518385ec5a5", + "bytes": 68 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_feedforward-float64/unwrapped-audit/generated-code.json", + "copy": "evidence/oracle/motif_feedforward-float64/unwrapped-audit/generated-code.json", + "sha256": "0711324a1fd18d75f5b243deba0dae9dd992aa54ecd12d5727b91331c1d7faf0", + "bytes": 11050 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_feedforward-float64/unwrapped-audit/input-audit.json", + "copy": "evidence/oracle/motif_feedforward-float64/unwrapped-audit/input-audit.json", + "sha256": "da721733ca6e25552066d11eab447b8ca7f5494fd9780f98b1a10f43d705ffef", + "bytes": 1238 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_feedforward-float64/unwrapped-audit/queue-audit.json", + "copy": "evidence/oracle/motif_feedforward-float64/unwrapped-audit/queue-audit.json", + "sha256": "33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7", + "bytes": 371 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_feedforward-float64/unwrapped-audit/schedule.json", + "copy": "evidence/oracle/motif_feedforward-float64/unwrapped-audit/schedule.json", + "sha256": "af9f8f7b182f3c780b23e1448888728ad89be2bbaf7ebe5631d6bff7c7ae77db", + "bytes": 1411 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_five-float32/case.json", + "copy": "evidence/oracle/motif_five-float32/case.json", + "sha256": "0ba654448ad73f8a7d93d026822d4847d107ebdd887e689c3d73b29355ea46b2", + "bytes": 1237 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_five-float32/coefficients.json", + "copy": "evidence/oracle/motif_five-float32/coefficients.json", + "sha256": "d98eee7b93f944578eebb05b33e94c2515ee82b5753af1eec756a596e7201ac6", + "bytes": 2335 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_five-float32/environment.json", + "copy": "evidence/oracle/motif_five-float32/environment.json", + "sha256": "8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6", + "bytes": 352 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_five-float32/instrumented/coefficients.json", + "copy": "evidence/oracle/motif_five-float32/instrumented/coefficients.json", + "sha256": "d98eee7b93f944578eebb05b33e94c2515ee82b5753af1eec756a596e7201ac6", + "bytes": 2335 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_five-float32/instrumented/compiled-code.json", + "copy": "evidence/oracle/motif_five-float32/instrumented/compiled-code.json", + "sha256": "d37bbac320791543bdc13106f71c8aab50c345ca93aeee06d49ce26131e5e198", + "bytes": 11202 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_five-float32/instrumented/completeness.csv", + "copy": "evidence/oracle/motif_five-float32/instrumented/completeness.csv", + "sha256": "301ae4572c658aa307fc998e009377e9c82467d97d66aa1ac4b3f518385ec5a5", + "bytes": 68 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_five-float32/instrumented/generated-code.json", + "copy": "evidence/oracle/motif_five-float32/instrumented/generated-code.json", + "sha256": "b5bff1e1272f13317e217bebe95a6f8b85713a59d2fcc3c81cfbdf316f56a839", + "bytes": 11218 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_five-float32/instrumented/input-audit.json", + "copy": "evidence/oracle/motif_five-float32/instrumented/input-audit.json", + "sha256": "3ae9c6d4d215251c5f6b0386e853230174156167bcf5c684e9ff0884af12c632", + "bytes": 1237 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_five-float32/instrumented/queue-audit.json", + "copy": "evidence/oracle/motif_five-float32/instrumented/queue-audit.json", + "sha256": "649034e2f1ad4fbdcbc7bc671166e16d5d742629ca65fececf8929a8c2c52e01", + "bytes": 463 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_five-float32/instrumented/schedule.json", + "copy": "evidence/oracle/motif_five-float32/instrumented/schedule.json", + "sha256": "0db2d5f73709934bf7a91db2908a8dc3301614d09490769bf369aad96ee4f0fb", + "bytes": 1574 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_five-float32/proxy-validation.json", + "copy": "evidence/oracle/motif_five-float32/proxy-validation.json", + "sha256": "87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09", + "bytes": 774 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_five-float32/summary.json", + "copy": "evidence/oracle/motif_five-float32/summary.json", + "sha256": "9b650e977f4858b37ffc0884920d4143f6f9704921dd6fc1f42ec71f981eef89", + "bytes": 567 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_five-float32/unwrapped-audit/coefficients.json", + "copy": "evidence/oracle/motif_five-float32/unwrapped-audit/coefficients.json", + "sha256": "d01a405ef9b9be1675c66875d972578ff4c506a468388d8e980f8d449e6dc333", + "bytes": 2335 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_five-float32/unwrapped-audit/compiled-code.json", + "copy": "evidence/oracle/motif_five-float32/unwrapped-audit/compiled-code.json", + "sha256": "9ef07e82240727c9761386ecdd054475050156677e9b0a3a6bc37b845c1f602c", + "bytes": 11038 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_five-float32/unwrapped-audit/completeness.csv", + "copy": "evidence/oracle/motif_five-float32/unwrapped-audit/completeness.csv", + "sha256": "301ae4572c658aa307fc998e009377e9c82467d97d66aa1ac4b3f518385ec5a5", + "bytes": 68 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_five-float32/unwrapped-audit/generated-code.json", + "copy": "evidence/oracle/motif_five-float32/unwrapped-audit/generated-code.json", + "sha256": "e7486df9bef2f372e8d69062750e92ff5e458d772e3b634443b3d9b66d68eccd", + "bytes": 11054 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_five-float32/unwrapped-audit/input-audit.json", + "copy": "evidence/oracle/motif_five-float32/unwrapped-audit/input-audit.json", + "sha256": "7ef4d06198b0ce68e84e6e4c793839ead0d9d3d4e4fe573ed1b4f66e7f828a76", + "bytes": 1238 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_five-float32/unwrapped-audit/queue-audit.json", + "copy": "evidence/oracle/motif_five-float32/unwrapped-audit/queue-audit.json", + "sha256": "33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7", + "bytes": 371 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_five-float32/unwrapped-audit/schedule.json", + "copy": "evidence/oracle/motif_five-float32/unwrapped-audit/schedule.json", + "sha256": "af9f8f7b182f3c780b23e1448888728ad89be2bbaf7ebe5631d6bff7c7ae77db", + "bytes": 1411 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_five-float64/case.json", + "copy": "evidence/oracle/motif_five-float64/case.json", + "sha256": "02428504cba1b7275e6fab9e521d4f417b3d6125996836714347534b567afa66", + "bytes": 1237 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_five-float64/coefficients.json", + "copy": "evidence/oracle/motif_five-float64/coefficients.json", + "sha256": "a75717c29fc1ccf7beb7496183952821a4990365eab5b3c97c7339981903aad4", + "bytes": 2335 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_five-float64/environment.json", + "copy": "evidence/oracle/motif_five-float64/environment.json", + "sha256": "8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6", + "bytes": 352 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_five-float64/instrumented/coefficients.json", + "copy": "evidence/oracle/motif_five-float64/instrumented/coefficients.json", + "sha256": "a75717c29fc1ccf7beb7496183952821a4990365eab5b3c97c7339981903aad4", + "bytes": 2335 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_five-float64/instrumented/compiled-code.json", + "copy": "evidence/oracle/motif_five-float64/instrumented/compiled-code.json", + "sha256": "d37bbac320791543bdc13106f71c8aab50c345ca93aeee06d49ce26131e5e198", + "bytes": 11202 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_five-float64/instrumented/completeness.csv", + "copy": "evidence/oracle/motif_five-float64/instrumented/completeness.csv", + "sha256": "301ae4572c658aa307fc998e009377e9c82467d97d66aa1ac4b3f518385ec5a5", + "bytes": 68 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_five-float64/instrumented/generated-code.json", + "copy": "evidence/oracle/motif_five-float64/instrumented/generated-code.json", + "sha256": "c8ff56101e28a5c44128e24bef4f2b9fdb133c2f934c3c359b841dd9f309607e", + "bytes": 11218 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_five-float64/instrumented/input-audit.json", + "copy": "evidence/oracle/motif_five-float64/instrumented/input-audit.json", + "sha256": "570ddf1c205c30f84634851ba251525855538d1b3ec9ca95227474960076d62a", + "bytes": 1237 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_five-float64/instrumented/queue-audit.json", + "copy": "evidence/oracle/motif_five-float64/instrumented/queue-audit.json", + "sha256": "405762068db98becc1843db0bf506cfcfb9b3d33353ac9e4e168c0f52d9b49e7", + "bytes": 463 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_five-float64/instrumented/schedule.json", + "copy": "evidence/oracle/motif_five-float64/instrumented/schedule.json", + "sha256": "0db2d5f73709934bf7a91db2908a8dc3301614d09490769bf369aad96ee4f0fb", + "bytes": 1574 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_five-float64/proxy-validation.json", + "copy": "evidence/oracle/motif_five-float64/proxy-validation.json", + "sha256": "87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09", + "bytes": 774 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_five-float64/summary.json", + "copy": "evidence/oracle/motif_five-float64/summary.json", + "sha256": "df9c6c8221fdaf65ea5117c650378bcf1b9d53c80c6f4b1b05481d3aa582fef9", + "bytes": 567 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_five-float64/unwrapped-audit/coefficients.json", + "copy": "evidence/oracle/motif_five-float64/unwrapped-audit/coefficients.json", + "sha256": "0bf9991cf8a66dc9eed742d7e613b3f1e3ee89bf59e37080324c8f84cbd34a2d", + "bytes": 2329 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_five-float64/unwrapped-audit/compiled-code.json", + "copy": "evidence/oracle/motif_five-float64/unwrapped-audit/compiled-code.json", + "sha256": "9ef07e82240727c9761386ecdd054475050156677e9b0a3a6bc37b845c1f602c", + "bytes": 11038 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_five-float64/unwrapped-audit/completeness.csv", + "copy": "evidence/oracle/motif_five-float64/unwrapped-audit/completeness.csv", + "sha256": "301ae4572c658aa307fc998e009377e9c82467d97d66aa1ac4b3f518385ec5a5", + "bytes": 68 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_five-float64/unwrapped-audit/generated-code.json", + "copy": "evidence/oracle/motif_five-float64/unwrapped-audit/generated-code.json", + "sha256": "aa9a755267ea52baca9275599baef199f7a12023b030e9727821fc4ba34cfa89", + "bytes": 11050 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_five-float64/unwrapped-audit/input-audit.json", + "copy": "evidence/oracle/motif_five-float64/unwrapped-audit/input-audit.json", + "sha256": "f1ca7891f879fd508bd42f8bdc919deea0c204dbaf694b3e5d7117f7a263c3d9", + "bytes": 1238 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_five-float64/unwrapped-audit/queue-audit.json", + "copy": "evidence/oracle/motif_five-float64/unwrapped-audit/queue-audit.json", + "sha256": "33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7", + "bytes": 371 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_five-float64/unwrapped-audit/schedule.json", + "copy": "evidence/oracle/motif_five-float64/unwrapped-audit/schedule.json", + "sha256": "af9f8f7b182f3c780b23e1448888728ad89be2bbaf7ebe5631d6bff7c7ae77db", + "bytes": 1411 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_no_input-float32/case.json", + "copy": "evidence/oracle/motif_no_input-float32/case.json", + "sha256": "9d179420654413ca1abfb05f22dee6cfb7d51ad2cd6eef69dffc4005c16f0fd6", + "bytes": 1241 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_no_input-float32/coefficients.json", + "copy": "evidence/oracle/motif_no_input-float32/coefficients.json", + "sha256": "de979150b8c18ea8a46a876778327a49353eb5a87e5c1d7d9cafb11c9f6d8483", + "bytes": 2335 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_no_input-float32/environment.json", + "copy": "evidence/oracle/motif_no_input-float32/environment.json", + "sha256": "8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6", + "bytes": 352 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_no_input-float32/instrumented/coefficients.json", + "copy": "evidence/oracle/motif_no_input-float32/instrumented/coefficients.json", + "sha256": "de979150b8c18ea8a46a876778327a49353eb5a87e5c1d7d9cafb11c9f6d8483", + "bytes": 2335 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_no_input-float32/instrumented/compiled-code.json", + "copy": "evidence/oracle/motif_no_input-float32/instrumented/compiled-code.json", + "sha256": "d37bbac320791543bdc13106f71c8aab50c345ca93aeee06d49ce26131e5e198", + "bytes": 11202 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_no_input-float32/instrumented/completeness.csv", + "copy": "evidence/oracle/motif_no_input-float32/instrumented/completeness.csv", + "sha256": "301ae4572c658aa307fc998e009377e9c82467d97d66aa1ac4b3f518385ec5a5", + "bytes": 68 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_no_input-float32/instrumented/generated-code.json", + "copy": "evidence/oracle/motif_no_input-float32/instrumented/generated-code.json", + "sha256": "e5aa1ab2a7909ec49496dbef2284053c3e1e879b11a18e0fc77e864f12501818", + "bytes": 11218 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_no_input-float32/instrumented/input-audit.json", + "copy": "evidence/oracle/motif_no_input-float32/instrumented/input-audit.json", + "sha256": "3ae9c6d4d215251c5f6b0386e853230174156167bcf5c684e9ff0884af12c632", + "bytes": 1237 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_no_input-float32/instrumented/queue-audit.json", + "copy": "evidence/oracle/motif_no_input-float32/instrumented/queue-audit.json", + "sha256": "cee965022108973f9b9da6aeb880f6eb1dfb3d75bd613658f7164784da3adb00", + "bytes": 459 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_no_input-float32/instrumented/schedule.json", + "copy": "evidence/oracle/motif_no_input-float32/instrumented/schedule.json", + "sha256": "0db2d5f73709934bf7a91db2908a8dc3301614d09490769bf369aad96ee4f0fb", + "bytes": 1574 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_no_input-float32/proxy-validation.json", + "copy": "evidence/oracle/motif_no_input-float32/proxy-validation.json", + "sha256": "87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09", + "bytes": 774 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_no_input-float32/summary.json", + "copy": "evidence/oracle/motif_no_input-float32/summary.json", + "sha256": "f6714c8b34ba46595deb08f2b87623d8ffb94dbbea423d8319136948e1b2dea1", + "bytes": 576 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_no_input-float32/unwrapped-audit/coefficients.json", + "copy": "evidence/oracle/motif_no_input-float32/unwrapped-audit/coefficients.json", + "sha256": "a45521c8cc13306fa535adf1cbf9f476b88061351774660f680abf04ee65899d", + "bytes": 2335 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_no_input-float32/unwrapped-audit/compiled-code.json", + "copy": "evidence/oracle/motif_no_input-float32/unwrapped-audit/compiled-code.json", + "sha256": "9ef07e82240727c9761386ecdd054475050156677e9b0a3a6bc37b845c1f602c", + "bytes": 11038 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_no_input-float32/unwrapped-audit/completeness.csv", + "copy": "evidence/oracle/motif_no_input-float32/unwrapped-audit/completeness.csv", + "sha256": "301ae4572c658aa307fc998e009377e9c82467d97d66aa1ac4b3f518385ec5a5", + "bytes": 68 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_no_input-float32/unwrapped-audit/generated-code.json", + "copy": "evidence/oracle/motif_no_input-float32/unwrapped-audit/generated-code.json", + "sha256": "27e213d76a91871c492e28be66c7a093fd4e1ba5920b7fd87a59f3b5ccca1b05", + "bytes": 11054 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_no_input-float32/unwrapped-audit/input-audit.json", + "copy": "evidence/oracle/motif_no_input-float32/unwrapped-audit/input-audit.json", + "sha256": "7ef4d06198b0ce68e84e6e4c793839ead0d9d3d4e4fe573ed1b4f66e7f828a76", + "bytes": 1238 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_no_input-float32/unwrapped-audit/queue-audit.json", + "copy": "evidence/oracle/motif_no_input-float32/unwrapped-audit/queue-audit.json", + "sha256": "33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7", + "bytes": 371 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_no_input-float32/unwrapped-audit/schedule.json", + "copy": "evidence/oracle/motif_no_input-float32/unwrapped-audit/schedule.json", + "sha256": "af9f8f7b182f3c780b23e1448888728ad89be2bbaf7ebe5631d6bff7c7ae77db", + "bytes": 1411 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_no_input-float64/case.json", + "copy": "evidence/oracle/motif_no_input-float64/case.json", + "sha256": "e09512d3a290d1b67017d8041beee4445dff7338d25ee5a419662ce0fa1e0294", + "bytes": 1241 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_no_input-float64/coefficients.json", + "copy": "evidence/oracle/motif_no_input-float64/coefficients.json", + "sha256": "0bf9991cf8a66dc9eed742d7e613b3f1e3ee89bf59e37080324c8f84cbd34a2d", + "bytes": 2329 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_no_input-float64/environment.json", + "copy": "evidence/oracle/motif_no_input-float64/environment.json", + "sha256": "8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6", + "bytes": 352 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_no_input-float64/instrumented/coefficients.json", + "copy": "evidence/oracle/motif_no_input-float64/instrumented/coefficients.json", + "sha256": "0bf9991cf8a66dc9eed742d7e613b3f1e3ee89bf59e37080324c8f84cbd34a2d", + "bytes": 2329 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_no_input-float64/instrumented/compiled-code.json", + "copy": "evidence/oracle/motif_no_input-float64/instrumented/compiled-code.json", + "sha256": "d37bbac320791543bdc13106f71c8aab50c345ca93aeee06d49ce26131e5e198", + "bytes": 11202 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_no_input-float64/instrumented/completeness.csv", + "copy": "evidence/oracle/motif_no_input-float64/instrumented/completeness.csv", + "sha256": "301ae4572c658aa307fc998e009377e9c82467d97d66aa1ac4b3f518385ec5a5", + "bytes": 68 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_no_input-float64/instrumented/generated-code.json", + "copy": "evidence/oracle/motif_no_input-float64/instrumented/generated-code.json", + "sha256": "e2863283352ed45e14e825141be421dc603061254dd7676cd5db972b676990a9", + "bytes": 11214 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_no_input-float64/instrumented/input-audit.json", + "copy": "evidence/oracle/motif_no_input-float64/instrumented/input-audit.json", + "sha256": "570ddf1c205c30f84634851ba251525855538d1b3ec9ca95227474960076d62a", + "bytes": 1237 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_no_input-float64/instrumented/queue-audit.json", + "copy": "evidence/oracle/motif_no_input-float64/instrumented/queue-audit.json", + "sha256": "d7d8e6eba191b4fb6a8876896c9b932e2a908e66cf6e419065d6b7f1cbeda73e", + "bytes": 458 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_no_input-float64/instrumented/schedule.json", + "copy": "evidence/oracle/motif_no_input-float64/instrumented/schedule.json", + "sha256": "0db2d5f73709934bf7a91db2908a8dc3301614d09490769bf369aad96ee4f0fb", + "bytes": 1574 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_no_input-float64/proxy-validation.json", + "copy": "evidence/oracle/motif_no_input-float64/proxy-validation.json", + "sha256": "87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09", + "bytes": 774 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_no_input-float64/summary.json", + "copy": "evidence/oracle/motif_no_input-float64/summary.json", + "sha256": "5f27219565e45f42327bdf33e08d0c38373d6719f932d88454ab0bc5be7c9f7d", + "bytes": 576 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_no_input-float64/unwrapped-audit/coefficients.json", + "copy": "evidence/oracle/motif_no_input-float64/unwrapped-audit/coefficients.json", + "sha256": "d01a405ef9b9be1675c66875d972578ff4c506a468388d8e980f8d449e6dc333", + "bytes": 2335 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_no_input-float64/unwrapped-audit/compiled-code.json", + "copy": "evidence/oracle/motif_no_input-float64/unwrapped-audit/compiled-code.json", + "sha256": "9ef07e82240727c9761386ecdd054475050156677e9b0a3a6bc37b845c1f602c", + "bytes": 11038 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_no_input-float64/unwrapped-audit/completeness.csv", + "copy": "evidence/oracle/motif_no_input-float64/unwrapped-audit/completeness.csv", + "sha256": "301ae4572c658aa307fc998e009377e9c82467d97d66aa1ac4b3f518385ec5a5", + "bytes": 68 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_no_input-float64/unwrapped-audit/generated-code.json", + "copy": "evidence/oracle/motif_no_input-float64/unwrapped-audit/generated-code.json", + "sha256": "e7486df9bef2f372e8d69062750e92ff5e458d772e3b634443b3d9b66d68eccd", + "bytes": 11054 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_no_input-float64/unwrapped-audit/input-audit.json", + "copy": "evidence/oracle/motif_no_input-float64/unwrapped-audit/input-audit.json", + "sha256": "f1ca7891f879fd508bd42f8bdc919deea0c204dbaf694b3e5d7117f7a263c3d9", + "bytes": 1238 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_no_input-float64/unwrapped-audit/queue-audit.json", + "copy": "evidence/oracle/motif_no_input-float64/unwrapped-audit/queue-audit.json", + "sha256": "33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7", + "bytes": 371 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_no_input-float64/unwrapped-audit/schedule.json", + "copy": "evidence/oracle/motif_no_input-float64/unwrapped-audit/schedule.json", + "sha256": "af9f8f7b182f3c780b23e1448888728ad89be2bbaf7ebe5631d6bff7c7ae77db", + "bytes": 1411 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_pair-float32/case.json", + "copy": "evidence/oracle/motif_pair-float32/case.json", + "sha256": "7c2e51163cc02ade1ad547b0f80b72e3a2ce41e9ddbc8488c0963ae8cb8b25fd", + "bytes": 1237 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_pair-float32/coefficients.json", + "copy": "evidence/oracle/motif_pair-float32/coefficients.json", + "sha256": "a96c603914560bec97c4da88bdc22a77ba3feaf49c83226793b258c67c856b91", + "bytes": 2335 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_pair-float32/environment.json", + "copy": "evidence/oracle/motif_pair-float32/environment.json", + "sha256": "8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6", + "bytes": 352 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_pair-float32/instrumented/coefficients.json", + "copy": "evidence/oracle/motif_pair-float32/instrumented/coefficients.json", + "sha256": "a96c603914560bec97c4da88bdc22a77ba3feaf49c83226793b258c67c856b91", + "bytes": 2335 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_pair-float32/instrumented/compiled-code.json", + "copy": "evidence/oracle/motif_pair-float32/instrumented/compiled-code.json", + "sha256": "d37bbac320791543bdc13106f71c8aab50c345ca93aeee06d49ce26131e5e198", + "bytes": 11202 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_pair-float32/instrumented/completeness.csv", + "copy": "evidence/oracle/motif_pair-float32/instrumented/completeness.csv", + "sha256": "5af02939034e66e7a8e7c361555203906d69bbba0042b1ab549041db1626f02b", + "bytes": 44 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_pair-float32/instrumented/generated-code.json", + "copy": "evidence/oracle/motif_pair-float32/instrumented/generated-code.json", + "sha256": "04dd8561cbfca6932ddc94ffbf3228449a7ab8676b153db775cf1514af9f61cb", + "bytes": 11218 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_pair-float32/instrumented/input-audit.json", + "copy": "evidence/oracle/motif_pair-float32/instrumented/input-audit.json", + "sha256": "c6618376a52844263736e9dd031ff5745543d4db39d51072381d2230a9c61076", + "bytes": 1237 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_pair-float32/instrumented/queue-audit.json", + "copy": "evidence/oracle/motif_pair-float32/instrumented/queue-audit.json", + "sha256": "e7aade6f0cedd94c4c07fbe6eb69dbfb345cb2793bf819cc7fd995d708df83e5", + "bytes": 461 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_pair-float32/instrumented/schedule.json", + "copy": "evidence/oracle/motif_pair-float32/instrumented/schedule.json", + "sha256": "0db2d5f73709934bf7a91db2908a8dc3301614d09490769bf369aad96ee4f0fb", + "bytes": 1574 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_pair-float32/proxy-validation.json", + "copy": "evidence/oracle/motif_pair-float32/proxy-validation.json", + "sha256": "87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09", + "bytes": 774 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_pair-float32/summary.json", + "copy": "evidence/oracle/motif_pair-float32/summary.json", + "sha256": "c282c963d6a2e7c80a70aa20d339f57ea46cdb9a4c296ae1017f37c42f71a66b", + "bytes": 565 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_pair-float32/unwrapped-audit/coefficients.json", + "copy": "evidence/oracle/motif_pair-float32/unwrapped-audit/coefficients.json", + "sha256": "7de7395618cc75c739c64aa06e9b5111270a04f6e38e4fead6f42bc9838b24d9", + "bytes": 2335 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_pair-float32/unwrapped-audit/compiled-code.json", + "copy": "evidence/oracle/motif_pair-float32/unwrapped-audit/compiled-code.json", + "sha256": "9ef07e82240727c9761386ecdd054475050156677e9b0a3a6bc37b845c1f602c", + "bytes": 11038 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_pair-float32/unwrapped-audit/completeness.csv", + "copy": "evidence/oracle/motif_pair-float32/unwrapped-audit/completeness.csv", + "sha256": "5af02939034e66e7a8e7c361555203906d69bbba0042b1ab549041db1626f02b", + "bytes": 44 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_pair-float32/unwrapped-audit/generated-code.json", + "copy": "evidence/oracle/motif_pair-float32/unwrapped-audit/generated-code.json", + "sha256": "6285bf3f565631bb13f61df1de231f6431e9dbba62c9390a770a481fecf434d4", + "bytes": 11054 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_pair-float32/unwrapped-audit/input-audit.json", + "copy": "evidence/oracle/motif_pair-float32/unwrapped-audit/input-audit.json", + "sha256": "38494b8726f5685faae5116251a91c775d036f984a7d6685d5512b8cc4730197", + "bytes": 1238 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_pair-float32/unwrapped-audit/queue-audit.json", + "copy": "evidence/oracle/motif_pair-float32/unwrapped-audit/queue-audit.json", + "sha256": "33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7", + "bytes": 371 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_pair-float32/unwrapped-audit/schedule.json", + "copy": "evidence/oracle/motif_pair-float32/unwrapped-audit/schedule.json", + "sha256": "af9f8f7b182f3c780b23e1448888728ad89be2bbaf7ebe5631d6bff7c7ae77db", + "bytes": 1411 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_pair-float64/case.json", + "copy": "evidence/oracle/motif_pair-float64/case.json", + "sha256": "2c3139962eace310ec0592d1e507efc799658ea0fcdde723c5238e5af214915f", + "bytes": 1237 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_pair-float64/coefficients.json", + "copy": "evidence/oracle/motif_pair-float64/coefficients.json", + "sha256": "d01a405ef9b9be1675c66875d972578ff4c506a468388d8e980f8d449e6dc333", + "bytes": 2335 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_pair-float64/environment.json", + "copy": "evidence/oracle/motif_pair-float64/environment.json", + "sha256": "8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6", + "bytes": 352 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_pair-float64/instrumented/coefficients.json", + "copy": "evidence/oracle/motif_pair-float64/instrumented/coefficients.json", + "sha256": "d01a405ef9b9be1675c66875d972578ff4c506a468388d8e980f8d449e6dc333", + "bytes": 2335 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_pair-float64/instrumented/compiled-code.json", + "copy": "evidence/oracle/motif_pair-float64/instrumented/compiled-code.json", + "sha256": "d37bbac320791543bdc13106f71c8aab50c345ca93aeee06d49ce26131e5e198", + "bytes": 11202 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_pair-float64/instrumented/completeness.csv", + "copy": "evidence/oracle/motif_pair-float64/instrumented/completeness.csv", + "sha256": "5af02939034e66e7a8e7c361555203906d69bbba0042b1ab549041db1626f02b", + "bytes": 44 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_pair-float64/instrumented/generated-code.json", + "copy": "evidence/oracle/motif_pair-float64/instrumented/generated-code.json", + "sha256": "6218cb7a5561987d8a5f4b50df6b8ab178f97d9c8a3b0c2281592030323d19ad", + "bytes": 11218 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_pair-float64/instrumented/input-audit.json", + "copy": "evidence/oracle/motif_pair-float64/instrumented/input-audit.json", + "sha256": "05822e9cca61f7cf9b21e6eb6334e39c783e94d260cb526ac42fd17da4a55bae", + "bytes": 1237 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_pair-float64/instrumented/queue-audit.json", + "copy": "evidence/oracle/motif_pair-float64/instrumented/queue-audit.json", + "sha256": "f20253a8c675f99d0b51612f0faa6ffe968e63f6059b7e0f865d4730de411d75", + "bytes": 461 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_pair-float64/instrumented/schedule.json", + "copy": "evidence/oracle/motif_pair-float64/instrumented/schedule.json", + "sha256": "0db2d5f73709934bf7a91db2908a8dc3301614d09490769bf369aad96ee4f0fb", + "bytes": 1574 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_pair-float64/proxy-validation.json", + "copy": "evidence/oracle/motif_pair-float64/proxy-validation.json", + "sha256": "87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09", + "bytes": 774 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_pair-float64/summary.json", + "copy": "evidence/oracle/motif_pair-float64/summary.json", + "sha256": "d31801b7409b61b11c039dcedb57695447c170d280ff6bae80836a70710eb9d9", + "bytes": 565 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_pair-float64/unwrapped-audit/coefficients.json", + "copy": "evidence/oracle/motif_pair-float64/unwrapped-audit/coefficients.json", + "sha256": "a45521c8cc13306fa535adf1cbf9f476b88061351774660f680abf04ee65899d", + "bytes": 2335 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_pair-float64/unwrapped-audit/compiled-code.json", + "copy": "evidence/oracle/motif_pair-float64/unwrapped-audit/compiled-code.json", + "sha256": "9ef07e82240727c9761386ecdd054475050156677e9b0a3a6bc37b845c1f602c", + "bytes": 11038 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_pair-float64/unwrapped-audit/completeness.csv", + "copy": "evidence/oracle/motif_pair-float64/unwrapped-audit/completeness.csv", + "sha256": "5af02939034e66e7a8e7c361555203906d69bbba0042b1ab549041db1626f02b", + "bytes": 44 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_pair-float64/unwrapped-audit/generated-code.json", + "copy": "evidence/oracle/motif_pair-float64/unwrapped-audit/generated-code.json", + "sha256": "27e213d76a91871c492e28be66c7a093fd4e1ba5920b7fd87a59f3b5ccca1b05", + "bytes": 11054 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_pair-float64/unwrapped-audit/input-audit.json", + "copy": "evidence/oracle/motif_pair-float64/unwrapped-audit/input-audit.json", + "sha256": "5ad9da04ebc86c451a2dc3ee1ae515048da3d0517a2772766e948be58a87cf9e", + "bytes": 1238 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_pair-float64/unwrapped-audit/queue-audit.json", + "copy": "evidence/oracle/motif_pair-float64/unwrapped-audit/queue-audit.json", + "sha256": "33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7", + "bytes": 371 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_pair-float64/unwrapped-audit/schedule.json", + "copy": "evidence/oracle/motif_pair-float64/unwrapped-audit/schedule.json", + "sha256": "af9f8f7b182f3c780b23e1448888728ad89be2bbaf7ebe5631d6bff7c7ae77db", + "bytes": 1411 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_trio-float32/case.json", + "copy": "evidence/oracle/motif_trio-float32/case.json", + "sha256": "a8cfb8d4d18e0619d6da058dae7e8488e22eaf1c78d79e30b7950cef9805392e", + "bytes": 1237 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_trio-float32/coefficients.json", + "copy": "evidence/oracle/motif_trio-float32/coefficients.json", + "sha256": "7c1b1089b738c3acbca361d026af0818c2bedd1058226a4b1613107835f7e063", + "bytes": 2335 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_trio-float32/environment.json", + "copy": "evidence/oracle/motif_trio-float32/environment.json", + "sha256": "8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6", + "bytes": 352 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_trio-float32/instrumented/coefficients.json", + "copy": "evidence/oracle/motif_trio-float32/instrumented/coefficients.json", + "sha256": "7c1b1089b738c3acbca361d026af0818c2bedd1058226a4b1613107835f7e063", + "bytes": 2335 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_trio-float32/instrumented/compiled-code.json", + "copy": "evidence/oracle/motif_trio-float32/instrumented/compiled-code.json", + "sha256": "d37bbac320791543bdc13106f71c8aab50c345ca93aeee06d49ce26131e5e198", + "bytes": 11202 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_trio-float32/instrumented/completeness.csv", + "copy": "evidence/oracle/motif_trio-float32/instrumented/completeness.csv", + "sha256": "e8795d5efb2eebefaae419c6df6d18d3cea3c390d9df7987f55823f5a860169e", + "bytes": 51 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_trio-float32/instrumented/generated-code.json", + "copy": "evidence/oracle/motif_trio-float32/instrumented/generated-code.json", + "sha256": "8c8e0ef283417f030223be90143fe431a2e55c00e197ccfb42a603bcb8e0ac6d", + "bytes": 11218 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_trio-float32/instrumented/input-audit.json", + "copy": "evidence/oracle/motif_trio-float32/instrumented/input-audit.json", + "sha256": "aeb9de630a338539ef77e631d6fad439b8c8bac45f72c9b1ea5a746762f1478e", + "bytes": 1237 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_trio-float32/instrumented/queue-audit.json", + "copy": "evidence/oracle/motif_trio-float32/instrumented/queue-audit.json", + "sha256": "b4e878392aba4af8d5f54a972a0345a1e5ae61f02d3cecd84c66ee16e1c14070", + "bytes": 461 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_trio-float32/instrumented/schedule.json", + "copy": "evidence/oracle/motif_trio-float32/instrumented/schedule.json", + "sha256": "0db2d5f73709934bf7a91db2908a8dc3301614d09490769bf369aad96ee4f0fb", + "bytes": 1574 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_trio-float32/proxy-validation.json", + "copy": "evidence/oracle/motif_trio-float32/proxy-validation.json", + "sha256": "87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09", + "bytes": 774 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_trio-float32/summary.json", + "copy": "evidence/oracle/motif_trio-float32/summary.json", + "sha256": "d854013887eb352536cebd66f3060cb0b7d7048f170a415e56e58641d27c8be7", + "bytes": 565 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_trio-float32/unwrapped-audit/coefficients.json", + "copy": "evidence/oracle/motif_trio-float32/unwrapped-audit/coefficients.json", + "sha256": "e93700e27b476c87d3bd9631847df5930580d588188f2d6356f8fd4278640c62", + "bytes": 2335 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_trio-float32/unwrapped-audit/compiled-code.json", + "copy": "evidence/oracle/motif_trio-float32/unwrapped-audit/compiled-code.json", + "sha256": "9ef07e82240727c9761386ecdd054475050156677e9b0a3a6bc37b845c1f602c", + "bytes": 11038 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_trio-float32/unwrapped-audit/completeness.csv", + "copy": "evidence/oracle/motif_trio-float32/unwrapped-audit/completeness.csv", + "sha256": "e8795d5efb2eebefaae419c6df6d18d3cea3c390d9df7987f55823f5a860169e", + "bytes": 51 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_trio-float32/unwrapped-audit/generated-code.json", + "copy": "evidence/oracle/motif_trio-float32/unwrapped-audit/generated-code.json", + "sha256": "9f4389a017bd872ea48ce57dce09ff7feddc58e4d3e3de3e91a485d8e4efe661", + "bytes": 11054 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_trio-float32/unwrapped-audit/input-audit.json", + "copy": "evidence/oracle/motif_trio-float32/unwrapped-audit/input-audit.json", + "sha256": "b66ee25f7bb8b96360c9c0c3b919cca442eaf90f83644e6ec7ad42f0a5644691", + "bytes": 1238 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_trio-float32/unwrapped-audit/queue-audit.json", + "copy": "evidence/oracle/motif_trio-float32/unwrapped-audit/queue-audit.json", + "sha256": "33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7", + "bytes": 371 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_trio-float32/unwrapped-audit/schedule.json", + "copy": "evidence/oracle/motif_trio-float32/unwrapped-audit/schedule.json", + "sha256": "af9f8f7b182f3c780b23e1448888728ad89be2bbaf7ebe5631d6bff7c7ae77db", + "bytes": 1411 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_trio-float64/case.json", + "copy": "evidence/oracle/motif_trio-float64/case.json", + "sha256": "a72c3e1c5887c5174e5bc1bdd488e21652c2d40e1a64c17bec055d1c33ad8163", + "bytes": 1237 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_trio-float64/coefficients.json", + "copy": "evidence/oracle/motif_trio-float64/coefficients.json", + "sha256": "7de7395618cc75c739c64aa06e9b5111270a04f6e38e4fead6f42bc9838b24d9", + "bytes": 2335 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_trio-float64/environment.json", + "copy": "evidence/oracle/motif_trio-float64/environment.json", + "sha256": "8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6", + "bytes": 352 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_trio-float64/instrumented/coefficients.json", + "copy": "evidence/oracle/motif_trio-float64/instrumented/coefficients.json", + "sha256": "7de7395618cc75c739c64aa06e9b5111270a04f6e38e4fead6f42bc9838b24d9", + "bytes": 2335 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_trio-float64/instrumented/compiled-code.json", + "copy": "evidence/oracle/motif_trio-float64/instrumented/compiled-code.json", + "sha256": "d37bbac320791543bdc13106f71c8aab50c345ca93aeee06d49ce26131e5e198", + "bytes": 11202 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_trio-float64/instrumented/completeness.csv", + "copy": "evidence/oracle/motif_trio-float64/instrumented/completeness.csv", + "sha256": "e8795d5efb2eebefaae419c6df6d18d3cea3c390d9df7987f55823f5a860169e", + "bytes": 51 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_trio-float64/instrumented/generated-code.json", + "copy": "evidence/oracle/motif_trio-float64/instrumented/generated-code.json", + "sha256": "6219a02ab212b7391b8686191afcdf1189aa04c3eb60c3d6faffe54f2130c232", + "bytes": 11218 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_trio-float64/instrumented/input-audit.json", + "copy": "evidence/oracle/motif_trio-float64/instrumented/input-audit.json", + "sha256": "dca8d6b6f6e544292d87ece37af55ea38f48e26265132984c82293a83d3a5126", + "bytes": 1237 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_trio-float64/instrumented/queue-audit.json", + "copy": "evidence/oracle/motif_trio-float64/instrumented/queue-audit.json", + "sha256": "29957621c31b54a95a988fe4a82363c02c7726b27778870b80dc9d63c1741c7f", + "bytes": 461 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_trio-float64/instrumented/schedule.json", + "copy": "evidence/oracle/motif_trio-float64/instrumented/schedule.json", + "sha256": "0db2d5f73709934bf7a91db2908a8dc3301614d09490769bf369aad96ee4f0fb", + "bytes": 1574 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_trio-float64/proxy-validation.json", + "copy": "evidence/oracle/motif_trio-float64/proxy-validation.json", + "sha256": "87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09", + "bytes": 774 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_trio-float64/summary.json", + "copy": "evidence/oracle/motif_trio-float64/summary.json", + "sha256": "96f65fd87b834a3b4e79be2017c42f7e28aea8588393f3ba64ef92d2c9d5e4f7", + "bytes": 565 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_trio-float64/unwrapped-audit/coefficients.json", + "copy": "evidence/oracle/motif_trio-float64/unwrapped-audit/coefficients.json", + "sha256": "7c1b1089b738c3acbca361d026af0818c2bedd1058226a4b1613107835f7e063", + "bytes": 2335 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_trio-float64/unwrapped-audit/compiled-code.json", + "copy": "evidence/oracle/motif_trio-float64/unwrapped-audit/compiled-code.json", + "sha256": "9ef07e82240727c9761386ecdd054475050156677e9b0a3a6bc37b845c1f602c", + "bytes": 11038 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_trio-float64/unwrapped-audit/completeness.csv", + "copy": "evidence/oracle/motif_trio-float64/unwrapped-audit/completeness.csv", + "sha256": "e8795d5efb2eebefaae419c6df6d18d3cea3c390d9df7987f55823f5a860169e", + "bytes": 51 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_trio-float64/unwrapped-audit/generated-code.json", + "copy": "evidence/oracle/motif_trio-float64/unwrapped-audit/generated-code.json", + "sha256": "3dfe75cb3a716d21a5c93328ca9afebf1540f68bf873af5005720b8b41a81231", + "bytes": 11054 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_trio-float64/unwrapped-audit/input-audit.json", + "copy": "evidence/oracle/motif_trio-float64/unwrapped-audit/input-audit.json", + "sha256": "eca8ca955d53b8e6e0568c3f0020bcfd40b8b536f64f74040623dd50235c62ef", + "bytes": 1238 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_trio-float64/unwrapped-audit/queue-audit.json", + "copy": "evidence/oracle/motif_trio-float64/unwrapped-audit/queue-audit.json", + "sha256": "33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7", + "bytes": 371 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/motif_trio-float64/unwrapped-audit/schedule.json", + "copy": "evidence/oracle/motif_trio-float64/unwrapped-audit/schedule.json", + "sha256": "af9f8f7b182f3c780b23e1448888728ad89be2bbaf7ebe5631d6bff7c7ae77db", + "bytes": 1411 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/ordered_cancellation-float32/case.json", + "copy": "evidence/oracle/ordered_cancellation-float32/case.json", + "sha256": "83987a7bbeb3dde14fac3de2f73ce9270b0be4d0d1a444212e0a42fea8099df9", + "bytes": 1273 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/ordered_cancellation-float32/coefficients.json", + "copy": "evidence/oracle/ordered_cancellation-float32/coefficients.json", + "sha256": "25028e6abaf2d0674eff984499f9b03e540ea7ec39006e1792242a71a662654c", + "bytes": 2335 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/ordered_cancellation-float32/environment.json", + "copy": "evidence/oracle/ordered_cancellation-float32/environment.json", + "sha256": "8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6", + "bytes": 352 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/ordered_cancellation-float32/instrumented/coefficients.json", + "copy": "evidence/oracle/ordered_cancellation-float32/instrumented/coefficients.json", + "sha256": "25028e6abaf2d0674eff984499f9b03e540ea7ec39006e1792242a71a662654c", + "bytes": 2335 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/ordered_cancellation-float32/instrumented/compiled-code.json", + "copy": "evidence/oracle/ordered_cancellation-float32/instrumented/compiled-code.json", + "sha256": "d37bbac320791543bdc13106f71c8aab50c345ca93aeee06d49ce26131e5e198", + "bytes": 11202 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/ordered_cancellation-float32/instrumented/completeness.csv", + "copy": "evidence/oracle/ordered_cancellation-float32/instrumented/completeness.csv", + "sha256": "d861bdcdccde99f4c49e489f5f22e274a3e810fa365d0858513d91092f6ddeed", + "bytes": 242 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/ordered_cancellation-float32/instrumented/generated-code.json", + "copy": "evidence/oracle/ordered_cancellation-float32/instrumented/generated-code.json", + "sha256": "7f4e8f22ed3dcdf089914e79c574bbbb404f4eb6bb3fecca4a680e3f9d3c0857", + "bytes": 11218 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/ordered_cancellation-float32/instrumented/input-audit.json", + "copy": "evidence/oracle/ordered_cancellation-float32/instrumented/input-audit.json", + "sha256": "6375f3b8727a3b9023eb16a811cb2ab95ca75f0d039190faa015801f0fa472ce", + "bytes": 1236 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/ordered_cancellation-float32/instrumented/queue-audit.json", + "copy": "evidence/oracle/ordered_cancellation-float32/instrumented/queue-audit.json", + "sha256": "215e1d7357f2adbd81c2dc4e71948d1341cda30ec05ea55adc46e546c3952780", + "bytes": 459 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/ordered_cancellation-float32/instrumented/schedule.json", + "copy": "evidence/oracle/ordered_cancellation-float32/instrumented/schedule.json", + "sha256": "0db2d5f73709934bf7a91db2908a8dc3301614d09490769bf369aad96ee4f0fb", + "bytes": 1574 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/ordered_cancellation-float32/proxy-validation.json", + "copy": "evidence/oracle/ordered_cancellation-float32/proxy-validation.json", + "sha256": "87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09", + "bytes": 774 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/ordered_cancellation-float32/summary.json", + "copy": "evidence/oracle/ordered_cancellation-float32/summary.json", + "sha256": "5fde5e19bb7f3ea8bace360458c67652575827fd2f8f493cafade16537c7efcf", + "bytes": 598 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/ordered_cancellation-float32/unwrapped-audit/coefficients.json", + "copy": "evidence/oracle/ordered_cancellation-float32/unwrapped-audit/coefficients.json", + "sha256": "5c7757cd44e4f994f9d1496a3533ffc3ae993d3f9327764e57183e4167a02ef6", + "bytes": 2335 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/ordered_cancellation-float32/unwrapped-audit/compiled-code.json", + "copy": "evidence/oracle/ordered_cancellation-float32/unwrapped-audit/compiled-code.json", + "sha256": "9ef07e82240727c9761386ecdd054475050156677e9b0a3a6bc37b845c1f602c", + "bytes": 11038 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/ordered_cancellation-float32/unwrapped-audit/completeness.csv", + "copy": "evidence/oracle/ordered_cancellation-float32/unwrapped-audit/completeness.csv", + "sha256": "d861bdcdccde99f4c49e489f5f22e274a3e810fa365d0858513d91092f6ddeed", + "bytes": 242 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/ordered_cancellation-float32/unwrapped-audit/generated-code.json", + "copy": "evidence/oracle/ordered_cancellation-float32/unwrapped-audit/generated-code.json", + "sha256": "78041f723fdc221809a9202f586abfb828114e0c60101e72b8f82dbb7b349b4e", + "bytes": 11054 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/ordered_cancellation-float32/unwrapped-audit/input-audit.json", + "copy": "evidence/oracle/ordered_cancellation-float32/unwrapped-audit/input-audit.json", + "sha256": "853eb8557130dd59256f4d8b53ba1f104aea43f6e6d2aab68e12f2d3fced8e90", + "bytes": 1237 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/ordered_cancellation-float32/unwrapped-audit/queue-audit.json", + "copy": "evidence/oracle/ordered_cancellation-float32/unwrapped-audit/queue-audit.json", + "sha256": "33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7", + "bytes": 371 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/ordered_cancellation-float32/unwrapped-audit/schedule.json", + "copy": "evidence/oracle/ordered_cancellation-float32/unwrapped-audit/schedule.json", + "sha256": "af9f8f7b182f3c780b23e1448888728ad89be2bbaf7ebe5631d6bff7c7ae77db", + "bytes": 1411 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/ordered_cancellation-float64/case.json", + "copy": "evidence/oracle/ordered_cancellation-float64/case.json", + "sha256": "42a5b1bd97192138c1aa231a7cc200fb4cd50e2eaf71ca79ba50005444272761", + "bytes": 1273 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/ordered_cancellation-float64/coefficients.json", + "copy": "evidence/oracle/ordered_cancellation-float64/coefficients.json", + "sha256": "e93700e27b476c87d3bd9631847df5930580d588188f2d6356f8fd4278640c62", + "bytes": 2335 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/ordered_cancellation-float64/environment.json", + "copy": "evidence/oracle/ordered_cancellation-float64/environment.json", + "sha256": "8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6", + "bytes": 352 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/ordered_cancellation-float64/instrumented/coefficients.json", + "copy": "evidence/oracle/ordered_cancellation-float64/instrumented/coefficients.json", + "sha256": "e93700e27b476c87d3bd9631847df5930580d588188f2d6356f8fd4278640c62", + "bytes": 2335 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/ordered_cancellation-float64/instrumented/compiled-code.json", + "copy": "evidence/oracle/ordered_cancellation-float64/instrumented/compiled-code.json", + "sha256": "d37bbac320791543bdc13106f71c8aab50c345ca93aeee06d49ce26131e5e198", + "bytes": 11202 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/ordered_cancellation-float64/instrumented/completeness.csv", + "copy": "evidence/oracle/ordered_cancellation-float64/instrumented/completeness.csv", + "sha256": "d861bdcdccde99f4c49e489f5f22e274a3e810fa365d0858513d91092f6ddeed", + "bytes": 242 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/ordered_cancellation-float64/instrumented/generated-code.json", + "copy": "evidence/oracle/ordered_cancellation-float64/instrumented/generated-code.json", + "sha256": "ce982dd6dd2bf6f81d608e820add84fbe611d51a6157fbae6fb2b9e1e30dd571", + "bytes": 11218 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/ordered_cancellation-float64/instrumented/input-audit.json", + "copy": "evidence/oracle/ordered_cancellation-float64/instrumented/input-audit.json", + "sha256": "4969d3f0ae5857d3eca879568c757e6d4b631d4fb0f90212eb5951836b41d1f3", + "bytes": 1236 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/ordered_cancellation-float64/instrumented/queue-audit.json", + "copy": "evidence/oracle/ordered_cancellation-float64/instrumented/queue-audit.json", + "sha256": "0de23642c9438c99c3c1f93efb4ee282ba55e2ebb9d04b77ae93d4a10fd92fa4", + "bytes": 459 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/ordered_cancellation-float64/instrumented/schedule.json", + "copy": "evidence/oracle/ordered_cancellation-float64/instrumented/schedule.json", + "sha256": "0db2d5f73709934bf7a91db2908a8dc3301614d09490769bf369aad96ee4f0fb", + "bytes": 1574 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/ordered_cancellation-float64/proxy-validation.json", + "copy": "evidence/oracle/ordered_cancellation-float64/proxy-validation.json", + "sha256": "87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09", + "bytes": 774 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/ordered_cancellation-float64/summary.json", + "copy": "evidence/oracle/ordered_cancellation-float64/summary.json", + "sha256": "538d114715e29bfe83252cd5ce86bdc69e416f643422d7d66bc3b9cc634a2382", + "bytes": 598 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/ordered_cancellation-float64/unwrapped-audit/coefficients.json", + "copy": "evidence/oracle/ordered_cancellation-float64/unwrapped-audit/coefficients.json", + "sha256": "25028e6abaf2d0674eff984499f9b03e540ea7ec39006e1792242a71a662654c", + "bytes": 2335 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/ordered_cancellation-float64/unwrapped-audit/compiled-code.json", + "copy": "evidence/oracle/ordered_cancellation-float64/unwrapped-audit/compiled-code.json", + "sha256": "9ef07e82240727c9761386ecdd054475050156677e9b0a3a6bc37b845c1f602c", + "bytes": 11038 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/ordered_cancellation-float64/unwrapped-audit/completeness.csv", + "copy": "evidence/oracle/ordered_cancellation-float64/unwrapped-audit/completeness.csv", + "sha256": "d861bdcdccde99f4c49e489f5f22e274a3e810fa365d0858513d91092f6ddeed", + "bytes": 242 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/ordered_cancellation-float64/unwrapped-audit/generated-code.json", + "copy": "evidence/oracle/ordered_cancellation-float64/unwrapped-audit/generated-code.json", + "sha256": "2e921b0a8d0b8be1bc83ece8d54edc08bc8e5c746c765b917f88cd3517ffea92", + "bytes": 11054 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/ordered_cancellation-float64/unwrapped-audit/input-audit.json", + "copy": "evidence/oracle/ordered_cancellation-float64/unwrapped-audit/input-audit.json", + "sha256": "859874145af010d744d285cf471ae9cb7f410e02666dedd15abb189ced0dd22d", + "bytes": 1237 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/ordered_cancellation-float64/unwrapped-audit/queue-audit.json", + "copy": "evidence/oracle/ordered_cancellation-float64/unwrapped-audit/queue-audit.json", + "sha256": "33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7", + "bytes": 371 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/ordered_cancellation-float64/unwrapped-audit/schedule.json", + "copy": "evidence/oracle/ordered_cancellation-float64/unwrapped-audit/schedule.json", + "sha256": "af9f8f7b182f3c780b23e1448888728ad89be2bbaf7ebe5631d6bff7c7ae77db", + "bytes": 1411 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/release_selfloop-float32/case.json", + "copy": "evidence/oracle/release_selfloop-float32/case.json", + "sha256": "fd295fc5ccc133bfa70d2e9f7b4d9ca839b23beb337b5fdd4183be00987c6dd4", + "bytes": 1242 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/release_selfloop-float32/coefficients.json", + "copy": "evidence/oracle/release_selfloop-float32/coefficients.json", + "sha256": "641e4016edb1690746a62aab09485c91852d5862d25fe85dab390121fb21779f", + "bytes": 2335 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/release_selfloop-float32/environment.json", + "copy": "evidence/oracle/release_selfloop-float32/environment.json", + "sha256": "8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6", + "bytes": 352 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/release_selfloop-float32/instrumented/coefficients.json", + "copy": "evidence/oracle/release_selfloop-float32/instrumented/coefficients.json", + "sha256": "641e4016edb1690746a62aab09485c91852d5862d25fe85dab390121fb21779f", + "bytes": 2335 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/release_selfloop-float32/instrumented/compiled-code.json", + "copy": "evidence/oracle/release_selfloop-float32/instrumented/compiled-code.json", + "sha256": "dfbcf815d17465e4c83a54320687e77c3035c5064f6a81a11bffc5ce35ec0dd1", + "bytes": 14949 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/release_selfloop-float32/instrumented/completeness.csv", + "copy": "evidence/oracle/release_selfloop-float32/instrumented/completeness.csv", + "sha256": "c79ddcee44e7786a8805ed8bd4685d8107764e5dff4952b204e5163f8630ce80", + "bytes": 50 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/release_selfloop-float32/instrumented/generated-code.json", + "copy": "evidence/oracle/release_selfloop-float32/instrumented/generated-code.json", + "sha256": "94ba0cc5f884ff7e332d1859286ba39e4bc7fa684546db29088e22a5fb96a14b", + "bytes": 14969 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/release_selfloop-float32/instrumented/input-audit.json", + "copy": "evidence/oracle/release_selfloop-float32/instrumented/input-audit.json", + "sha256": "4047c46214a2c9d06289ed7db728e2f1afa23cb1e1e9437634d4c4f56540d3a2", + "bytes": 1236 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/release_selfloop-float32/instrumented/queue-audit.json", + "copy": "evidence/oracle/release_selfloop-float32/instrumented/queue-audit.json", + "sha256": "40bf803d062804b7bb6ce070743fc805423f873311d8bb453d2cc5db2ea62bb3", + "bytes": 458 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/release_selfloop-float32/instrumented/schedule.json", + "copy": "evidence/oracle/release_selfloop-float32/instrumented/schedule.json", + "sha256": "8d5492b7968694e913d3321b10d5779137045d4689fe50ec50b1ef7637d8fc04", + "bytes": 1984 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/release_selfloop-float32/proxy-validation.json", + "copy": "evidence/oracle/release_selfloop-float32/proxy-validation.json", + "sha256": "87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09", + "bytes": 774 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/release_selfloop-float32/summary.json", + "copy": "evidence/oracle/release_selfloop-float32/summary.json", + "sha256": "979d2a0d15f9d6f746e930fa5c0eb8def666713669026b69140c65687630401e", + "bytes": 581 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/release_selfloop-float32/unwrapped-audit/coefficients.json", + "copy": "evidence/oracle/release_selfloop-float32/unwrapped-audit/coefficients.json", + "sha256": "b31b081bcc455e5a3e29ab3c7094c020e9a4f56f47cbd108bfa12c23abb4f83a", + "bytes": 2335 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/release_selfloop-float32/unwrapped-audit/compiled-code.json", + "copy": "evidence/oracle/release_selfloop-float32/unwrapped-audit/compiled-code.json", + "sha256": "82868f03604ec2a12efea07718960e3bfb1c8152950c3b6bc4fd8e1b1d46cf8d", + "bytes": 14785 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/release_selfloop-float32/unwrapped-audit/completeness.csv", + "copy": "evidence/oracle/release_selfloop-float32/unwrapped-audit/completeness.csv", + "sha256": "c79ddcee44e7786a8805ed8bd4685d8107764e5dff4952b204e5163f8630ce80", + "bytes": 50 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/release_selfloop-float32/unwrapped-audit/generated-code.json", + "copy": "evidence/oracle/release_selfloop-float32/unwrapped-audit/generated-code.json", + "sha256": "7fb472acf561ca1c043f0fc3a46941cdb7846d1ca8df820a15b725ad1f144ed9", + "bytes": 14805 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/release_selfloop-float32/unwrapped-audit/input-audit.json", + "copy": "evidence/oracle/release_selfloop-float32/unwrapped-audit/input-audit.json", + "sha256": "35a01e501ae88e4350583ba961a0e67e3be2c486c2fc9c2c49905924e2bc004f", + "bytes": 1237 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/release_selfloop-float32/unwrapped-audit/queue-audit.json", + "copy": "evidence/oracle/release_selfloop-float32/unwrapped-audit/queue-audit.json", + "sha256": "33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7", + "bytes": 371 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/release_selfloop-float32/unwrapped-audit/schedule.json", + "copy": "evidence/oracle/release_selfloop-float32/unwrapped-audit/schedule.json", + "sha256": "42679bfcc102a0ec20fafe7fdf9cc82b02a0b8809931a49502ac6efd669fc9cd", + "bytes": 1807 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/release_selfloop-float64/case.json", + "copy": "evidence/oracle/release_selfloop-float64/case.json", + "sha256": "6a7d03115b6dbff20bcca4708f5ffea8de006e9f091bac804e8f1d2db168220c", + "bytes": 1242 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/release_selfloop-float64/coefficients.json", + "copy": "evidence/oracle/release_selfloop-float64/coefficients.json", + "sha256": "5c7757cd44e4f994f9d1496a3533ffc3ae993d3f9327764e57183e4167a02ef6", + "bytes": 2335 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/release_selfloop-float64/environment.json", + "copy": "evidence/oracle/release_selfloop-float64/environment.json", + "sha256": "8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6", + "bytes": 352 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/release_selfloop-float64/instrumented/coefficients.json", + "copy": "evidence/oracle/release_selfloop-float64/instrumented/coefficients.json", + "sha256": "5c7757cd44e4f994f9d1496a3533ffc3ae993d3f9327764e57183e4167a02ef6", + "bytes": 2335 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/release_selfloop-float64/instrumented/compiled-code.json", + "copy": "evidence/oracle/release_selfloop-float64/instrumented/compiled-code.json", + "sha256": "dfbcf815d17465e4c83a54320687e77c3035c5064f6a81a11bffc5ce35ec0dd1", + "bytes": 14949 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/release_selfloop-float64/instrumented/completeness.csv", + "copy": "evidence/oracle/release_selfloop-float64/instrumented/completeness.csv", + "sha256": "c79ddcee44e7786a8805ed8bd4685d8107764e5dff4952b204e5163f8630ce80", + "bytes": 50 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/release_selfloop-float64/instrumented/generated-code.json", + "copy": "evidence/oracle/release_selfloop-float64/instrumented/generated-code.json", + "sha256": "0d51e9ee6cad7494f92e4f90c362be175b66388d4bed51c1ef14a7aba6822eee", + "bytes": 14969 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/release_selfloop-float64/instrumented/input-audit.json", + "copy": "evidence/oracle/release_selfloop-float64/instrumented/input-audit.json", + "sha256": "adcc4735605e955cc3f82c52e078c3aa0ed6a5f6134a536431efa5595af0b553", + "bytes": 1236 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/release_selfloop-float64/instrumented/queue-audit.json", + "copy": "evidence/oracle/release_selfloop-float64/instrumented/queue-audit.json", + "sha256": "d1b7304bec0a1b2ffd069cc04b16aa05c19aff71104ccd1fa6324ac80683c6c6", + "bytes": 458 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/release_selfloop-float64/instrumented/schedule.json", + "copy": "evidence/oracle/release_selfloop-float64/instrumented/schedule.json", + "sha256": "8d5492b7968694e913d3321b10d5779137045d4689fe50ec50b1ef7637d8fc04", + "bytes": 1984 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/release_selfloop-float64/proxy-validation.json", + "copy": "evidence/oracle/release_selfloop-float64/proxy-validation.json", + "sha256": "87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09", + "bytes": 774 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/release_selfloop-float64/summary.json", + "copy": "evidence/oracle/release_selfloop-float64/summary.json", + "sha256": "4312b4466d22b9ea9d4e797dee7ffece32356d0483a12e6886df48a4b68a83a9", + "bytes": 581 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/release_selfloop-float64/unwrapped-audit/coefficients.json", + "copy": "evidence/oracle/release_selfloop-float64/unwrapped-audit/coefficients.json", + "sha256": "641e4016edb1690746a62aab09485c91852d5862d25fe85dab390121fb21779f", + "bytes": 2335 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/release_selfloop-float64/unwrapped-audit/compiled-code.json", + "copy": "evidence/oracle/release_selfloop-float64/unwrapped-audit/compiled-code.json", + "sha256": "82868f03604ec2a12efea07718960e3bfb1c8152950c3b6bc4fd8e1b1d46cf8d", + "bytes": 14785 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/release_selfloop-float64/unwrapped-audit/completeness.csv", + "copy": "evidence/oracle/release_selfloop-float64/unwrapped-audit/completeness.csv", + "sha256": "c79ddcee44e7786a8805ed8bd4685d8107764e5dff4952b204e5163f8630ce80", + "bytes": 50 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/release_selfloop-float64/unwrapped-audit/generated-code.json", + "copy": "evidence/oracle/release_selfloop-float64/unwrapped-audit/generated-code.json", + "sha256": "59f811addd08ca9edd87e10f52560ea5c7fffcfcb3fe809b2a35222b73788586", + "bytes": 14805 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/release_selfloop-float64/unwrapped-audit/input-audit.json", + "copy": "evidence/oracle/release_selfloop-float64/unwrapped-audit/input-audit.json", + "sha256": "149bcf4eccdde513b08be26169d1fb502a65436ec56b8bdabb0c36be4bab1949", + "bytes": 1237 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/release_selfloop-float64/unwrapped-audit/queue-audit.json", + "copy": "evidence/oracle/release_selfloop-float64/unwrapped-audit/queue-audit.json", + "sha256": "33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7", + "bytes": 371 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/release_selfloop-float64/unwrapped-audit/schedule.json", + "copy": "evidence/oracle/release_selfloop-float64/unwrapped-audit/schedule.json", + "sha256": "42679bfcc102a0ec20fafe7fdf9cc82b02a0b8809931a49502ac6efd669fc9cd", + "bytes": 1807 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/signed_random-float32/case.json", + "copy": "evidence/oracle/signed_random-float32/case.json", + "sha256": "41ffb65d2bb6c0cbce029a2bcc9c13a3d9cdd26bd1d2c38cad0f02d71ca33ad9", + "bytes": 1275 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/signed_random-float32/coefficients.json", + "copy": "evidence/oracle/signed_random-float32/coefficients.json", + "sha256": "b31b081bcc455e5a3e29ab3c7094c020e9a4f56f47cbd108bfa12c23abb4f83a", + "bytes": 2335 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/signed_random-float32/environment.json", + "copy": "evidence/oracle/signed_random-float32/environment.json", + "sha256": "8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6", + "bytes": 352 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/signed_random-float32/instrumented/coefficients.json", + "copy": "evidence/oracle/signed_random-float32/instrumented/coefficients.json", + "sha256": "b31b081bcc455e5a3e29ab3c7094c020e9a4f56f47cbd108bfa12c23abb4f83a", + "bytes": 2335 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/signed_random-float32/instrumented/compiled-code.json", + "copy": "evidence/oracle/signed_random-float32/instrumented/compiled-code.json", + "sha256": "dfbcf815d17465e4c83a54320687e77c3035c5064f6a81a11bffc5ce35ec0dd1", + "bytes": 14949 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/signed_random-float32/instrumented/completeness.csv", + "copy": "evidence/oracle/signed_random-float32/instrumented/completeness.csv", + "sha256": "847d1cf9168f7309567f41a98b9258003eb1174f46d3b61f19fab79c8a629c4f", + "bytes": 964 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/signed_random-float32/instrumented/generated-code.json", + "copy": "evidence/oracle/signed_random-float32/instrumented/generated-code.json", + "sha256": "a1fc01a10b78668091c0e85a41fe5e090b886631237f155dc7e2203f12a86a2f", + "bytes": 14969 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/signed_random-float32/instrumented/input-audit.json", + "copy": "evidence/oracle/signed_random-float32/instrumented/input-audit.json", + "sha256": "1e75500b3d33a04cb3ebdb8978dec818f5c609e3528ed896b76225b461bed4c8", + "bytes": 1236 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/signed_random-float32/instrumented/queue-audit.json", + "copy": "evidence/oracle/signed_random-float32/instrumented/queue-audit.json", + "sha256": "632d60b3927ca573c01d427658b25d3a7c5b8dab6a95957e29ea5512ccf40c45", + "bytes": 463 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/signed_random-float32/instrumented/schedule.json", + "copy": "evidence/oracle/signed_random-float32/instrumented/schedule.json", + "sha256": "8d5492b7968694e913d3321b10d5779137045d4689fe50ec50b1ef7637d8fc04", + "bytes": 1984 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/signed_random-float32/proxy-validation.json", + "copy": "evidence/oracle/signed_random-float32/proxy-validation.json", + "sha256": "87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09", + "bytes": 774 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/signed_random-float32/summary.json", + "copy": "evidence/oracle/signed_random-float32/summary.json", + "sha256": "1b09126a1c80ec7e1239ebbc5ba7e8654644e091a9f4d1f86ef5fe1bea7942c1", + "bytes": 583 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/signed_random-float32/unwrapped-audit/coefficients.json", + "copy": "evidence/oracle/signed_random-float32/unwrapped-audit/coefficients.json", + "sha256": "d87699f97f7e1c60379593c077990e8267d55c01a4b87c62a754764b3c67edde", + "bytes": 2335 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/signed_random-float32/unwrapped-audit/compiled-code.json", + "copy": "evidence/oracle/signed_random-float32/unwrapped-audit/compiled-code.json", + "sha256": "82868f03604ec2a12efea07718960e3bfb1c8152950c3b6bc4fd8e1b1d46cf8d", + "bytes": 14785 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/signed_random-float32/unwrapped-audit/completeness.csv", + "copy": "evidence/oracle/signed_random-float32/unwrapped-audit/completeness.csv", + "sha256": "847d1cf9168f7309567f41a98b9258003eb1174f46d3b61f19fab79c8a629c4f", + "bytes": 964 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/signed_random-float32/unwrapped-audit/generated-code.json", + "copy": "evidence/oracle/signed_random-float32/unwrapped-audit/generated-code.json", + "sha256": "4392e7f76087a91d08e8143261cb912d5489dcccfb0bd8b2f6edb9759f24b119", + "bytes": 14805 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/signed_random-float32/unwrapped-audit/input-audit.json", + "copy": "evidence/oracle/signed_random-float32/unwrapped-audit/input-audit.json", + "sha256": "55acf52e153a3c1427954dab23d11d2b5de39b842d56b302b744f40b5300093f", + "bytes": 1237 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/signed_random-float32/unwrapped-audit/queue-audit.json", + "copy": "evidence/oracle/signed_random-float32/unwrapped-audit/queue-audit.json", + "sha256": "33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7", + "bytes": 371 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/signed_random-float32/unwrapped-audit/schedule.json", + "copy": "evidence/oracle/signed_random-float32/unwrapped-audit/schedule.json", + "sha256": "42679bfcc102a0ec20fafe7fdf9cc82b02a0b8809931a49502ac6efd669fc9cd", + "bytes": 1807 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/signed_random-float64/case.json", + "copy": "evidence/oracle/signed_random-float64/case.json", + "sha256": "3a998345bf8746c0e2229574005dc64647a9911ed54e3db709d01e0c5400db50", + "bytes": 1275 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/signed_random-float64/coefficients.json", + "copy": "evidence/oracle/signed_random-float64/coefficients.json", + "sha256": "18c982eeea655a6efb2ab684941ed13dcbea4cf8bf5add0bde564e1991c46918", + "bytes": 2335 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/signed_random-float64/environment.json", + "copy": "evidence/oracle/signed_random-float64/environment.json", + "sha256": "8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6", + "bytes": 352 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/signed_random-float64/instrumented/coefficients.json", + "copy": "evidence/oracle/signed_random-float64/instrumented/coefficients.json", + "sha256": "18c982eeea655a6efb2ab684941ed13dcbea4cf8bf5add0bde564e1991c46918", + "bytes": 2335 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/signed_random-float64/instrumented/compiled-code.json", + "copy": "evidence/oracle/signed_random-float64/instrumented/compiled-code.json", + "sha256": "dfbcf815d17465e4c83a54320687e77c3035c5064f6a81a11bffc5ce35ec0dd1", + "bytes": 14949 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/signed_random-float64/instrumented/completeness.csv", + "copy": "evidence/oracle/signed_random-float64/instrumented/completeness.csv", + "sha256": "847d1cf9168f7309567f41a98b9258003eb1174f46d3b61f19fab79c8a629c4f", + "bytes": 964 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/signed_random-float64/instrumented/generated-code.json", + "copy": "evidence/oracle/signed_random-float64/instrumented/generated-code.json", + "sha256": "016c7778c92643344b85c0d4a02c4a3596e8fd96bef364b074d3bca217268b40", + "bytes": 14969 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/signed_random-float64/instrumented/input-audit.json", + "copy": "evidence/oracle/signed_random-float64/instrumented/input-audit.json", + "sha256": "5c0283e72857d6b597fae4b7ae6e170a49b578c249ab61297b0abcb3a3dd08d2", + "bytes": 1236 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/signed_random-float64/instrumented/queue-audit.json", + "copy": "evidence/oracle/signed_random-float64/instrumented/queue-audit.json", + "sha256": "20a4213741e9ef87ab021f779e259129a49e89708d44c74717dc284b90264c52", + "bytes": 463 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/signed_random-float64/instrumented/schedule.json", + "copy": "evidence/oracle/signed_random-float64/instrumented/schedule.json", + "sha256": "8d5492b7968694e913d3321b10d5779137045d4689fe50ec50b1ef7637d8fc04", + "bytes": 1984 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/signed_random-float64/proxy-validation.json", + "copy": "evidence/oracle/signed_random-float64/proxy-validation.json", + "sha256": "87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09", + "bytes": 774 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/signed_random-float64/summary.json", + "copy": "evidence/oracle/signed_random-float64/summary.json", + "sha256": "c6ab83e4fe4b7758f74af24407a1df22f1283115d561e410c4ffda58e4fcc0d7", + "bytes": 583 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/signed_random-float64/unwrapped-audit/coefficients.json", + "copy": "evidence/oracle/signed_random-float64/unwrapped-audit/coefficients.json", + "sha256": "d87699f97f7e1c60379593c077990e8267d55c01a4b87c62a754764b3c67edde", + "bytes": 2335 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/signed_random-float64/unwrapped-audit/compiled-code.json", + "copy": "evidence/oracle/signed_random-float64/unwrapped-audit/compiled-code.json", + "sha256": "82868f03604ec2a12efea07718960e3bfb1c8152950c3b6bc4fd8e1b1d46cf8d", + "bytes": 14785 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/signed_random-float64/unwrapped-audit/completeness.csv", + "copy": "evidence/oracle/signed_random-float64/unwrapped-audit/completeness.csv", + "sha256": "847d1cf9168f7309567f41a98b9258003eb1174f46d3b61f19fab79c8a629c4f", + "bytes": 964 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/signed_random-float64/unwrapped-audit/generated-code.json", + "copy": "evidence/oracle/signed_random-float64/unwrapped-audit/generated-code.json", + "sha256": "89c9d663e1a33f36044a05d58ca417669c3d4a8746b2580127e75778a991711d", + "bytes": 14805 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/signed_random-float64/unwrapped-audit/input-audit.json", + "copy": "evidence/oracle/signed_random-float64/unwrapped-audit/input-audit.json", + "sha256": "0bbea9b06c74e659398f117e2a3d9c444d3e16fcf8ce9c2042cdc09d99318e4c", + "bytes": 1237 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/signed_random-float64/unwrapped-audit/queue-audit.json", + "copy": "evidence/oracle/signed_random-float64/unwrapped-audit/queue-audit.json", + "sha256": "33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7", + "bytes": 371 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/signed_random-float64/unwrapped-audit/schedule.json", + "copy": "evidence/oracle/signed_random-float64/unwrapped-audit/schedule.json", + "sha256": "42679bfcc102a0ec20fafe7fdf9cc82b02a0b8809931a49502ac6efd669fc9cd", + "bytes": 1807 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/threshold_rounding-float32/case.json", + "copy": "evidence/oracle/threshold_rounding-float32/case.json", + "sha256": "a5eb5baa4ca36263c75f80c348dd444836241cd270598ca660a9a4176557eb8c", + "bytes": 1281 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/threshold_rounding-float32/coefficients.json", + "copy": "evidence/oracle/threshold_rounding-float32/coefficients.json", + "sha256": "c463f321c25ce79fbb95756ca3fcc8b4b9e2b36a31ce074439b6a45d0641fcff", + "bytes": 2335 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/threshold_rounding-float32/environment.json", + "copy": "evidence/oracle/threshold_rounding-float32/environment.json", + "sha256": "8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6", + "bytes": 352 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/threshold_rounding-float32/instrumented/coefficients.json", + "copy": "evidence/oracle/threshold_rounding-float32/instrumented/coefficients.json", + "sha256": "c463f321c25ce79fbb95756ca3fcc8b4b9e2b36a31ce074439b6a45d0641fcff", + "bytes": 2335 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/threshold_rounding-float32/instrumented/compiled-code.json", + "copy": "evidence/oracle/threshold_rounding-float32/instrumented/compiled-code.json", + "sha256": "d37bbac320791543bdc13106f71c8aab50c345ca93aeee06d49ce26131e5e198", + "bytes": 11202 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/threshold_rounding-float32/instrumented/completeness.csv", + "copy": "evidence/oracle/threshold_rounding-float32/instrumented/completeness.csv", + "sha256": "c391cd11c54130ce647d85f3b175256f1bfc2d5b50601ede4231cb7038cea401", + "bytes": 81 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/threshold_rounding-float32/instrumented/generated-code.json", + "copy": "evidence/oracle/threshold_rounding-float32/instrumented/generated-code.json", + "sha256": "80aba5afd83fd57e943ad930e58d25290488f32c47d1cfc6d807130462e0b9ee", + "bytes": 11218 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/threshold_rounding-float32/instrumented/input-audit.json", + "copy": "evidence/oracle/threshold_rounding-float32/instrumented/input-audit.json", + "sha256": "61743ad6576a8d4d0dab49f2989cdf4e33bd0c6dc6205411b4b9ce446b671150", + "bytes": 1236 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/threshold_rounding-float32/instrumented/queue-audit.json", + "copy": "evidence/oracle/threshold_rounding-float32/instrumented/queue-audit.json", + "sha256": "42db107c806b29780165845cf05e63f4e300b6c2352fa933454d5b7eef9d0f86", + "bytes": 457 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/threshold_rounding-float32/instrumented/schedule.json", + "copy": "evidence/oracle/threshold_rounding-float32/instrumented/schedule.json", + "sha256": "0db2d5f73709934bf7a91db2908a8dc3301614d09490769bf369aad96ee4f0fb", + "bytes": 1574 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/threshold_rounding-float32/proxy-validation.json", + "copy": "evidence/oracle/threshold_rounding-float32/proxy-validation.json", + "sha256": "87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09", + "bytes": 774 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/threshold_rounding-float32/summary.json", + "copy": "evidence/oracle/threshold_rounding-float32/summary.json", + "sha256": "ed9025646a6f6cbfcdb542dfd4ad700b68f3ddf6e4dca4156843b7c4658a0115", + "bytes": 587 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/threshold_rounding-float32/unwrapped-audit/coefficients.json", + "copy": "evidence/oracle/threshold_rounding-float32/unwrapped-audit/coefficients.json", + "sha256": "e034e68f3a14e480bbef791cef03d2ebb4f654675663035c0788c8d4c4fe00e2", + "bytes": 2335 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/threshold_rounding-float32/unwrapped-audit/compiled-code.json", + "copy": "evidence/oracle/threshold_rounding-float32/unwrapped-audit/compiled-code.json", + "sha256": "9ef07e82240727c9761386ecdd054475050156677e9b0a3a6bc37b845c1f602c", + "bytes": 11038 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/threshold_rounding-float32/unwrapped-audit/completeness.csv", + "copy": "evidence/oracle/threshold_rounding-float32/unwrapped-audit/completeness.csv", + "sha256": "c391cd11c54130ce647d85f3b175256f1bfc2d5b50601ede4231cb7038cea401", + "bytes": 81 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/threshold_rounding-float32/unwrapped-audit/generated-code.json", + "copy": "evidence/oracle/threshold_rounding-float32/unwrapped-audit/generated-code.json", + "sha256": "5dba98727c043059d343a65c895990307c5e34cfe1d17d7f6a439a21cba5bf7c", + "bytes": 11054 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/threshold_rounding-float32/unwrapped-audit/input-audit.json", + "copy": "evidence/oracle/threshold_rounding-float32/unwrapped-audit/input-audit.json", + "sha256": "9ff3841577d5755a5108c77147464655b07fb9fba2879d647cd0c94f96183548", + "bytes": 1237 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/threshold_rounding-float32/unwrapped-audit/queue-audit.json", + "copy": "evidence/oracle/threshold_rounding-float32/unwrapped-audit/queue-audit.json", + "sha256": "33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7", + "bytes": 371 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/threshold_rounding-float32/unwrapped-audit/schedule.json", + "copy": "evidence/oracle/threshold_rounding-float32/unwrapped-audit/schedule.json", + "sha256": "af9f8f7b182f3c780b23e1448888728ad89be2bbaf7ebe5631d6bff7c7ae77db", + "bytes": 1411 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/threshold_rounding-float64/case.json", + "copy": "evidence/oracle/threshold_rounding-float64/case.json", + "sha256": "f2d7a8d5a067f0356ce106def5e8e1cde709e080837cfd87844cecfc6c7df884", + "bytes": 1281 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/threshold_rounding-float64/coefficients.json", + "copy": "evidence/oracle/threshold_rounding-float64/coefficients.json", + "sha256": "d87699f97f7e1c60379593c077990e8267d55c01a4b87c62a754764b3c67edde", + "bytes": 2335 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/threshold_rounding-float64/environment.json", + "copy": "evidence/oracle/threshold_rounding-float64/environment.json", + "sha256": "8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6", + "bytes": 352 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/threshold_rounding-float64/instrumented/coefficients.json", + "copy": "evidence/oracle/threshold_rounding-float64/instrumented/coefficients.json", + "sha256": "d87699f97f7e1c60379593c077990e8267d55c01a4b87c62a754764b3c67edde", + "bytes": 2335 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/threshold_rounding-float64/instrumented/compiled-code.json", + "copy": "evidence/oracle/threshold_rounding-float64/instrumented/compiled-code.json", + "sha256": "d37bbac320791543bdc13106f71c8aab50c345ca93aeee06d49ce26131e5e198", + "bytes": 11202 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/threshold_rounding-float64/instrumented/completeness.csv", + "copy": "evidence/oracle/threshold_rounding-float64/instrumented/completeness.csv", + "sha256": "c391cd11c54130ce647d85f3b175256f1bfc2d5b50601ede4231cb7038cea401", + "bytes": 81 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/threshold_rounding-float64/instrumented/generated-code.json", + "copy": "evidence/oracle/threshold_rounding-float64/instrumented/generated-code.json", + "sha256": "f8855c24be8282f84e30d36e1d94c37389f0fb3a65537b121407311c25596f6b", + "bytes": 11218 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/threshold_rounding-float64/instrumented/input-audit.json", + "copy": "evidence/oracle/threshold_rounding-float64/instrumented/input-audit.json", + "sha256": "8e10d2ac7488b62aacd4de02d4a0c16605b7ea3767c5c14678ce02919f0b24f0", + "bytes": 1236 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/threshold_rounding-float64/instrumented/queue-audit.json", + "copy": "evidence/oracle/threshold_rounding-float64/instrumented/queue-audit.json", + "sha256": "242f188267ccd2c787842ebb71e00d0eeac1c05abfb60beddc88f1ce629d46ba", + "bytes": 457 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/threshold_rounding-float64/instrumented/schedule.json", + "copy": "evidence/oracle/threshold_rounding-float64/instrumented/schedule.json", + "sha256": "0db2d5f73709934bf7a91db2908a8dc3301614d09490769bf369aad96ee4f0fb", + "bytes": 1574 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/threshold_rounding-float64/proxy-validation.json", + "copy": "evidence/oracle/threshold_rounding-float64/proxy-validation.json", + "sha256": "87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09", + "bytes": 774 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/threshold_rounding-float64/summary.json", + "copy": "evidence/oracle/threshold_rounding-float64/summary.json", + "sha256": "4f5705946624e474f686ce2ec300cbc743b4cf4984281bf0c28394d8af2fd9ad", + "bytes": 587 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/threshold_rounding-float64/unwrapped-audit/coefficients.json", + "copy": "evidence/oracle/threshold_rounding-float64/unwrapped-audit/coefficients.json", + "sha256": "c463f321c25ce79fbb95756ca3fcc8b4b9e2b36a31ce074439b6a45d0641fcff", + "bytes": 2335 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/threshold_rounding-float64/unwrapped-audit/compiled-code.json", + "copy": "evidence/oracle/threshold_rounding-float64/unwrapped-audit/compiled-code.json", + "sha256": "9ef07e82240727c9761386ecdd054475050156677e9b0a3a6bc37b845c1f602c", + "bytes": 11038 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/threshold_rounding-float64/unwrapped-audit/completeness.csv", + "copy": "evidence/oracle/threshold_rounding-float64/unwrapped-audit/completeness.csv", + "sha256": "c391cd11c54130ce647d85f3b175256f1bfc2d5b50601ede4231cb7038cea401", + "bytes": 81 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/threshold_rounding-float64/unwrapped-audit/generated-code.json", + "copy": "evidence/oracle/threshold_rounding-float64/unwrapped-audit/generated-code.json", + "sha256": "679659ac5f0f6f82d0f7e130c37d640b5ffc22211191cdf56c350929cf539c58", + "bytes": 11054 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/threshold_rounding-float64/unwrapped-audit/input-audit.json", + "copy": "evidence/oracle/threshold_rounding-float64/unwrapped-audit/input-audit.json", + "sha256": "b3a74657044ee0f3dbc4190b453dc4b8d6615f9be27d94141075de1e18095fa2", + "bytes": 1237 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/threshold_rounding-float64/unwrapped-audit/queue-audit.json", + "copy": "evidence/oracle/threshold_rounding-float64/unwrapped-audit/queue-audit.json", + "sha256": "33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7", + "bytes": 371 + }, + { + "source": "experiments/phase4ae-author-runtime/oracle/threshold_rounding-float64/unwrapped-audit/schedule.json", + "copy": "evidence/oracle/threshold_rounding-float64/unwrapped-audit/schedule.json", + "sha256": "af9f8f7b182f3c780b23e1448888728ad89be2bbaf7ebe5631d6bff7c7ae77db", + "bytes": 1411 + }, + { + "source": "experiments/phase4ae-author-runtime/protocol/case-hashes.json", + "copy": "evidence/protocol/case-hashes.json", + "sha256": "3b0095dd04f6467323150497ac84c4d375a83f9ed3130250955eb65f8d406063", + "bytes": 3883 + }, + { + "source": "experiments/phase4ae-author-runtime/protocol/preregistered.json", + "copy": "evidence/protocol/preregistered.json", + "sha256": "f2cbcbf0dd85a61a7267a7567332b00f162d42e69d655792c1bf980d3f1b7c90", + "bytes": 3395 + }, + { + "source": "experiments/phase4ae-author-runtime/regression/frozen-five.json", + "copy": "evidence/regression/frozen-five.json", + "sha256": "863d7c13334f75e0dd270f1bb870c4a2d86dbf2ff7324a4146560509aab1abd0", + "bytes": 1282 + }, + { + "source": "experiments/phase4ae-author-runtime/regression/gpu-complete.json", + "copy": "evidence/regression/gpu-complete.json", + "sha256": "9ac57b06217a4d7d75a36a8611df398381b4313772ba39b6af0b92a0dd2cd073", + "bytes": 101768 + }, + { + "source": "experiments/phase4ae-author-runtime/regression/old-integrity-after.json", + "copy": "evidence/regression/old-integrity-after.json", + "sha256": "c4dba5e26a96277f128887d20734705675507395755747f4af1e8a36dc36a538", + "bytes": 3130 + }, + { + "source": "experiments/phase4ae-author-runtime/regression/old-integrity-before.json", + "copy": "evidence/regression/old-integrity-before.json", + "sha256": "c4dba5e26a96277f128887d20734705675507395755747f4af1e8a36dc36a538", + "bytes": 3130 + }, + { + "source": "experiments/phase4ae-author-runtime/regression/oracle-complete.json", + "copy": "evidence/regression/oracle-complete.json", + "sha256": "58f6d1c1afe4f96a82a247ae46d8a987d74cc6f59a79eded650bf24ca2a18751", + "bytes": 2330 + }, + { + "source": "experiments/phase4ae-author-runtime/manifest.json", + "copy": "evidence/manifest.json", + "sha256": "a86caca4ecbd96c2b7cf24371b28f80f37170fa8769cdd9a31c822434be1eef5", + "bytes": 171109 + }, + { + "source": "experiments/phase4ae-author-runtime/checksums.sha256", + "copy": "evidence/checksums.sha256", + "sha256": "7bd84b8365953964b24684830e1fd97fca04bef8f8c051dcad3ff95633a1ae82", + "bytes": 108789 + } +] diff --git a/registry/phase4ae-author-runtime/evidence/REPORT.md b/registry/phase4ae-author-runtime/evidence/REPORT.md new file mode 100644 index 0000000..86a4318 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/REPORT.md @@ -0,0 +1,37 @@ +# Phase 4AE GPU作者语义数值门禁 + +状态：`PASS-ISOLATED-GPU-NUMERICAL-GATE`。 + +仅验证固定小网络，尚未证明全脑等价、生物学正确或学习可用。未训练、未修改冻结输入或旧模型。 + +| case | precision | events | max V/g error V | exact whole history | pass | +|---|---|---:|---:|---|---| +| fanin_bursts | float64 | 1539 | 0.0 | True | True | +| fanin_bursts | float32 | 1539 | 0.0 | True | True | +| highest_indegree | float64 | 101 | 0.0 | True | True | +| highest_indegree | float32 | 101 | 0.0 | True | True | +| mixed_high_indegree | float64 | 106 | 0.0 | True | True | +| mixed_high_indegree | float32 | 106 | 0.0 | True | True | +| motif_feedforward | float64 | 3 | 0.0 | True | True | +| motif_feedforward | float32 | 3 | 0.0 | True | True | +| motif_five | float64 | 60 | 0.0 | True | True | +| motif_five | float32 | 60 | 0.0 | True | True | +| motif_no_input | float64 | 0 | 0.0 | True | True | +| motif_no_input | float32 | 0 | 0.0 | True | True | +| motif_pair | float64 | 22 | 0.0 | True | True | +| motif_pair | float32 | 22 | 0.0 | True | True | +| motif_trio | float64 | 45 | 0.0 | True | True | +| motif_trio | float32 | 45 | 0.0 | True | True | +| ordered_cancellation | float64 | 32 | 0.0 | True | True | +| ordered_cancellation | float32 | 32 | 0.0 | True | True | +| release_selfloop | float64 | 8 | 0.0 | True | True | +| release_selfloop | float32 | 8 | 0.0 | True | True | +| signed_random | float64 | 400 | 0.0 | True | True | +| signed_random | float32 | 400 | 0.0 | True | True | +| threshold_rounding | float64 | 4 | 0.0 | True | True | +| threshold_rounding | float32 | 3 | 0.0 | True | True | + +每项GPU执行3次，检查原始事件、输入请求实际送达、逐目标到达顺序及guard、计数、不应期和完整状态。 +大整数、随机图、重复/零边属于纯数值夹具，不是新增MaleCNS连接或生理假设。真实子图使用全部既有诱导边、原contact count与冻结transmitter sign。 +原始冻结完整性与旧五组全脑deterministic-v2回归再次核验；该旧回归PASS不等于新动力学全脑PASS。 +没有根据活动强度选择参数；尚须短时全图对照及嗅觉信息保持测试。 diff --git a/registry/phase4ae-author-runtime/evidence/audit/final-status.json b/registry/phase4ae-author-runtime/evidence/audit/final-status.json new file mode 100644 index 0000000..1caad70 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/audit/final-status.json @@ -0,0 +1,11 @@ +{ + "status": "PASS-ISOLATED-GPU-NUMERICAL-GATE", + "pass_all": true, + "cases": 12, + "gpu_runs": 72, + "full_brain_author_equivalence": false, + "conditioning": false, + "learning_achieved": false, + "candidate_generated": false, + "next_gate": "Short full-graph same-precision author comparison, then fixed DoOR CAL only if numerical gates pass" +} diff --git a/registry/phase4ae-author-runtime/evidence/cases/fanin_bursts/spec.json b/registry/phase4ae-author-runtime/evidence/cases/fanin_bursts/spec.json new file mode 100644 index 0000000..e1dcaa9 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/cases/fanin_bursts/spec.json @@ -0,0 +1,21 @@ +{ + "name": "fanin_bursts", + "dt_ms": 0.1, + "steps": 600, + "duration_ms": 60.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 + }, + "description": "256-source signed fan-in, labelled duplicate/loop; refractory requests and external writes.", + "trace_queue": true, + "validate_queue_proxy": true, + "selection": null +} diff --git a/registry/phase4ae-author-runtime/evidence/cases/highest_indegree/anatomical-edges.csv b/registry/phase4ae-author-runtime/evidence/cases/highest_indegree/anatomical-edges.csv new file mode 100644 index 0000000..fe56f97 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/cases/highest_indegree/anatomical-edges.csv @@ -0,0 +1,321 @@ +edge_id,source_neuron_idx,target_neuron_idx,raw_count,source_sign,signed_raw +4897,5,21,2,-1,-2 +4914,5,775,12,-1,-12 +4919,5,1572,3,-1,-3 +6148,5,52515,15,-1,-15 +6240,5,57252,9,-1,-9 +6305,5,59937,10,-1,-10 +6310,5,60155,17,-1,-17 +6320,5,60450,9,-1,-9 +6329,5,60737,11,-1,-11 +6351,5,61164,12,-1,-12 +6354,5,61387,9,-1,-9 +6368,5,61721,13,-1,-13 +6371,5,61804,11,-1,-11 +6378,5,61941,9,-1,-9 +6396,5,62257,12,-1,-12 +6412,5,62700,12,-1,-12 +6415,5,62734,8,-1,-8 +6421,5,62795,9,-1,-9 +6428,5,62888,12,-1,-12 +6435,5,63041,12,-1,-12 +6437,5,63106,9,-1,-9 +6440,5,63173,14,-1,-14 +6448,5,63287,7,-1,-7 +6452,5,63339,10,-1,-10 +6491,5,63918,13,-1,-13 +6505,5,64210,13,-1,-13 +6508,5,64233,9,-1,-9 +6521,5,64443,11,-1,-11 +6529,5,64514,14,-1,-14 +6550,5,65001,14,-1,-14 +6568,5,65235,5,-1,-5 +6569,5,65262,12,-1,-12 +6574,5,65374,13,-1,-13 +6584,5,65565,17,-1,-17 +6598,5,65691,10,-1,-10 +6602,5,65742,7,-1,-7 +6617,5,66003,12,-1,-12 +6626,5,66127,15,-1,-15 +6636,5,66225,10,-1,-10 +6637,5,66237,9,-1,-9 +6660,5,66541,8,-1,-8 +6666,5,66598,14,-1,-14 +6693,5,66843,11,-1,-11 +6705,5,66958,15,-1,-15 +6714,5,67072,14,-1,-14 +6722,5,67135,13,-1,-13 +6738,5,67241,15,-1,-15 +6743,5,67284,13,-1,-13 +6749,5,67324,6,-1,-6 +6754,5,67373,16,-1,-16 +6765,5,67453,15,-1,-15 +6770,5,67483,16,-1,-16 +6776,5,67537,12,-1,-12 +6783,5,67594,11,-1,-11 +6832,5,68056,10,-1,-10 +6836,5,68074,14,-1,-14 +6854,5,68192,11,-1,-11 +6856,5,68199,11,-1,-11 +6872,5,68355,9,-1,-9 +6894,5,68543,16,-1,-16 +6904,5,68617,10,-1,-10 +6910,5,68656,16,-1,-16 +6934,5,68838,9,-1,-9 +6937,5,68856,11,-1,-11 +6938,5,68869,7,-1,-7 +6970,5,69139,16,-1,-16 +7007,5,69415,5,-1,-5 +7019,5,69516,6,-1,-6 +7022,5,69540,11,-1,-11 +7064,5,69809,14,-1,-14 +7073,5,69860,10,-1,-10 +7084,5,69966,9,-1,-9 +7087,5,69982,7,-1,-7 +7092,5,70036,13,-1,-13 +7120,5,70202,14,-1,-14 +7139,5,70316,17,-1,-17 +7169,5,70561,11,-1,-11 +7177,5,70626,12,-1,-12 +7195,5,70744,12,-1,-12 +7201,5,70783,7,-1,-7 +7229,5,70897,13,-1,-13 +7240,5,70977,16,-1,-16 +7242,5,70995,6,-1,-6 +7252,5,71060,9,-1,-9 +7270,5,71120,10,-1,-10 +7280,5,71215,14,-1,-14 +7292,5,71267,15,-1,-15 +7303,5,71346,13,-1,-13 +7314,5,71440,9,-1,-9 +7318,5,71456,15,-1,-15 +7359,5,71738,6,-1,-6 +7406,5,72060,13,-1,-13 +7429,5,72219,7,-1,-7 +7452,5,72322,15,-1,-15 +7457,5,72365,8,-1,-8 +7473,5,72473,22,-1,-22 +7475,5,72485,12,-1,-12 +7492,5,72578,6,-1,-6 +7569,5,73026,6,-1,-6 +7602,5,73221,15,-1,-15 +7657,5,73544,15,-1,-15 +7675,5,73653,9,-1,-9 +7719,5,73903,13,-1,-13 +7843,5,74495,7,-1,-7 +7900,5,74818,10,-1,-10 +7930,5,74995,12,-1,-12 +8109,5,75925,13,-1,-13 +8304,5,76961,13,-1,-13 +8331,5,77090,17,-1,-17 +8376,5,77291,11,-1,-11 +8414,5,77444,12,-1,-12 +8626,5,78506,8,-1,-8 +8637,5,78574,14,-1,-14 +9134,5,80691,10,-1,-10 +10206,5,85419,12,-1,-12 +11736,5,91986,12,-1,-12 +12743,5,97175,13,-1,-13 +12956,5,98515,13,-1,-13 +13400,5,101566,15,-1,-15 +13479,5,102237,13,-1,-13 +13760,5,104598,12,-1,-12 +13827,5,105190,9,-1,-9 +13831,5,105260,13,-1,-13 +13913,5,106136,15,-1,-15 +14498,5,137444,288,-1,-288 +14516,5,140350,9,-1,-9 +32040,21,5,38,-1,-38 +35459,21,59937,1,-1,-1 +35473,21,60155,1,-1,-1 +35586,21,61164,1,-1,-1 +35776,21,62734,1,-1,-1 +36180,21,66127,1,-1,-1 +36587,21,70626,1,-1,-1 +36616,21,70977,1,-1,-1 +36649,21,71440,1,-1,-1 +36732,21,72473,1,-1,-1 +36734,21,72485,2,-1,-2 +36806,21,73544,1,-1,-1 +36875,21,74495,2,-1,-2 +38999,21,140350,1,-1,-1 +757825,494,5,144,1,144 +758405,494,137444,51,1,51 +1000645,775,5,918,1,918 +1000681,775,494,1,1,1 +1001593,775,137444,344,1,344 +1598110,1572,5,83,-1,-83 +1598130,1572,494,2,-1,-2 +12295949,52515,5,41,1,41 +12295998,52515,137444,2,1,2 +12955015,57252,5,42,1,42 +13313258,59937,5,38,1,38 +13341831,60155,5,39,1,39 +13341832,60155,21,1,1,1 +13381518,60450,5,41,1,41 +13419754,60737,5,38,1,38 +13475274,61164,5,41,1,41 +13504915,61387,5,39,1,39 +13547075,61721,5,43,1,43 +13557213,61804,5,50,1,50 +13574773,61941,5,40,1,40 +13615444,62257,5,55,1,55 +13674106,62700,5,46,1,46 +13674164,62700,137444,3,1,3 +13678358,62734,5,42,1,42 +13685724,62795,5,51,1,51 +13696886,62888,5,38,1,38 +13715954,63041,5,47,1,47 +13724287,63106,5,38,1,38 +13732392,63173,5,41,1,41 +13747092,63287,5,42,1,42 +13752625,63339,5,42,1,42 +13752679,63339,137444,1,1,1 +13826190,63918,5,41,1,41 +13862959,64210,5,45,1,45 +13865226,64233,5,44,1,44 +13892964,64443,5,40,1,40 +13902952,64514,5,42,1,42 +13965351,65001,5,38,1,38 +13995138,65235,5,38,1,38 +13998219,65262,5,47,1,47 +14012171,65374,5,40,1,40 +14036002,65565,5,40,1,40 +14051671,65691,5,40,1,40 +14051724,65691,137444,2,1,2 +14057223,65742,5,39,1,39 +14089055,66003,5,39,1,39 +14103762,66127,5,40,1,40 +14103763,66127,21,1,1,1 +14103828,66127,137444,1,1,1 +14115991,66225,5,49,1,49 +14116044,66225,137444,1,1,1 +14117243,66237,5,46,1,46 +14154260,66541,5,41,1,41 +14160491,66598,5,41,1,41 +14190586,66843,5,38,1,38 +14203317,66958,5,38,1,38 +14216589,67072,5,45,1,45 +14223566,67135,5,39,1,39 +14235496,67241,5,49,1,49 +14241113,67284,5,43,1,43 +14245371,67324,5,46,1,46 +14251187,67373,5,46,1,46 +14259668,67453,5,45,1,45 +14259716,67453,137444,3,1,3 +14263074,67483,5,40,1,40 +14269476,67537,5,42,1,42 +14275638,67594,5,41,1,41 +14328312,68056,5,40,1,40 +14330661,68074,5,44,1,44 +14344037,68192,5,39,1,39 +14344600,68199,5,46,1,46 +14362012,68355,5,40,1,40 +14362062,68355,137444,1,1,1 +14383249,68543,5,40,1,40 +14392791,68617,5,45,1,45 +14396678,68656,5,43,1,43 +14418963,68838,5,40,1,40 +14420756,68856,5,50,1,50 +14422393,68869,5,40,1,40 +14422447,68869,137444,1,1,1 +14450763,69139,5,42,1,42 +14481744,69415,5,39,1,39 +14492363,69516,5,41,1,41 +14495130,69540,5,40,1,40 +14525565,69809,5,43,1,43 +14531569,69860,5,41,1,41 +14531613,69860,137444,4,1,4 +14543009,69966,5,40,1,40 +14544704,69982,5,39,1,39 +14550492,70036,5,39,1,39 +14568648,70202,5,40,1,40 +14581777,70316,5,44,1,44 +14610749,70561,5,39,1,39 +14618088,70626,5,52,1,52 +14631240,70744,5,39,1,39 +14635726,70783,5,39,1,39 +14647714,70897,5,41,1,41 +14656327,70977,5,39,1,39 +14658186,70995,5,46,1,46 +14664944,71060,5,41,1,41 +14664945,71060,494,1,1,1 +14670187,71120,5,40,1,40 +14680828,71215,5,43,1,43 +14685821,71267,5,42,1,42 +14693690,71346,5,39,1,39 +14703808,71440,5,41,1,41 +14705510,71456,5,44,1,44 +14705563,71456,137444,1,1,1 +14736062,71738,5,40,1,40 +14736115,71738,137444,1,1,1 +14771140,72060,5,41,1,41 +14788752,72219,5,39,1,39 +14788800,72219,137444,2,1,2 +14799628,72322,5,45,1,45 +14804288,72365,5,42,1,42 +14815151,72473,5,41,1,41 +14815152,72473,21,1,1,1 +14816101,72485,5,43,1,43 +14825618,72578,5,39,1,39 +14825674,72578,137444,1,1,1 +14872749,73026,5,41,1,41 +14892579,73221,5,39,1,39 +14926968,73544,5,45,1,45 +14937066,73653,5,39,1,39 +14937113,73653,137444,8,1,8 +14962271,73903,5,39,1,39 +15024378,74495,5,41,1,41 +15059020,74818,5,39,1,39 +15076955,74995,5,42,1,42 +15077006,74995,137444,1,1,1 +15171001,75925,5,41,1,41 +15275022,76961,5,39,1,39 +15275068,76961,137444,1,1,1 +15288253,77090,5,40,1,40 +15307290,77291,5,40,1,40 +15322987,77444,5,40,1,40 +15430092,78506,5,44,1,44 +15437423,78574,5,39,1,39 +15646184,80691,5,39,1,39 +16096773,85419,5,41,1,41 +16690249,91986,5,44,1,44 +17152556,97175,5,43,1,43 +17272361,98515,5,39,1,39 +17544131,101566,5,40,1,40 +17604485,102237,5,40,1,40 +17808131,104598,5,41,1,41 +17856109,105190,5,39,1,39 +17856154,105190,137444,7,1,7 +17861992,105260,5,43,1,43 +17937702,106136,5,41,1,41 +21606907,137444,5,126,-1,-126 +21606909,137444,21,3,-1,-3 +21606916,137444,494,1,-1,-1 +21606921,137444,775,6,-1,-6 +21607306,137444,59937,1,-1,-1 +21607319,137444,60737,1,-1,-1 +21607331,137444,61721,1,-1,-1 +21607338,137444,61941,1,-1,-1 +21607352,137444,62734,1,-1,-1 +21607353,137444,62795,1,-1,-1 +21607365,137444,63173,1,-1,-1 +21607366,137444,63287,1,-1,-1 +21607400,137444,64443,1,-1,-1 +21607432,137444,65742,1,-1,-1 +21607440,137444,66003,1,-1,-1 +21607475,137444,67373,2,-1,-2 +21607506,137444,68199,2,-1,-2 +21607518,137444,68617,1,-1,-1 +21607582,137444,69966,1,-1,-1 +21607588,137444,70036,1,-1,-1 +21607623,137444,70626,1,-1,-1 +21607633,137444,70897,3,-1,-3 +21607657,137444,71346,1,-1,-1 +21607714,137444,72578,1,-1,-1 +21607833,137444,74495,1,-1,-1 +21607852,137444,74818,2,-1,-2 +21609321,137444,91986,1,-1,-1 +21610281,137444,101566,1,-1,-1 +21610534,137444,105260,1,-1,-1 +21934630,140350,5,45,1,45 diff --git a/registry/phase4ae-author-runtime/evidence/cases/highest_indegree/identities.csv b/registry/phase4ae-author-runtime/evidence/cases/highest_indegree/identities.csv new file mode 100644 index 0000000..8ac20ea --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/cases/highest_indegree/identities.csv @@ -0,0 +1,129 @@ +neuron_idx,body_id,annotation_type,neurotransmitter +5,10009,CT1,gaba +21,10029,LoVC16,glutamate +494,10532,MeVC26,acetylcholine +775,10836,OLVC3,acetylcholine +1572,11684,MeVPLp2,glutamate +52515,70245,Tm9,acetylcholine +57252,76118,Tm9,acetylcholine +59937,79501,Tm9,acetylcholine +60155,79781,Tm9,acetylcholine +60450,80142,Tm9,acetylcholine +60737,80501,Tm9,acetylcholine +61164,81041,Tm9,acetylcholine +61387,81301,Tm9,acetylcholine +61721,81734,Tm9,acetylcholine +61804,81831,Tm9,acetylcholine +61941,82003,Tm9,acetylcholine +62257,82394,Tm9,acetylcholine +62700,82937,Tm9,acetylcholine +62734,82979,Tm9,acetylcholine +62795,83060,Tm9,acetylcholine +62888,83185,Tm9,acetylcholine +63041,83375,Tm9,acetylcholine +63106,83462,Tm9,acetylcholine +63173,83545,Tm9,acetylcholine +63287,83686,Tm9,acetylcholine +63339,83753,Tm9,acetylcholine +63918,84478,Tm9,acetylcholine +64210,84851,Tm9,acetylcholine +64233,84878,Tm9,acetylcholine +64443,85140,Tm9,acetylcholine +64514,85236,Tm9,acetylcholine +65001,85889,Tm9,acetylcholine +65235,86195,Tm9,acetylcholine +65262,86232,Tm9,acetylcholine +65374,86371,Tm9,acetylcholine +65565,86617,Tm9,acetylcholine +65691,86786,Tm9,acetylcholine +65742,86856,Tm9,acetylcholine +66003,87208,Tm9,acetylcholine +66127,87381,Tm9,acetylcholine +66225,87504,Tm9,acetylcholine +66237,87520,Tm9,acetylcholine +66541,87925,Tm9,acetylcholine +66598,87994,Tm9,acetylcholine +66843,88320,Tm9,acetylcholine +66958,88475,Tm9,acetylcholine +67072,88621,Tm9,acetylcholine +67135,88713,Tm9,acetylcholine +67241,88850,Tm9,acetylcholine +67284,88907,Tm9,acetylcholine +67324,88959,Tm9,acetylcholine +67373,89023,Tm9,acetylcholine +67453,89138,Tm9,acetylcholine +67483,89177,Tm9,acetylcholine +67537,89251,Tm9,acetylcholine +67594,89319,Tm9,acetylcholine +68056,89933,Tm9,acetylcholine +68074,89954,Tm9,acetylcholine +68192,90120,Tm9,acetylcholine +68199,90133,Tm9,acetylcholine +68355,90340,Tm9,acetylcholine +68543,90590,Tm9,acetylcholine +68617,90688,Tm9,acetylcholine +68656,90733,Tm9,acetylcholine +68838,90991,Tm9,acetylcholine +68856,91014,Tm9,acetylcholine +68869,91034,Tm9,acetylcholine +69139,91392,Tm9,acetylcholine +69415,91766,Tm9,acetylcholine +69516,91900,Tm9,acetylcholine +69540,91933,Tm9,acetylcholine +69809,92279,Tm9,acetylcholine +69860,92356,Tm9,acetylcholine +69966,92497,Tm9,acetylcholine +69982,92521,Tm9,acetylcholine +70036,92592,Tm9,acetylcholine +70202,92805,Tm9,acetylcholine +70316,92954,Tm9,acetylcholine +70561,93271,Tm9,acetylcholine +70626,93347,Tm9,acetylcholine +70744,93499,Tm9,acetylcholine +70783,93556,Tm9,acetylcholine +70897,93720,Tm9,acetylcholine +70977,93824,Tm9,acetylcholine +70995,93845,Tm9,acetylcholine +71060,93923,Tm9,acetylcholine +71120,94000,Tm9,acetylcholine +71215,94133,Tm9,acetylcholine +71267,94199,Tm9,acetylcholine +71346,94296,Tm9,acetylcholine +71440,94423,Tm9,acetylcholine +71456,94443,Tm9,acetylcholine +71738,94831,Tm9,acetylcholine +72060,95260,Tm9,acetylcholine +72219,95470,Tm9,acetylcholine +72322,95604,Tm9,acetylcholine +72365,95658,Tm9,acetylcholine +72473,95798,Tm9,acetylcholine +72485,95813,Tm9,acetylcholine +72578,95937,Tm9,acetylcholine +73026,96565,Tm9,acetylcholine +73221,96845,Tm9,acetylcholine +73544,97254,Tm9,acetylcholine +73653,97408,Tm9,acetylcholine +73903,97731,Tm9,acetylcholine +74495,98585,Tm9,acetylcholine +74818,99046,Tm9,acetylcholine +74995,99268,Tm9,acetylcholine +75925,100512,Tm9,acetylcholine +76961,101957,Tm9,acetylcholine +77090,102126,Tm9,acetylcholine +77291,102421,Tm9,acetylcholine +77444,102619,Tm9,acetylcholine +78506,104080,Tm9,acetylcholine +78574,104167,Tm9,acetylcholine +80691,107094,Tm9,acetylcholine +85419,113692,Tm9,acetylcholine +91986,123393,Tm9,acetylcholine +97175,131756,Tm9,acetylcholine +98515,134011,Tm9,acetylcholine +101566,139750,Tm9,acetylcholine +102237,141068,Tm9,acetylcholine +104598,145922,Tm9,acetylcholine +105190,147208,Tm9,acetylcholine +105260,147382,Tm9,acetylcholine +106136,149457,Tm9,acetylcholine +137444,537032,LT33,gaba +140350,546479,Tm9,acetylcholine diff --git a/registry/phase4ae-author-runtime/evidence/cases/highest_indegree/spec.json b/registry/phase4ae-author-runtime/evidence/cases/highest_indegree/spec.json new file mode 100644 index 0000000..b5de569 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/cases/highest_indegree/spec.json @@ -0,0 +1,45 @@ +{ + "name": "highest_indegree", + "dt_ms": 0.1, + "steps": 500, + "duration_ms": 50.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 + }, + "description": "Deterministically selected real induced graph; canonical edge IDs/counts and frozen signs.", + "trace_queue": true, + "validate_queue_proxy": true, + "selection": { + "target_neuron_idx": 5, + "target_body_id": 10009, + "global_in_degree": 11526, + "positive_in_edges": 10076, + "negative_in_edges": 1403, + "stimulated_neuron_idx": [ + 494, + 775, + 1572, + 61804, + 62257, + 62700, + 62795, + 63041, + 65262, + 66225, + 66237, + 67241, + 67324, + 68856, + 70626, + 137444 + ] + } +} diff --git a/registry/phase4ae-author-runtime/evidence/cases/mixed_high_indegree/anatomical-edges.csv b/registry/phase4ae-author-runtime/evidence/cases/mixed_high_indegree/anatomical-edges.csv new file mode 100644 index 0000000..f7dd16e --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/cases/mixed_high_indegree/anatomical-edges.csv @@ -0,0 +1,267 @@ +edge_id,source_neuron_idx,target_neuron_idx,raw_count,source_sign,signed_raw +4897,5,21,2,-1,-2 +4899,5,44,4,-1,-4 +4914,5,775,12,-1,-12 +4919,5,1572,3,-1,-3 +5026,5,15460,3,-1,-3 +5050,5,18811,2,-1,-2 +5816,5,40937,1,-1,-1 +6054,5,48221,1,-1,-1 +6081,5,49476,1,-1,-1 +6105,5,50622,1,-1,-1 +6141,5,52222,1,-1,-1 +6148,5,52515,15,-1,-15 +6240,5,57252,9,-1,-9 +6251,5,57612,1,-1,-1 +6312,5,60182,1,-1,-1 +6320,5,60450,9,-1,-9 +6351,5,61164,12,-1,-12 +6368,5,61721,13,-1,-13 +6371,5,61804,11,-1,-11 +6396,5,62257,12,-1,-12 +6412,5,62700,12,-1,-12 +6415,5,62734,8,-1,-8 +6421,5,62795,9,-1,-9 +6435,5,63041,12,-1,-12 +6440,5,63173,14,-1,-14 +6448,5,63287,7,-1,-7 +6452,5,63339,10,-1,-10 +6491,5,63918,13,-1,-13 +6505,5,64210,13,-1,-13 +6508,5,64233,9,-1,-9 +6529,5,64514,14,-1,-14 +6569,5,65262,12,-1,-12 +6636,5,66225,10,-1,-10 +6637,5,66237,9,-1,-9 +6660,5,66541,8,-1,-8 +6666,5,66598,14,-1,-14 +6714,5,67072,14,-1,-14 +6738,5,67241,15,-1,-15 +6743,5,67284,13,-1,-13 +6749,5,67324,6,-1,-6 +6754,5,67373,16,-1,-16 +6765,5,67453,15,-1,-15 +6776,5,67537,12,-1,-12 +6783,5,67594,11,-1,-11 +6836,5,68074,14,-1,-14 +6856,5,68199,11,-1,-11 +6904,5,68617,10,-1,-10 +6910,5,68656,16,-1,-16 +6937,5,68856,11,-1,-11 +6970,5,69139,16,-1,-16 +7019,5,69516,6,-1,-6 +7064,5,69809,14,-1,-14 +7073,5,69860,10,-1,-10 +7139,5,70316,17,-1,-17 +7177,5,70626,12,-1,-12 +7229,5,70897,13,-1,-13 +7242,5,70995,6,-1,-6 +7252,5,71060,9,-1,-9 +7280,5,71215,14,-1,-14 +7292,5,71267,15,-1,-15 +7314,5,71440,9,-1,-9 +7318,5,71456,15,-1,-15 +7406,5,72060,13,-1,-13 +7444,5,72275,1,-1,-1 +7452,5,72322,15,-1,-15 +7457,5,72365,8,-1,-8 +7473,5,72473,22,-1,-22 +7475,5,72485,12,-1,-12 +7569,5,73026,6,-1,-6 +7657,5,73544,15,-1,-15 +7930,5,74995,12,-1,-12 +8626,5,78506,8,-1,-8 +11736,5,91986,12,-1,-12 +12743,5,97175,13,-1,-13 +13801,5,104999,1,-1,-1 +13831,5,105260,13,-1,-13 +14498,5,137444,288,-1,-288 +14516,5,140350,9,-1,-9 +32040,21,5,38,-1,-38 +32042,21,44,9,-1,-9 +32141,21,6667,31,-1,-31 +35586,21,61164,1,-1,-1 +35776,21,62734,1,-1,-1 +36587,21,70626,1,-1,-1 +36649,21,71440,1,-1,-1 +36732,21,72473,1,-1,-1 +36734,21,72485,2,-1,-2 +36806,21,73544,1,-1,-1 +38999,21,140350,1,-1,-1 +89520,44,5,32,-1,-32 +89522,44,21,23,-1,-23 +89638,44,6667,23,-1,-23 +93532,44,63918,1,-1,-1 +93678,44,65262,2,-1,-2 +93999,44,68617,1,-1,-1 +94207,44,70897,1,-1,-1 +96541,44,137444,3,-1,-3 +757825,494,5,144,1,144 +758405,494,137444,51,1,51 +1000645,775,5,918,1,918 +1000652,775,44,2,1,2 +1000681,775,494,1,1,1 +1000776,775,6667,7,1,7 +1001593,775,137444,344,1,344 +1598110,1572,5,83,-1,-83 +1598130,1572,494,2,-1,-2 +1598393,1572,18811,1,-1,-1 +1598691,1572,59164,1,-1,-1 +3758873,6667,5,7,-1,-7 +3758874,6667,21,5,-1,-5 +3758876,6667,44,1,-1,-1 +3760664,6667,137444,221,-1,-221 +6086699,15460,5,9,-1,-9 +6086723,15460,6667,1,-1,-1 +6087208,15460,137444,1,-1,-1 +6785640,18811,5,7,-1,-7 +10569176,40937,5,8,-1,-8 +10704992,41813,5,7,-1,-7 +10736027,42005,5,7,-1,-7 +11197785,45077,5,7,-1,-7 +11251998,45449,5,10,-1,-10 +11484227,47004,5,8,-1,-8 +11488066,47028,5,12,-1,-12 +11558753,47491,5,8,-1,-8 +11596918,47754,5,7,-1,-7 +11602095,47782,5,7,-1,-7 +11654974,48155,5,7,-1,-7 +11664899,48221,5,9,-1,-9 +11772156,48947,5,7,-1,-7 +11851050,49476,5,8,-1,-8 +11884301,49706,5,7,-1,-7 +11899194,49809,5,7,-1,-7 +11984065,50350,5,9,-1,-9 +11998296,50455,5,9,-1,-9 +12013821,50561,5,8,-1,-8 +12022562,50622,5,10,-1,-10 +12038629,50734,5,7,-1,-7 +12091997,51102,5,8,-1,-8 +12099494,51157,5,10,-1,-10 +12165422,51608,5,12,-1,-12 +12252801,52222,5,9,-1,-9 +12271215,52352,5,12,-1,-12 +12293012,52494,5,9,-1,-9 +12295949,52515,5,41,1,41 +12295998,52515,137444,2,1,2 +12375691,53063,5,11,-1,-11 +12413314,53324,5,10,-1,-10 +12507358,54010,5,8,-1,-8 +12660361,55100,5,13,-1,-13 +12856017,56539,5,8,-1,-8 +12947731,57201,5,15,-1,-15 +12955015,57252,5,42,1,42 +13005488,57612,5,9,-1,-9 +13212934,59164,5,10,-1,-10 +13212942,59164,1572,1,-1,-1 +13239499,59365,5,11,-1,-11 +13345851,60182,5,8,-1,-8 +13381518,60450,5,41,1,41 +13475274,61164,5,41,1,41 +13545470,61707,5,12,-1,-12 +13547075,61721,5,43,1,43 +13557213,61804,5,50,1,50 +13615444,62257,5,55,1,55 +13674106,62700,5,46,1,46 +13674108,62700,6667,1,1,1 +13674164,62700,137444,3,1,3 +13678358,62734,5,42,1,42 +13685724,62795,5,51,1,51 +13715954,63041,5,47,1,47 +13732392,63173,5,41,1,41 +13747092,63287,5,42,1,42 +13752625,63339,5,42,1,42 +13752679,63339,137444,1,1,1 +13826190,63918,5,41,1,41 +13862959,64210,5,45,1,45 +13865226,64233,5,44,1,44 +13879186,64335,5,10,-1,-10 +13902952,64514,5,42,1,42 +13998219,65262,5,47,1,47 +14070553,65848,5,9,-1,-9 +14115991,66225,5,49,1,49 +14116044,66225,137444,1,1,1 +14117243,66237,5,46,1,46 +14154260,66541,5,41,1,41 +14160491,66598,5,41,1,41 +14216589,67072,5,45,1,45 +14235496,67241,5,49,1,49 +14241113,67284,5,43,1,43 +14245371,67324,5,46,1,46 +14245378,67324,49476,2,1,2 +14251187,67373,5,46,1,46 +14251198,67373,53324,2,1,2 +14259668,67453,5,45,1,45 +14259716,67453,137444,3,1,3 +14269476,67537,5,42,1,42 +14275638,67594,5,41,1,41 +14330661,68074,5,44,1,44 +14344600,68199,5,46,1,46 +14379230,68506,5,8,-1,-8 +14392791,68617,5,45,1,45 +14396678,68656,5,43,1,43 +14412757,68785,5,9,-1,-9 +14420756,68856,5,50,1,50 +14450763,69139,5,42,1,42 +14486521,69462,5,10,-1,-10 +14492363,69516,5,41,1,41 +14525565,69809,5,43,1,43 +14531569,69860,5,41,1,41 +14531613,69860,137444,4,1,4 +14534259,69887,5,8,-1,-8 +14581777,70316,5,44,1,44 +14618088,70626,5,52,1,52 +14622283,70662,5,8,-1,-8 +14647714,70897,5,41,1,41 +14654473,70959,5,8,-1,-8 +14658186,70995,5,46,1,46 +14664944,71060,5,41,1,41 +14664945,71060,494,1,1,1 +14680828,71215,5,43,1,43 +14685821,71267,5,42,1,42 +14703808,71440,5,41,1,41 +14705510,71456,5,44,1,44 +14705563,71456,137444,1,1,1 +14771140,72060,5,41,1,41 +14794365,72275,5,11,-1,-11 +14799628,72322,5,45,1,45 +14804288,72365,5,42,1,42 +14815151,72473,5,41,1,41 +14815152,72473,21,1,1,1 +14816101,72485,5,43,1,43 +14816111,72485,51102,2,1,2 +14872749,73026,5,41,1,41 +14926968,73544,5,45,1,45 +15064838,74878,5,9,-1,-9 +15076955,74995,5,42,1,42 +15077006,74995,137444,1,1,1 +15316989,77390,5,8,-1,-8 +15430092,78506,5,44,1,44 +16053751,84964,5,9,-1,-9 +16298962,87611,5,9,-1,-9 +16407272,88823,5,15,-1,-15 +16448785,89271,5,10,-1,-10 +16448792,89271,1572,1,-1,-1 +16690249,91986,5,44,1,44 +17112927,96731,5,12,-1,-12 +17128837,96909,5,8,-1,-8 +17152556,97175,5,43,1,43 +17840952,104999,5,8,-1,-8 +17861992,105260,5,43,1,43 +21606907,137444,5,126,-1,-126 +21606909,137444,21,3,-1,-3 +21606916,137444,494,1,-1,-1 +21606921,137444,775,6,-1,-6 +21607331,137444,61721,1,-1,-1 +21607352,137444,62734,1,-1,-1 +21607353,137444,62795,1,-1,-1 +21607365,137444,63173,1,-1,-1 +21607366,137444,63287,1,-1,-1 +21607475,137444,67373,2,-1,-2 +21607506,137444,68199,2,-1,-2 +21607518,137444,68617,1,-1,-1 +21607623,137444,70626,1,-1,-1 +21607633,137444,70897,3,-1,-3 +21609321,137444,91986,1,-1,-1 +21610534,137444,105260,1,-1,-1 +21934630,140350,5,45,1,45 diff --git a/registry/phase4ae-author-runtime/evidence/cases/mixed_high_indegree/identities.csv b/registry/phase4ae-author-runtime/evidence/cases/mixed_high_indegree/identities.csv new file mode 100644 index 0000000..85861d7 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/cases/mixed_high_indegree/identities.csv @@ -0,0 +1,129 @@ +neuron_idx,body_id,annotation_type,neurotransmitter +5,10009,CT1,gaba +21,10029,LoVC16,glutamate +44,10053,LoVC16,glutamate +494,10532,MeVC26,acetylcholine +775,10836,OLVC3,acetylcholine +1572,11684,MeVPLp2,glutamate +6667,17289,Li29,gaba +15460,27130,TmY15,gaba +18811,30896,TmY15,gaba +40937,56248,Mi9,glutamate +41813,57306,Mi9,glutamate +42005,57537,Mi9,glutamate +45077,61192,Mi9,glutamate +45449,61642,Mi9,glutamate +47004,63517,Mi9,glutamate +47028,63547,Mi9,glutamate +47491,64100,Mi9,glutamate +47754,64418,Mi9,glutamate +47782,64451,Mi9,glutamate +48155,64903,Mi9,glutamate +48221,64984,Mi9,glutamate +48947,65851,Mi9,glutamate +49476,66497,Mi9,glutamate +49706,66780,Mi9,glutamate +49809,66902,Mi9,glutamate +50350,67574,Mi9,glutamate +50455,67707,Mi9,glutamate +50561,67843,Mi9,glutamate +50622,67918,Mi9,glutamate +50734,68057,Mi9,glutamate +51102,68508,Mi9,glutamate +51157,68577,Mi9,glutamate +51608,69132,Mi9,glutamate +52222,69881,Mi9,glutamate +52352,70046,Mi9,glutamate +52494,70216,Mi9,glutamate +52515,70245,Tm9,acetylcholine +53063,70927,Mi9,glutamate +53324,71249,Mi9,glutamate +54010,72095,Mi9,glutamate +55100,73466,Mi9,glutamate +56539,75256,Mi9,glutamate +57201,76059,Mi9,glutamate +57252,76118,Tm9,acetylcholine +57612,76551,Mi9,glutamate +59164,78522,Mi9,glutamate +59365,78774,Mi9,glutamate +60182,79818,Mi9,glutamate +60450,80142,Tm9,acetylcholine +61164,81041,Tm9,acetylcholine +61707,81713,Mi9,glutamate +61721,81734,Tm9,acetylcholine +61804,81831,Tm9,acetylcholine +62257,82394,Tm9,acetylcholine +62700,82937,Tm9,acetylcholine +62734,82979,Tm9,acetylcholine +62795,83060,Tm9,acetylcholine +63041,83375,Tm9,acetylcholine +63173,83545,Tm9,acetylcholine +63287,83686,Tm9,acetylcholine +63339,83753,Tm9,acetylcholine +63918,84478,Tm9,acetylcholine +64210,84851,Tm9,acetylcholine +64233,84878,Tm9,acetylcholine +64335,85004,Mi9,glutamate +64514,85236,Tm9,acetylcholine +65262,86232,Tm9,acetylcholine +65848,86983,Mi9,glutamate +66225,87504,Tm9,acetylcholine +66237,87520,Tm9,acetylcholine +66541,87925,Tm9,acetylcholine +66598,87994,Tm9,acetylcholine +67072,88621,Tm9,acetylcholine +67241,88850,Tm9,acetylcholine +67284,88907,Tm9,acetylcholine +67324,88959,Tm9,acetylcholine +67373,89023,Tm9,acetylcholine +67453,89138,Tm9,acetylcholine +67537,89251,Tm9,acetylcholine +67594,89319,Tm9,acetylcholine +68074,89954,Tm9,acetylcholine +68199,90133,Tm9,acetylcholine +68506,90541,Mi9,glutamate +68617,90688,Tm9,acetylcholine +68656,90733,Tm9,acetylcholine +68785,90917,Mi9,glutamate +68856,91014,Tm9,acetylcholine +69139,91392,Tm9,acetylcholine +69462,91829,Mi9,glutamate +69516,91900,Tm9,acetylcholine +69809,92279,Tm9,acetylcholine +69860,92356,Tm9,acetylcholine +69887,92394,Mi9,glutamate +70316,92954,Tm9,acetylcholine +70626,93347,Tm9,acetylcholine +70662,93393,Mi9,glutamate +70897,93720,Tm9,acetylcholine +70959,93800,Mi9,glutamate +70995,93845,Tm9,acetylcholine +71060,93923,Tm9,acetylcholine +71215,94133,Tm9,acetylcholine +71267,94199,Tm9,acetylcholine +71440,94423,Tm9,acetylcholine +71456,94443,Tm9,acetylcholine +72060,95260,Tm9,acetylcholine +72275,95544,Mi9,glutamate +72322,95604,Tm9,acetylcholine +72365,95658,Tm9,acetylcholine +72473,95798,Tm9,acetylcholine +72485,95813,Tm9,acetylcholine +73026,96565,Tm9,acetylcholine +73544,97254,Tm9,acetylcholine +74878,99133,Mi9,glutamate +74995,99268,Tm9,acetylcholine +77390,102542,Mi9,glutamate +78506,104080,Tm9,acetylcholine +84964,113050,Mi9,glutamate +87611,116890,Mi9,glutamate +88823,118635,Mi9,glutamate +89271,119289,Mi9,glutamate +91986,123393,Tm9,acetylcholine +96731,131072,Mi9,glutamate +96909,131351,Mi9,glutamate +97175,131756,Tm9,acetylcholine +104999,146808,Mi9,glutamate +105260,147382,Tm9,acetylcholine +137444,537032,LT33,gaba +140350,546479,Tm9,acetylcholine diff --git a/registry/phase4ae-author-runtime/evidence/cases/mixed_high_indegree/spec.json b/registry/phase4ae-author-runtime/evidence/cases/mixed_high_indegree/spec.json new file mode 100644 index 0000000..c8d4d9c --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/cases/mixed_high_indegree/spec.json @@ -0,0 +1,45 @@ +{ + "name": "mixed_high_indegree", + "dt_ms": 0.1, + "steps": 500, + "duration_ms": 50.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 + }, + "description": "Deterministically selected real induced graph; canonical edge IDs/counts and frozen signs.", + "trace_queue": true, + "validate_queue_proxy": true, + "selection": { + "target_neuron_idx": 5, + "target_body_id": 10009, + "global_in_degree": 11526, + "positive_in_edges": 10076, + "negative_in_edges": 1403, + "stimulated_neuron_idx": [ + 494, + 775, + 61804, + 62257, + 62700, + 62795, + 63041, + 65262, + 66225, + 66237, + 67241, + 67324, + 67373, + 68199, + 68856, + 70626 + ] + } +} diff --git a/registry/phase4ae-author-runtime/evidence/cases/motif_feedforward/spec.json b/registry/phase4ae-author-runtime/evidence/cases/motif_feedforward/spec.json new file mode 100644 index 0000000..d947997 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/cases/motif_feedforward/spec.json @@ -0,0 +1,21 @@ +{ + "name": "motif_feedforward", + "dt_ms": 0.1, + "steps": 1000, + "duration_ms": 100.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 + }, + "description": "Same selected4AC/4AD motif,100ms prefix; no new edge or weight.", + "trace_queue": true, + "validate_queue_proxy": true, + "selection": null +} diff --git a/registry/phase4ae-author-runtime/evidence/cases/motif_five/spec.json b/registry/phase4ae-author-runtime/evidence/cases/motif_five/spec.json new file mode 100644 index 0000000..0e1bbb3 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/cases/motif_five/spec.json @@ -0,0 +1,21 @@ +{ + "name": "motif_five", + "dt_ms": 0.1, + "steps": 1000, + "duration_ms": 100.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 + }, + "description": "Same selected4AC/4AD motif,100ms prefix; no new edge or weight.", + "trace_queue": true, + "validate_queue_proxy": true, + "selection": null +} diff --git a/registry/phase4ae-author-runtime/evidence/cases/motif_no_input/spec.json b/registry/phase4ae-author-runtime/evidence/cases/motif_no_input/spec.json new file mode 100644 index 0000000..511d48b --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/cases/motif_no_input/spec.json @@ -0,0 +1,21 @@ +{ + "name": "motif_no_input", + "dt_ms": 0.1, + "steps": 1000, + "duration_ms": 100.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 + }, + "description": "Same selected4AC/4AD motif,100ms prefix; no new edge or weight.", + "trace_queue": true, + "validate_queue_proxy": true, + "selection": null +} diff --git a/registry/phase4ae-author-runtime/evidence/cases/motif_pair/spec.json b/registry/phase4ae-author-runtime/evidence/cases/motif_pair/spec.json new file mode 100644 index 0000000..78649d0 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/cases/motif_pair/spec.json @@ -0,0 +1,21 @@ +{ + "name": "motif_pair", + "dt_ms": 0.1, + "steps": 1000, + "duration_ms": 100.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 + }, + "description": "Same selected4AC/4AD motif,100ms prefix; no new edge or weight.", + "trace_queue": true, + "validate_queue_proxy": true, + "selection": null +} diff --git a/registry/phase4ae-author-runtime/evidence/cases/motif_trio/spec.json b/registry/phase4ae-author-runtime/evidence/cases/motif_trio/spec.json new file mode 100644 index 0000000..2893dfd --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/cases/motif_trio/spec.json @@ -0,0 +1,21 @@ +{ + "name": "motif_trio", + "dt_ms": 0.1, + "steps": 1000, + "duration_ms": 100.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 + }, + "description": "Same selected4AC/4AD motif,100ms prefix; no new edge or weight.", + "trace_queue": true, + "validate_queue_proxy": true, + "selection": null +} diff --git a/registry/phase4ae-author-runtime/evidence/cases/ordered_cancellation/spec.json b/registry/phase4ae-author-runtime/evidence/cases/ordered_cancellation/spec.json new file mode 100644 index 0000000..c1b6d59 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/cases/ordered_cancellation/spec.json @@ -0,0 +1,21 @@ +{ + "name": "ordered_cancellation", + "dt_ms": 0.1, + "steps": 160, + "duration_ms": 16.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 + }, + "description": "Pure synthetic numerical cancellation; huge counts are nonphysiological; nonzero initial g.", + "trace_queue": true, + "validate_queue_proxy": true, + "selection": null +} diff --git a/registry/phase4ae-author-runtime/evidence/cases/release_selfloop/spec.json b/registry/phase4ae-author-runtime/evidence/cases/release_selfloop/spec.json new file mode 100644 index 0000000..6ad2f75 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/cases/release_selfloop/spec.json @@ -0,0 +1,21 @@ +{ + "name": "release_selfloop", + "dt_ms": 0.1, + "steps": 160, + "duration_ms": 16.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 + }, + "description": "Release at22 with same-tick force/arrival, loops and ring wraps.", + "trace_queue": true, + "validate_queue_proxy": true, + "selection": null +} diff --git a/registry/phase4ae-author-runtime/evidence/cases/signed_random/spec.json b/registry/phase4ae-author-runtime/evidence/cases/signed_random/spec.json new file mode 100644 index 0000000..5862431 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/cases/signed_random/spec.json @@ -0,0 +1,21 @@ +{ + "name": "signed_random", + "dt_ms": 0.1, + "steps": 400, + "duration_ms": 40.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 + }, + "description": "Fixed seed128-cell signed random fixture; forcing stops at20ms; signs assigned per synthetic source.", + "trace_queue": true, + "validate_queue_proxy": true, + "selection": null +} diff --git a/registry/phase4ae-author-runtime/evidence/cases/threshold_rounding/spec.json b/registry/phase4ae-author-runtime/evidence/cases/threshold_rounding/spec.json new file mode 100644 index 0000000..fa828cb --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/cases/threshold_rounding/spec.json @@ -0,0 +1,21 @@ +{ + "name": "threshold_rounding", + "dt_ms": 0.1, + "steps": 100, + "duration_ms": 10.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 + }, + "description": "Preintegration voltages bracket strict-threshold landing in both precisions; inert zero fixture edge.", + "trace_queue": true, + "validate_queue_proxy": true, + "selection": null +} diff --git a/registry/phase4ae-author-runtime/evidence/checksums.sha256 b/registry/phase4ae-author-runtime/evidence/checksums.sha256 new file mode 100644 index 0000000..2104e82 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/checksums.sha256 @@ -0,0 +1,917 @@ +b868f1af329c95f5c264e42b05f53b13b6a86ef4a8a4ffb728cb8eee1e6f4223 REPORT.md +ea2305390f21d0aa35de76efae59819cb5548391b6cab57b9d72a3472d017013 audit/final-status.json +f3a900e9032754619549005131283cbaf87fdaa9093887a90a295589dac590fb cases/fanin_bursts/arrays.npz +90850d6968a7832e415d0966b57e216a65f5ba8f63e488e497148b6525806d79 cases/fanin_bursts/spec.json +aec331ee87f0da905d55b4dbb61a7e72fae734246ae6fbf462d7f6348dcdae1b cases/highest_indegree/anatomical-edges.csv +02ab938969b4369b1e08bc4a82e8c5fe68683f7318baf5eb052098d63fab0302 cases/highest_indegree/arrays.npz +5a837548ac8d45d495765d012f4495f4f68b2c9b0eda3eabd759869fc793fe77 cases/highest_indegree/identities.csv +eab2c18f120fd3e9f067f489cee0a4c07477607facf3094083d3e3fa60bfd1ef cases/highest_indegree/spec.json +4bb7f2b5344916035a87bffec9b26570ef21842010fcf78ff1a71230496c4757 cases/mixed_high_indegree/anatomical-edges.csv +63fb734a967aee5f77709788ad9bd7d8783c2209c34f0e1d9aa6a0a8b7a6ecf5 cases/mixed_high_indegree/arrays.npz +ad8f92fab6e2c38ed2b369b7f03c5b75d3c26433ad43bde6e2fc76f8058dd009 cases/mixed_high_indegree/identities.csv +11f07dd0a3e62b6ee66373022539a68daad766dce26fa759654f0201599f6703 cases/mixed_high_indegree/spec.json +cdba32792924258112a2fd6ffaca5e329c71404840a290a9187e5d3e2b6550d4 cases/motif_feedforward/arrays.npz +1bb9ef28864e46336581d23fc15eaf80a329ee4d1a439abd0fc18c52f87a2b77 cases/motif_feedforward/spec.json +712a18275609cc71875e4ea04ca97222de917de9b1d6760f4052e2a3f0dd465e cases/motif_five/arrays.npz +f78ba9423ed1dfb686cd79a0a003cda0bf9e7603d37e8d318118e08766ece7b3 cases/motif_five/spec.json +3e3f7c2bd477e097761d3e34745f88fb215636c74d89a9e77a2b9a5f2fc738c3 cases/motif_no_input/arrays.npz +02adfcd0717aa2d98eb571107136eae7186166ce1c7d7eb87df23bedb452fbd9 cases/motif_no_input/spec.json +7c01e762480777b22474264f28cc413e554314602fad320a33b53dd028a1fb5a cases/motif_pair/arrays.npz +faee4cdcdc93293b4b5e15d852a6a97b76767ce6aa7c534b12c6f204264daa7a cases/motif_pair/spec.json +a40e803b1227d4bb6b2c24d76bdf1454cb63ace61ebb9e77ff01010dd91cab37 cases/motif_trio/arrays.npz +da4b6cea0b8a33ca15e552425b55ce699d74ddf81660b02eeb30d5edcc4494cd cases/motif_trio/spec.json +97e033aaacc5703bca141b03a1db1d33522a3bf8c7ae182bafd15cafcb4c1e23 cases/ordered_cancellation/arrays.npz +1866003021cc39ad50858fe0d9f56d74e8dd16bd574eef15c0625b604cd987b2 cases/ordered_cancellation/spec.json +aececf2fd48c52804d84852483e467b13d23b7b675c8b7b0d967c02aee960a5f cases/release_selfloop/arrays.npz +f63a2d3a4e99220a42944461a3223c459e3a1e7c02d22dc5e30cd129dd9452d1 cases/release_selfloop/spec.json +b29ac37913a97f3e3a9a3136b0949e9cbaf3a42ddcd1c7cec1e5b356a5da1ac7 cases/signed_random/arrays.npz +7c6af1bf5fd8f68c84fe000ec6b4977d05f6db17f4b9338d8ad49376036cbf32 cases/signed_random/spec.json +4acb2f79684a0ffd1c9666da608f8b0ad4f5c150ba5b0d6a2d08e2778a20a298 cases/threshold_rounding/arrays.npz +8a000b9052226e0d4db020cc1dbfc839ac2aa98f01cb9361de2209dbe8706495 cases/threshold_rounding/spec.json +2263468c2217a9aaff057fa46c83358e78bd398f0f93efd5aa1365501afec520 extension-build/author_cuda_8b92086ce274b694/.ninja_deps +1a743a54d2b43b0e1537ba1e7a3274cea3a8e95c34b01d81269b1326d86dc982 extension-build/author_cuda_8b92086ce274b694/.ninja_log +9fc6af40c39adb319fa1a29a22d6672fe0ca620fdaa663e01a074f820c712ac5 extension-build/author_cuda_8b92086ce274b694/author_cuda_8b92086ce274b694.so +88ad1791aea2e67fcdf2e66902e7ccc752a1fc727ac1565327f34193c5d2c7f6 extension-build/author_cuda_8b92086ce274b694/author_ext.cuda.o +f9092f2ef8da90ee89cfb89075d1e0891456f4bcbf6d9d405c65696a92f8cc49 extension-build/author_cuda_8b92086ce274b694/author_ext.o +75c123c6847475e58245ed925446ae65ffcb58f336d6b4cb928e7f47e4de8a50 extension-build/author_cuda_8b92086ce274b694/build.ninja +e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 extension-build/author_cuda_8b92086ce274b694/lock +aeb40d155d36e3ade82c38f8ab304b003e78f16c7e6a79a9d8cefd2da3d4aa09 gpu/fanin_bursts-float32-r0/arrival-order.npz +12310d970a3122d98925e90a6ee852f93b89ac7c65740bce766fbdab104ae95e gpu/fanin_bursts-float32-r0/comparison.json +947e74fc7788cd190e804764757beb5f5ac56be1b2b55a4d415c171e33a71e36 gpu/fanin_bursts-float32-r0/metrics.json +0a4b40f8778f26fcd5afe342e7ebe8c1cd3fe1fccb72fcfebbc9b0000d48e9c3 gpu/fanin_bursts-float32-r0/state.npz +aeb40d155d36e3ade82c38f8ab304b003e78f16c7e6a79a9d8cefd2da3d4aa09 gpu/fanin_bursts-float32-r1/arrival-order.npz +e5b955928b916af14e464a65207e1a3ce06e74b5b7a92fd7969d0a3f9a7fd18a gpu/fanin_bursts-float32-r1/comparison.json +452d8917e29a03cbd1d217c397dd9e8e085dc33c2ee27517cde6dd7d0c6694ed gpu/fanin_bursts-float32-r1/metrics.json +0a4b40f8778f26fcd5afe342e7ebe8c1cd3fe1fccb72fcfebbc9b0000d48e9c3 gpu/fanin_bursts-float32-r1/state.npz +aeb40d155d36e3ade82c38f8ab304b003e78f16c7e6a79a9d8cefd2da3d4aa09 gpu/fanin_bursts-float32-r2/arrival-order.npz +045405c14e0929e4875ad8be6cd617db29f2367f53b1db03cb80604c081b0857 gpu/fanin_bursts-float32-r2/comparison.json +329b1be64ff13f3ef0fe4849ec9ef6bc5d4cf3cfe8bc731d82c8d12e07403f3f gpu/fanin_bursts-float32-r2/metrics.json +0a4b40f8778f26fcd5afe342e7ebe8c1cd3fe1fccb72fcfebbc9b0000d48e9c3 gpu/fanin_bursts-float32-r2/state.npz +aeb40d155d36e3ade82c38f8ab304b003e78f16c7e6a79a9d8cefd2da3d4aa09 gpu/fanin_bursts-float64-r0/arrival-order.npz +eeca2cf7cee7c8a2bb672cc2f9cb8ffe2fee5d7cebef5a7ac2168ce0d0c7bf55 gpu/fanin_bursts-float64-r0/comparison.json +0427ff2e3ee46fd3a40a71bfb36af193fc4c30a17d209e288be4f4e21b8d13ef gpu/fanin_bursts-float64-r0/metrics.json +c0534c8697387f44de4f465109bc8b1daf7b42ddb050549836d79f509209c312 gpu/fanin_bursts-float64-r0/state.npz +aeb40d155d36e3ade82c38f8ab304b003e78f16c7e6a79a9d8cefd2da3d4aa09 gpu/fanin_bursts-float64-r1/arrival-order.npz +21795525db57f8890dda1d50b7c9dd8988f951127488c2a6da544501c7ed43c4 gpu/fanin_bursts-float64-r1/comparison.json +45a9bcbe167e2ef3436060ffc2ea08b11670adc744a3e60db75ac0264de6db36 gpu/fanin_bursts-float64-r1/metrics.json +c0534c8697387f44de4f465109bc8b1daf7b42ddb050549836d79f509209c312 gpu/fanin_bursts-float64-r1/state.npz +aeb40d155d36e3ade82c38f8ab304b003e78f16c7e6a79a9d8cefd2da3d4aa09 gpu/fanin_bursts-float64-r2/arrival-order.npz +486c36e6e182d820201fd18a1b38b7eedbbd8aa4295a92b3145265dad8f0a170 gpu/fanin_bursts-float64-r2/comparison.json +b28d29cc60d80ddbd76c0bd309141e2eb44fcf00a0dd877ca92a4968530e8254 gpu/fanin_bursts-float64-r2/metrics.json +c0534c8697387f44de4f465109bc8b1daf7b42ddb050549836d79f509209c312 gpu/fanin_bursts-float64-r2/state.npz +c46a8697c4e5bdbb90e244c363976a1d41f79e8a04ce3e26b58be5de4d57b382 gpu/highest_indegree-float32-r0/arrival-order.npz +1f2def177229390bcde1b9a2c94819da9d68d4336f8dfc73b1be545e44ba9278 gpu/highest_indegree-float32-r0/comparison.json +afff8582869eb807dc43a62d1ec84fd9c6300822afaa839f138cefface1b51ae gpu/highest_indegree-float32-r0/metrics.json +0fb384c6fa07e434418650e7b6c0b00d64a899ecb50a5f433f6fa5a7b86c4db0 gpu/highest_indegree-float32-r0/state.npz +c46a8697c4e5bdbb90e244c363976a1d41f79e8a04ce3e26b58be5de4d57b382 gpu/highest_indegree-float32-r1/arrival-order.npz +246c89aa41573e512506057ff3f3a827cc0747453515e084e4aff4cd9013d221 gpu/highest_indegree-float32-r1/comparison.json +d5e3527c34e46cc7f46327fdfde3e894e8f10c07b69c9970a327b19a4d096c31 gpu/highest_indegree-float32-r1/metrics.json +0fb384c6fa07e434418650e7b6c0b00d64a899ecb50a5f433f6fa5a7b86c4db0 gpu/highest_indegree-float32-r1/state.npz +c46a8697c4e5bdbb90e244c363976a1d41f79e8a04ce3e26b58be5de4d57b382 gpu/highest_indegree-float32-r2/arrival-order.npz +8ab5759412dda7e8cdba5692ed62e667873e647155ac86ba31e5f539388fd43c gpu/highest_indegree-float32-r2/comparison.json +c106130ad03b70bca3f31d0074d19ed2f50fe760b57359fec00f682050ff759a gpu/highest_indegree-float32-r2/metrics.json +0fb384c6fa07e434418650e7b6c0b00d64a899ecb50a5f433f6fa5a7b86c4db0 gpu/highest_indegree-float32-r2/state.npz +c46a8697c4e5bdbb90e244c363976a1d41f79e8a04ce3e26b58be5de4d57b382 gpu/highest_indegree-float64-r0/arrival-order.npz +9bf9fb86fef1ebc866de0e8152f34067cb68e3434d3b232bf02c5207f57ff885 gpu/highest_indegree-float64-r0/comparison.json +a8b920d40fa3366874b08048c6b29dbfa1d1526e462cd3a444c40809e7ba37f2 gpu/highest_indegree-float64-r0/metrics.json +49a826f485c93abca8651447b15bf5afe65f319055b3f50a79f198a6dd981693 gpu/highest_indegree-float64-r0/state.npz +c46a8697c4e5bdbb90e244c363976a1d41f79e8a04ce3e26b58be5de4d57b382 gpu/highest_indegree-float64-r1/arrival-order.npz +462d36b713564bd81ffe28a3707ce208ab1c413437e1fffc869c5c1054728e2f gpu/highest_indegree-float64-r1/comparison.json +e655f6d65f52678ecd4e5acce372a34c5ea8a52a222cb36496e85dcdb54f5e73 gpu/highest_indegree-float64-r1/metrics.json +49a826f485c93abca8651447b15bf5afe65f319055b3f50a79f198a6dd981693 gpu/highest_indegree-float64-r1/state.npz +c46a8697c4e5bdbb90e244c363976a1d41f79e8a04ce3e26b58be5de4d57b382 gpu/highest_indegree-float64-r2/arrival-order.npz +e3fec806eb2608554720b0bd9667f1aee75c0ad269a613e36104ea4c4d95f82e gpu/highest_indegree-float64-r2/comparison.json +e1474af65ed69ce0707ca5c4f6fadf97e3606da14dad54664995646d57791012 gpu/highest_indegree-float64-r2/metrics.json +49a826f485c93abca8651447b15bf5afe65f319055b3f50a79f198a6dd981693 gpu/highest_indegree-float64-r2/state.npz +7ec4a257b6abfecb829c61463bdac87a7a509cdbce469c65858af29aba5c1946 gpu/mixed_high_indegree-float32-r0/arrival-order.npz +044aac9e7e4d3090c12050da10a3d9d229bf4b0ae1df0cd0535fe942af809d39 gpu/mixed_high_indegree-float32-r0/comparison.json +f813da02775ee2a2afb9a746f296a73f37c9b3f075dafcca2bd3c0419eca633d gpu/mixed_high_indegree-float32-r0/metrics.json +01236a09e7f4733d433735dba293ebf7257129abaa03e6dc106608840de92cb8 gpu/mixed_high_indegree-float32-r0/state.npz +7ec4a257b6abfecb829c61463bdac87a7a509cdbce469c65858af29aba5c1946 gpu/mixed_high_indegree-float32-r1/arrival-order.npz +55f6b0bdb442a9acd960e192afac270ea94c2ca3e98025a6e3079062f7100f5a gpu/mixed_high_indegree-float32-r1/comparison.json +42a0a24721e7b82b2f4917772e31ef7b44b9e18c2425acf5cac70dbc17e94a76 gpu/mixed_high_indegree-float32-r1/metrics.json +01236a09e7f4733d433735dba293ebf7257129abaa03e6dc106608840de92cb8 gpu/mixed_high_indegree-float32-r1/state.npz +7ec4a257b6abfecb829c61463bdac87a7a509cdbce469c65858af29aba5c1946 gpu/mixed_high_indegree-float32-r2/arrival-order.npz +62059fef31d576e96845b35ee83b6c28fab57377b63818fda89dd8ee151c5ebc gpu/mixed_high_indegree-float32-r2/comparison.json +132437c4c769a5b576b10c846355029af268c337ebfe19e1ae2b2a5ed37cc0c2 gpu/mixed_high_indegree-float32-r2/metrics.json +01236a09e7f4733d433735dba293ebf7257129abaa03e6dc106608840de92cb8 gpu/mixed_high_indegree-float32-r2/state.npz +7ec4a257b6abfecb829c61463bdac87a7a509cdbce469c65858af29aba5c1946 gpu/mixed_high_indegree-float64-r0/arrival-order.npz +7a5187b10bdfa9e2af4db7d6597d8aa02faadf4901a233ced2ed0be2450f124d gpu/mixed_high_indegree-float64-r0/comparison.json +bcc2f3f5918c514523b959f691cde82c3c9f3000c45d17191cc1d77c85edc005 gpu/mixed_high_indegree-float64-r0/metrics.json +7e3c2772c827da3aa7a57a0b92a20574def7db5f091e0a3ee585dbdd16a91b89 gpu/mixed_high_indegree-float64-r0/state.npz +7ec4a257b6abfecb829c61463bdac87a7a509cdbce469c65858af29aba5c1946 gpu/mixed_high_indegree-float64-r1/arrival-order.npz +73cc0c59195c1a2c3d4bc16da431aff42a885286679ca0cd809bc182c8e8d792 gpu/mixed_high_indegree-float64-r1/comparison.json +f98a32f498450333889a7e486c4d5277b2746f2d206f61ec0b146c6124a0cdd9 gpu/mixed_high_indegree-float64-r1/metrics.json +7e3c2772c827da3aa7a57a0b92a20574def7db5f091e0a3ee585dbdd16a91b89 gpu/mixed_high_indegree-float64-r1/state.npz +7ec4a257b6abfecb829c61463bdac87a7a509cdbce469c65858af29aba5c1946 gpu/mixed_high_indegree-float64-r2/arrival-order.npz +d5d6ad513373ccc7d48a795f51c7705427c1a92124f8cd75e173575aed40d5dc gpu/mixed_high_indegree-float64-r2/comparison.json +7f893e0fe56dcaa98d3748056c103a7eee7d10139ef8f970dc0f108d356bfeb2 gpu/mixed_high_indegree-float64-r2/metrics.json +7e3c2772c827da3aa7a57a0b92a20574def7db5f091e0a3ee585dbdd16a91b89 gpu/mixed_high_indegree-float64-r2/state.npz +62be726e31f00cc312563cc76b1f2c66e377e25756f03c117e7f9e4f8c961fc9 gpu/motif_feedforward-float32-r0/arrival-order.npz +f722721c2ed148c0afa53ef49f5914a828b01b877972eb6b56134f7839fb1731 gpu/motif_feedforward-float32-r0/comparison.json +31f5a7526d2d67c8d984c1527a274663c2c365da746132b210bccbf65ea94623 gpu/motif_feedforward-float32-r0/metrics.json +024acc8994c5f655712728217e20655853ef7c1b20bf3d4472a7cba7d4cd1188 gpu/motif_feedforward-float32-r0/state.npz +62be726e31f00cc312563cc76b1f2c66e377e25756f03c117e7f9e4f8c961fc9 gpu/motif_feedforward-float32-r1/arrival-order.npz +450453289e7fb360414c8938478e1780bc935d8d408cc5c4b8bb280b35ec343f gpu/motif_feedforward-float32-r1/comparison.json +189d25ed00771d2c8d38e72ad63563324f5840c244fda0e7331b380a2fb072bf gpu/motif_feedforward-float32-r1/metrics.json +024acc8994c5f655712728217e20655853ef7c1b20bf3d4472a7cba7d4cd1188 gpu/motif_feedforward-float32-r1/state.npz +62be726e31f00cc312563cc76b1f2c66e377e25756f03c117e7f9e4f8c961fc9 gpu/motif_feedforward-float32-r2/arrival-order.npz +65471b4a94fde3168e213673053c36031c466c2ff072ffb2152486319fa01acd gpu/motif_feedforward-float32-r2/comparison.json +bd413aff41252ec4ee5ac7d4da2bc6afbd3a6841e42bccdbe7fc94db0ddaa12a gpu/motif_feedforward-float32-r2/metrics.json +024acc8994c5f655712728217e20655853ef7c1b20bf3d4472a7cba7d4cd1188 gpu/motif_feedforward-float32-r2/state.npz +62be726e31f00cc312563cc76b1f2c66e377e25756f03c117e7f9e4f8c961fc9 gpu/motif_feedforward-float64-r0/arrival-order.npz +81cab1ca080eeabb69b85affba0a9f14b0106d6eeee58ab7db612d989000a1f0 gpu/motif_feedforward-float64-r0/comparison.json +3e8cde3092183a88c0b060af8db47b0e0f50231e7e36f7aa10c78e5317b7fd36 gpu/motif_feedforward-float64-r0/metrics.json +7c519ed44d9525561097841839a38009afb82fb3f697e29b9d51a53d37978913 gpu/motif_feedforward-float64-r0/state.npz +62be726e31f00cc312563cc76b1f2c66e377e25756f03c117e7f9e4f8c961fc9 gpu/motif_feedforward-float64-r1/arrival-order.npz +3c0e6b05be5d9bb32fd4f38a2a32524dc8ce3193fe24a9b55fbffc63d37c1573 gpu/motif_feedforward-float64-r1/comparison.json +ff0e89efa83ecc0f81ad09841d2d44de327ce6ede08615b563a7d81d9dc35795 gpu/motif_feedforward-float64-r1/metrics.json +7c519ed44d9525561097841839a38009afb82fb3f697e29b9d51a53d37978913 gpu/motif_feedforward-float64-r1/state.npz +62be726e31f00cc312563cc76b1f2c66e377e25756f03c117e7f9e4f8c961fc9 gpu/motif_feedforward-float64-r2/arrival-order.npz +171023bfd3fe1fb454affa1f84064422b2b318aa84a28126ce6c2cfc8f99edbb gpu/motif_feedforward-float64-r2/comparison.json +a04dbd55eba875b163d0e63f8600bf7d12e54c4fd71df93c620982179da70e4c gpu/motif_feedforward-float64-r2/metrics.json +7c519ed44d9525561097841839a38009afb82fb3f697e29b9d51a53d37978913 gpu/motif_feedforward-float64-r2/state.npz +8ece97e02478970cf56ad1192c6c31f1010893ca70732b4c56a12e4c46defb1f gpu/motif_five-float32-r0/arrival-order.npz +8e7bf7c087c98d80068f16f8b18cba08e82be69c7c0fe7bd2175fbb1a3e1e127 gpu/motif_five-float32-r0/comparison.json +1cde729f2b204cb2a0dd2aee5144d68df18d35b2964126cfedef6f276d7e735b gpu/motif_five-float32-r0/metrics.json +97f03620e6639710769fa30b0b40553be6ebeee424de12e43604943cff723a06 gpu/motif_five-float32-r0/state.npz +8ece97e02478970cf56ad1192c6c31f1010893ca70732b4c56a12e4c46defb1f gpu/motif_five-float32-r1/arrival-order.npz +2ce1a054f63f1b70e9b517d4804bbce40846a2758a6f225edf8f2d92323097ed gpu/motif_five-float32-r1/comparison.json +c77ef2df1ebf63edc5bf05f2ff5dd0a25973b68a445e515cca47f67dc586e0ab gpu/motif_five-float32-r1/metrics.json +97f03620e6639710769fa30b0b40553be6ebeee424de12e43604943cff723a06 gpu/motif_five-float32-r1/state.npz +8ece97e02478970cf56ad1192c6c31f1010893ca70732b4c56a12e4c46defb1f gpu/motif_five-float32-r2/arrival-order.npz +a9e790b00eef82de3d39dbc219bd5b893cc751e199dc4d6792488b4098cca0ca gpu/motif_five-float32-r2/comparison.json +be2a565f4b3100f4250815a71274723e491495abc561a6c4e477ac1e49946ed9 gpu/motif_five-float32-r2/metrics.json +97f03620e6639710769fa30b0b40553be6ebeee424de12e43604943cff723a06 gpu/motif_five-float32-r2/state.npz +8ece97e02478970cf56ad1192c6c31f1010893ca70732b4c56a12e4c46defb1f gpu/motif_five-float64-r0/arrival-order.npz +676f5af243f754f5e747f8d66e6308fe2246c119b250432897a6276351a576e8 gpu/motif_five-float64-r0/comparison.json +b524fea4b29c5575610cbfbf282f7cd0f5e3400ce7b2feae54990eb42236db91 gpu/motif_five-float64-r0/metrics.json +efd2987fa121f8e9324329da620e2072e2ecc61d3c89fdec0e8f3de69b712477 gpu/motif_five-float64-r0/state.npz +8ece97e02478970cf56ad1192c6c31f1010893ca70732b4c56a12e4c46defb1f gpu/motif_five-float64-r1/arrival-order.npz +5c5fdee60d3131fd6454ec0af496d3f34630314c8b0dc6ba2d7cf6c24b20979d gpu/motif_five-float64-r1/comparison.json +91117647bac42fc9d3f234a3380641863fd6b4a51eab24221f2bb8fba852162a gpu/motif_five-float64-r1/metrics.json +efd2987fa121f8e9324329da620e2072e2ecc61d3c89fdec0e8f3de69b712477 gpu/motif_five-float64-r1/state.npz +8ece97e02478970cf56ad1192c6c31f1010893ca70732b4c56a12e4c46defb1f gpu/motif_five-float64-r2/arrival-order.npz +a412787c057a232b2d1274cadfa010b5029836a0a6599c0539186c9671f08691 gpu/motif_five-float64-r2/comparison.json +6901ec19e9c344c62d9248d707391e5e4fdeec68ab59669049b8aadde35e81be gpu/motif_five-float64-r2/metrics.json +efd2987fa121f8e9324329da620e2072e2ecc61d3c89fdec0e8f3de69b712477 gpu/motif_five-float64-r2/state.npz +b64e6a697db766a6b54d24d3d01959986e8d5f303feaa10e9b55160ca71788ed gpu/motif_no_input-float32-r0/arrival-order.npz +069cc644ac74aba235f5de81f8d425b6730fd02111e5fd916dc4a20e5d50f547 gpu/motif_no_input-float32-r0/comparison.json +e76b9edb18ad6665b7eb2e737ac910fdb4e841b8fa5fb474c1263715898c0f24 gpu/motif_no_input-float32-r0/metrics.json +8017dd6abcffcd39d6a9156f726d8df53d4c14a17b45bb8c9c45bb55d26e48e3 gpu/motif_no_input-float32-r0/state.npz +b64e6a697db766a6b54d24d3d01959986e8d5f303feaa10e9b55160ca71788ed gpu/motif_no_input-float32-r1/arrival-order.npz +0cc735ae6f634ea4427e04f6591b808f057ca44ab33170f5d8e1e7a988fc9e8b gpu/motif_no_input-float32-r1/comparison.json +4d01c6d9616275aa788a6a485f2278b07e46c114d0c1d7bbf1399f71fc8fe59f gpu/motif_no_input-float32-r1/metrics.json +8017dd6abcffcd39d6a9156f726d8df53d4c14a17b45bb8c9c45bb55d26e48e3 gpu/motif_no_input-float32-r1/state.npz +b64e6a697db766a6b54d24d3d01959986e8d5f303feaa10e9b55160ca71788ed gpu/motif_no_input-float32-r2/arrival-order.npz +6696d8a5168715a985464d7893d0261813bacb3eff85b4a3edadd9b781fe5d84 gpu/motif_no_input-float32-r2/comparison.json +4cc9848437df51ac61fc9c9734070f0c09ee87c6fadc48009dd6d8d9fc0610e9 gpu/motif_no_input-float32-r2/metrics.json +8017dd6abcffcd39d6a9156f726d8df53d4c14a17b45bb8c9c45bb55d26e48e3 gpu/motif_no_input-float32-r2/state.npz +b64e6a697db766a6b54d24d3d01959986e8d5f303feaa10e9b55160ca71788ed gpu/motif_no_input-float64-r0/arrival-order.npz +b9f97cc5134b6506c8ca1bbfcc0e1b5542c7c26051053446128fd29e67eca866 gpu/motif_no_input-float64-r0/comparison.json +e064174f4fc484ea2b6efa3246dd85cb2c8b3113cf9bd199ac25387ecda23e16 gpu/motif_no_input-float64-r0/metrics.json +b3820b4dabe9c5a3243a270d4fcb52f13a3b7925b795948e0152ed3d0185e6a2 gpu/motif_no_input-float64-r0/state.npz +b64e6a697db766a6b54d24d3d01959986e8d5f303feaa10e9b55160ca71788ed gpu/motif_no_input-float64-r1/arrival-order.npz +60f034535db6d3d897805cb82c33a702e4d87eeededae8e8af95d7cbcd600ee5 gpu/motif_no_input-float64-r1/comparison.json +7c16b3e776a8ebc161114a76899097c7fe41c94618bc6b21aa1c06e5dcdc6ec8 gpu/motif_no_input-float64-r1/metrics.json +b3820b4dabe9c5a3243a270d4fcb52f13a3b7925b795948e0152ed3d0185e6a2 gpu/motif_no_input-float64-r1/state.npz +b64e6a697db766a6b54d24d3d01959986e8d5f303feaa10e9b55160ca71788ed gpu/motif_no_input-float64-r2/arrival-order.npz +aea6fd5b29d1d2b301fad4dcd45baca49d2e68a1b8e236f44d41847565eee984 gpu/motif_no_input-float64-r2/comparison.json +993b0d94f5f35149c25c304f19d453707e21335901fd60affdc2f8e54950f8a5 gpu/motif_no_input-float64-r2/metrics.json +b3820b4dabe9c5a3243a270d4fcb52f13a3b7925b795948e0152ed3d0185e6a2 gpu/motif_no_input-float64-r2/state.npz +2bead61b9fc1384019bb1842008ba86f752ffec242fff21bb7560a2f28b4a2d4 gpu/motif_pair-float32-r0/arrival-order.npz +e19afca3976bf288cff894efc55e7bd8c12f671544031c4c4ea85c0e29c7a095 gpu/motif_pair-float32-r0/comparison.json +f4059a737e317bd31a4fc5444a088c5d16fb8e6ab3dff1a50c97f36229c9737b gpu/motif_pair-float32-r0/metrics.json +8df39e860cedb0b321938c9ae5d36959237c452f4cbdb354730ab6c2311bca20 gpu/motif_pair-float32-r0/state.npz +2bead61b9fc1384019bb1842008ba86f752ffec242fff21bb7560a2f28b4a2d4 gpu/motif_pair-float32-r1/arrival-order.npz +79dd0b8acd03a41c9218986b6389bf4361dd61efc219a128310532318532dac5 gpu/motif_pair-float32-r1/comparison.json +58383925af6d7de1043600e27a5be51da709ce00caccaf824883a115715fb671 gpu/motif_pair-float32-r1/metrics.json +8df39e860cedb0b321938c9ae5d36959237c452f4cbdb354730ab6c2311bca20 gpu/motif_pair-float32-r1/state.npz +2bead61b9fc1384019bb1842008ba86f752ffec242fff21bb7560a2f28b4a2d4 gpu/motif_pair-float32-r2/arrival-order.npz +5bd76b86940c87422c7a45c123943503fb796fc32746e6da9a167378286359fa gpu/motif_pair-float32-r2/comparison.json +68c7c486c42eea81dcd1f6af2236c422154edfaa21761efec4ccd3a12cc3cd30 gpu/motif_pair-float32-r2/metrics.json +8df39e860cedb0b321938c9ae5d36959237c452f4cbdb354730ab6c2311bca20 gpu/motif_pair-float32-r2/state.npz +2bead61b9fc1384019bb1842008ba86f752ffec242fff21bb7560a2f28b4a2d4 gpu/motif_pair-float64-r0/arrival-order.npz +9d8c54acd5ae46ebef18e28d0284f9dc5dccfc5548690bb40b463348f7e434da gpu/motif_pair-float64-r0/comparison.json +4dda6a7c1efb337de1d4045001c34c8c753be1a9f6a2e8b7dd554d2bcaea26c1 gpu/motif_pair-float64-r0/metrics.json +5b8eaa6f9a010760b0fee803dace2ca0ebb3fb279281938596b704bece440933 gpu/motif_pair-float64-r0/state.npz +2bead61b9fc1384019bb1842008ba86f752ffec242fff21bb7560a2f28b4a2d4 gpu/motif_pair-float64-r1/arrival-order.npz +7447ab06a506aa0ca2a69c64fedd79973c8249ec120c67e0e882f7f8773b77d8 gpu/motif_pair-float64-r1/comparison.json +3605b358e707431fb11428ff58ded32c0a2a1b580a8a3b30960a361c3092e1eb gpu/motif_pair-float64-r1/metrics.json +5b8eaa6f9a010760b0fee803dace2ca0ebb3fb279281938596b704bece440933 gpu/motif_pair-float64-r1/state.npz +2bead61b9fc1384019bb1842008ba86f752ffec242fff21bb7560a2f28b4a2d4 gpu/motif_pair-float64-r2/arrival-order.npz +ed5ed460d0f71c371f053e0bef2e1434db9733461715075b45135ab51821b896 gpu/motif_pair-float64-r2/comparison.json +1bd7c6284304465170973724b3892c3c5fdf7710a4b7bdc1022cd95148385abd gpu/motif_pair-float64-r2/metrics.json +5b8eaa6f9a010760b0fee803dace2ca0ebb3fb279281938596b704bece440933 gpu/motif_pair-float64-r2/state.npz +b65eac2120376c86013611c6a7f73d460f8276089c4a7099ce3a0d6c89694469 gpu/motif_trio-float32-r0/arrival-order.npz +06070c6028ab04a0ff1062021a30aa9916c3d57be951373cd9c5cf85b435e83a gpu/motif_trio-float32-r0/comparison.json +fdd59ec33881edc9d8e8b7523cd01167da730aa4b4a095cabaf520ba488c623d gpu/motif_trio-float32-r0/metrics.json +d7e0d15bc95c54a389a6f2df8986273d493e61e76cd60b4a8c3a5a2a62f441d3 gpu/motif_trio-float32-r0/state.npz +b65eac2120376c86013611c6a7f73d460f8276089c4a7099ce3a0d6c89694469 gpu/motif_trio-float32-r1/arrival-order.npz +2ab4f0357307ec6137eb80bf0e3194d67227fb7bc256b68076effe8e25868db7 gpu/motif_trio-float32-r1/comparison.json +6fb4a69f6963b2541254f0051e9df99a3f32472b9d90cfc775fbe857c50a16f6 gpu/motif_trio-float32-r1/metrics.json +d7e0d15bc95c54a389a6f2df8986273d493e61e76cd60b4a8c3a5a2a62f441d3 gpu/motif_trio-float32-r1/state.npz +b65eac2120376c86013611c6a7f73d460f8276089c4a7099ce3a0d6c89694469 gpu/motif_trio-float32-r2/arrival-order.npz +c433bb2c1f27208ab7a92577fe5421a0dce9422ad8009251e006d147e94068db gpu/motif_trio-float32-r2/comparison.json +3e8ccdd69164d8efb32d6c57dca3f9654eed7d7a2251331b1bd3623ef820964b gpu/motif_trio-float32-r2/metrics.json +d7e0d15bc95c54a389a6f2df8986273d493e61e76cd60b4a8c3a5a2a62f441d3 gpu/motif_trio-float32-r2/state.npz +b65eac2120376c86013611c6a7f73d460f8276089c4a7099ce3a0d6c89694469 gpu/motif_trio-float64-r0/arrival-order.npz +67dfe0b913635f72363d85a720a93ed95c90f5b554319676ef5d86e366d6d454 gpu/motif_trio-float64-r0/comparison.json +9c7a3e46de47a43265fbc6a0fc3b7fff2dcf638edd1584c78a4af57f9d58ce31 gpu/motif_trio-float64-r0/metrics.json +6769bad069a1523a1dba9c696f0412189421012b55dd38b65177a060b9a256e6 gpu/motif_trio-float64-r0/state.npz +b65eac2120376c86013611c6a7f73d460f8276089c4a7099ce3a0d6c89694469 gpu/motif_trio-float64-r1/arrival-order.npz +4925f8501521d159702d6b701d815499c9369bb148003afd7a5d3987f913f218 gpu/motif_trio-float64-r1/comparison.json +31fbb95cceb1da812335ca8b9dd7717f65a930359d83bc7a863bd9f25d660220 gpu/motif_trio-float64-r1/metrics.json +6769bad069a1523a1dba9c696f0412189421012b55dd38b65177a060b9a256e6 gpu/motif_trio-float64-r1/state.npz +b65eac2120376c86013611c6a7f73d460f8276089c4a7099ce3a0d6c89694469 gpu/motif_trio-float64-r2/arrival-order.npz +75734d45ab6bc68268ab2bfa8d1c978e74289f1733f12c3e093e25b0e62c2412 gpu/motif_trio-float64-r2/comparison.json +6b4701ce099dcdb7847a106437b6a227cc1c7f48e7b943bfd1112b388381e4d8 gpu/motif_trio-float64-r2/metrics.json +6769bad069a1523a1dba9c696f0412189421012b55dd38b65177a060b9a256e6 gpu/motif_trio-float64-r2/state.npz +382a48347757d1b56bca51ff93f38273d36ad2a0b856d45b11d9c54bd697ad48 gpu/ordered_cancellation-float32-r0/arrival-order.npz +97e70b9338f2bd351f477de44423eaf23dfc096f3763267d6b36ac82f879fd1f gpu/ordered_cancellation-float32-r0/comparison.json +e1c51742ddab9b387935ce91750317ba78ce46384420263fcf7398551c062f6e gpu/ordered_cancellation-float32-r0/metrics.json +8ae98291cfde67cd7c9a353b1e66c0a7141a053fd52df9aff7b78cff9fbb53bd gpu/ordered_cancellation-float32-r0/state.npz +382a48347757d1b56bca51ff93f38273d36ad2a0b856d45b11d9c54bd697ad48 gpu/ordered_cancellation-float32-r1/arrival-order.npz +e08c95274102540fe4201f6d708388853fe87f39a0c1cc54035cccc1f819fc79 gpu/ordered_cancellation-float32-r1/comparison.json +d4e1ea55b64bd29dd691c3b61ec51c53d2407190cc3260a6288d86ecc6c5ee0a gpu/ordered_cancellation-float32-r1/metrics.json +8ae98291cfde67cd7c9a353b1e66c0a7141a053fd52df9aff7b78cff9fbb53bd gpu/ordered_cancellation-float32-r1/state.npz +382a48347757d1b56bca51ff93f38273d36ad2a0b856d45b11d9c54bd697ad48 gpu/ordered_cancellation-float32-r2/arrival-order.npz +863173342d260b41f003ea3cf231460390ce62266b4c87bad99940811355f946 gpu/ordered_cancellation-float32-r2/comparison.json +3f7e854fe53979703c4641a4be9b22ad91d063885aac8f18bc4883bcfa4aaa6e gpu/ordered_cancellation-float32-r2/metrics.json +8ae98291cfde67cd7c9a353b1e66c0a7141a053fd52df9aff7b78cff9fbb53bd gpu/ordered_cancellation-float32-r2/state.npz +382a48347757d1b56bca51ff93f38273d36ad2a0b856d45b11d9c54bd697ad48 gpu/ordered_cancellation-float64-r0/arrival-order.npz +ce34e9cb3dd179e507d258f6c1dada410890dc609510d2baa1cba2034d7819b7 gpu/ordered_cancellation-float64-r0/comparison.json +c783ddcb8f98072d3aeb3d5008cefa52a7df093c1e21c01168ec0d94ad494848 gpu/ordered_cancellation-float64-r0/metrics.json +bba48e6dd9cba9cec4b16a68488dc0dc2d23e9281081e1b1105a1a6135182ebc gpu/ordered_cancellation-float64-r0/state.npz +382a48347757d1b56bca51ff93f38273d36ad2a0b856d45b11d9c54bd697ad48 gpu/ordered_cancellation-float64-r1/arrival-order.npz +f4198ff2aa762a34bf811def8a89f521deea5d348fb6d83c689f6e2e9f7503b6 gpu/ordered_cancellation-float64-r1/comparison.json +fe5ab94117a5e9db792fc4b1cd2dcb832d70d3f3f3ca99ed78dae7b05fd4b783 gpu/ordered_cancellation-float64-r1/metrics.json +bba48e6dd9cba9cec4b16a68488dc0dc2d23e9281081e1b1105a1a6135182ebc gpu/ordered_cancellation-float64-r1/state.npz +382a48347757d1b56bca51ff93f38273d36ad2a0b856d45b11d9c54bd697ad48 gpu/ordered_cancellation-float64-r2/arrival-order.npz +62cfbc2eb26389d75968fa6d5e65dfc59293484a947c94a49656e03192953142 gpu/ordered_cancellation-float64-r2/comparison.json +170294aa0b4eb36d5be2e9bf1e2c8fac999a751263a56e351c07066acfa2e800 gpu/ordered_cancellation-float64-r2/metrics.json +bba48e6dd9cba9cec4b16a68488dc0dc2d23e9281081e1b1105a1a6135182ebc gpu/ordered_cancellation-float64-r2/state.npz +4caaa7c58fcc40dbf9fff220ac032d11817f015d014f3442c86614fcc29ffd9a gpu/release_selfloop-float32-r0/arrival-order.npz +9096f1e0b7bd2f0636f982c7e9d336b335630de1475988507f42570ee5ec8fbc gpu/release_selfloop-float32-r0/comparison.json +943c2eb1ebb59d266ed472d5ed765f594a7d726d0b0abd36fda0120617d02246 gpu/release_selfloop-float32-r0/metrics.json +a02198bd9adfe81bb52deed7719ed0cba660f24c609f1cd436950450bc70bc02 gpu/release_selfloop-float32-r0/state.npz +4caaa7c58fcc40dbf9fff220ac032d11817f015d014f3442c86614fcc29ffd9a gpu/release_selfloop-float32-r1/arrival-order.npz +93d69eba07971c0bdd620b2bf036ffae73c6e2cdba0297ac9c6fa62c58a3f70c gpu/release_selfloop-float32-r1/comparison.json +a7873bb08820fc2bc1700259cefea2e144d150dee2d63bf9612a066d0a87c7c5 gpu/release_selfloop-float32-r1/metrics.json +a02198bd9adfe81bb52deed7719ed0cba660f24c609f1cd436950450bc70bc02 gpu/release_selfloop-float32-r1/state.npz +4caaa7c58fcc40dbf9fff220ac032d11817f015d014f3442c86614fcc29ffd9a gpu/release_selfloop-float32-r2/arrival-order.npz +4dc94196990f8acaa09c656a216d72d2c5da008262da634221466faaed129914 gpu/release_selfloop-float32-r2/comparison.json +762363b9400578440025f92904222bcb5f8d43f9449618c55755d89bf2e60bf2 gpu/release_selfloop-float32-r2/metrics.json +a02198bd9adfe81bb52deed7719ed0cba660f24c609f1cd436950450bc70bc02 gpu/release_selfloop-float32-r2/state.npz +4caaa7c58fcc40dbf9fff220ac032d11817f015d014f3442c86614fcc29ffd9a gpu/release_selfloop-float64-r0/arrival-order.npz +0b1d71d2572f4aee6f0860cb7c942007e86385d4b89d86c8bed4781b9a18f693 gpu/release_selfloop-float64-r0/comparison.json +b81cc105366bd6cb500d4a30447250eef46d6c4f4ecfba56476a12a2604cee4a gpu/release_selfloop-float64-r0/metrics.json +352dbf73a16a8c04faf5d7ab77f7490a85ad95be709e7a6214da02d05a187ca9 gpu/release_selfloop-float64-r0/state.npz +4caaa7c58fcc40dbf9fff220ac032d11817f015d014f3442c86614fcc29ffd9a gpu/release_selfloop-float64-r1/arrival-order.npz +31c9f680ff76a56c66aa1c9e931dc5cd20a98466982ba198af898d9a5303b41e gpu/release_selfloop-float64-r1/comparison.json +3799bdeaef2d1243500774ca38b33e188b9a684e887fb742583e1ea3df19a0b1 gpu/release_selfloop-float64-r1/metrics.json +352dbf73a16a8c04faf5d7ab77f7490a85ad95be709e7a6214da02d05a187ca9 gpu/release_selfloop-float64-r1/state.npz +4caaa7c58fcc40dbf9fff220ac032d11817f015d014f3442c86614fcc29ffd9a gpu/release_selfloop-float64-r2/arrival-order.npz +5b8436161d014ac5e8182363dabe071d2fad9c3941773fa850b45dfe6ccafcb6 gpu/release_selfloop-float64-r2/comparison.json +786ff8d1e2203fe101596ad802bf3f3aa2fbb75a93c973647d224864ff3d68e9 gpu/release_selfloop-float64-r2/metrics.json +352dbf73a16a8c04faf5d7ab77f7490a85ad95be709e7a6214da02d05a187ca9 gpu/release_selfloop-float64-r2/state.npz +f01cc11d373062be750def8db397521205986b6dfd60ebc2089ec9c4377056ad gpu/signed_random-float32-r0/arrival-order.npz +a1ace6d4c542a2bf257f09424dd564caf5f13f876833baf0d213bc301f564740 gpu/signed_random-float32-r0/comparison.json +ac2c60aed61a50d169d0f30974c7d609cf05c39604ad10c36807129f05044296 gpu/signed_random-float32-r0/metrics.json +4e422db27ba6622b0ef6f76b160baa26416f81c3e5421bdae561bf29a4c71c86 gpu/signed_random-float32-r0/state.npz +f01cc11d373062be750def8db397521205986b6dfd60ebc2089ec9c4377056ad gpu/signed_random-float32-r1/arrival-order.npz +293390081bb82b98456e07efb2be5ac2ea75ca61e583c47df3e2893df624eae5 gpu/signed_random-float32-r1/comparison.json +42b06a42e3821a6b042b775bd9120a5cd5cd9ae49fc90f233e9f15972390bbc7 gpu/signed_random-float32-r1/metrics.json +4e422db27ba6622b0ef6f76b160baa26416f81c3e5421bdae561bf29a4c71c86 gpu/signed_random-float32-r1/state.npz +f01cc11d373062be750def8db397521205986b6dfd60ebc2089ec9c4377056ad gpu/signed_random-float32-r2/arrival-order.npz +ab194323647dc23c0f79b310146c4ed63f01634147b41c286337ba4c995747b1 gpu/signed_random-float32-r2/comparison.json +4f177d07d8f8510414aba5d75e6de7d9b61a856bae5f2c84ae1484f3275d7b06 gpu/signed_random-float32-r2/metrics.json +4e422db27ba6622b0ef6f76b160baa26416f81c3e5421bdae561bf29a4c71c86 gpu/signed_random-float32-r2/state.npz +f01cc11d373062be750def8db397521205986b6dfd60ebc2089ec9c4377056ad gpu/signed_random-float64-r0/arrival-order.npz +dcbc03b01b1bab61256546c12bacdabb1067d0cf862198333b56158331d50285 gpu/signed_random-float64-r0/comparison.json +2067336a1093ecb37540c92b4d52ba5988a3631b72cc0a41fafbc5f3347ac4be gpu/signed_random-float64-r0/metrics.json +844194cf8d237bef1827f9209fb61832e9677d0407262dc0cd56dcdd691131b6 gpu/signed_random-float64-r0/state.npz +f01cc11d373062be750def8db397521205986b6dfd60ebc2089ec9c4377056ad gpu/signed_random-float64-r1/arrival-order.npz +57b6a2e47242160623c0fd85467e0c49987f8c94bb46484047effbebc676c872 gpu/signed_random-float64-r1/comparison.json +b22191dccd7f29e70fc5af69a4ef1cbee82054fa47e15155b13871d52a60687f gpu/signed_random-float64-r1/metrics.json +844194cf8d237bef1827f9209fb61832e9677d0407262dc0cd56dcdd691131b6 gpu/signed_random-float64-r1/state.npz +f01cc11d373062be750def8db397521205986b6dfd60ebc2089ec9c4377056ad gpu/signed_random-float64-r2/arrival-order.npz +e3a1de9283170ef928d9f9178f8620f5ae251819c8d28b15e567d54d506210c0 gpu/signed_random-float64-r2/comparison.json +a0d5d7816d48e15f19c8343f0c2e7cf9205334c3255baa70c625546dbbcd7ecf gpu/signed_random-float64-r2/metrics.json +844194cf8d237bef1827f9209fb61832e9677d0407262dc0cd56dcdd691131b6 gpu/signed_random-float64-r2/state.npz +b64e6a697db766a6b54d24d3d01959986e8d5f303feaa10e9b55160ca71788ed gpu/threshold_rounding-float32-r0/arrival-order.npz +8739225c90857ab6c2b9e8e486c224e12ec65466e10129f71ce288fab6266c7d gpu/threshold_rounding-float32-r0/comparison.json +ae27ea25d3c1e39716bc1ec6c81897efc528398ce45fa39e0e49bdaecac3ca2b gpu/threshold_rounding-float32-r0/metrics.json +a77e88223658f1ad8346e714e1aeac304e33889ca4c37cf378149f19c414a33d gpu/threshold_rounding-float32-r0/state.npz +b64e6a697db766a6b54d24d3d01959986e8d5f303feaa10e9b55160ca71788ed gpu/threshold_rounding-float32-r1/arrival-order.npz +a10bb1a007ef61c4cb33ff5e0f640ce9a396d7b32b3c80ca6de48bff4f0491ed gpu/threshold_rounding-float32-r1/comparison.json +58858c943191b48a6defe7dc9e5171997f06a4cb70b7244d511cf287ba12bf88 gpu/threshold_rounding-float32-r1/metrics.json +a77e88223658f1ad8346e714e1aeac304e33889ca4c37cf378149f19c414a33d gpu/threshold_rounding-float32-r1/state.npz +b64e6a697db766a6b54d24d3d01959986e8d5f303feaa10e9b55160ca71788ed gpu/threshold_rounding-float32-r2/arrival-order.npz +96bdc33ff14f50247dd4a4224ce0bb3d734c80a437147c0baed69588ea3b48f2 gpu/threshold_rounding-float32-r2/comparison.json +86a77aec3230eea856d5b81f12ad7737807ffbaa9e23e78553208dd3a4f2cb93 gpu/threshold_rounding-float32-r2/metrics.json +a77e88223658f1ad8346e714e1aeac304e33889ca4c37cf378149f19c414a33d gpu/threshold_rounding-float32-r2/state.npz +b64e6a697db766a6b54d24d3d01959986e8d5f303feaa10e9b55160ca71788ed gpu/threshold_rounding-float64-r0/arrival-order.npz +61fede1ddcd6e65c014a6310189521df46f437e711ac7659cf7b1bda068edf41 gpu/threshold_rounding-float64-r0/comparison.json +ebee8abadabeae92dca41ba2afe81d68d919bf3652320c02d241d3c75834ff4e gpu/threshold_rounding-float64-r0/metrics.json +0d621a52620987dc588522ba43b9a2823769b80b2f11ad9a71ad5940fb27f893 gpu/threshold_rounding-float64-r0/state.npz +b64e6a697db766a6b54d24d3d01959986e8d5f303feaa10e9b55160ca71788ed gpu/threshold_rounding-float64-r1/arrival-order.npz +04edfac5ddd74456202aa89df3d3062fd07abe42445b17a038921667715c6a6b gpu/threshold_rounding-float64-r1/comparison.json +89324a2e788074ea518da354f93396643ecf16ff16c1ce4fddffa86b4c3323af gpu/threshold_rounding-float64-r1/metrics.json +0d621a52620987dc588522ba43b9a2823769b80b2f11ad9a71ad5940fb27f893 gpu/threshold_rounding-float64-r1/state.npz +b64e6a697db766a6b54d24d3d01959986e8d5f303feaa10e9b55160ca71788ed gpu/threshold_rounding-float64-r2/arrival-order.npz +c7c9b6572f20a1478827ce792c139bc49461dc113bd3cacc6be9f508b8b14201 gpu/threshold_rounding-float64-r2/comparison.json +c129a9cc8dd60ac96152d5651edc7731851a7812ad48b89441139fdcb87e3aeb gpu/threshold_rounding-float64-r2/metrics.json +0d621a52620987dc588522ba43b9a2823769b80b2f11ad9a71ad5940fb27f893 gpu/threshold_rounding-float64-r2/state.npz +16862647377b64a27506b9bbb608bbccd3b13f62fc0285acccf6461f4b772f2f gpu-reference/extension-build/.ninja_deps +c788a52dce4cffce62d069603fd5f121fad489f6e9176af87ff51020f982f56a gpu-reference/extension-build/.ninja_log +c570f72b9a2f486e104ed3bf5b1b9f2ccc729ecab02046cd62389d629fb4f48f gpu-reference/extension-build/build.ninja +e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 gpu-reference/extension-build/lock +2b5d56ae5b40051b5b2cdaa51cdc39bed86d03bb804594f82b5855c14ec3889c gpu-reference/extension-build/male_cns_lif_deterministic_v2_ext.so +443ab3fb57a26245a7f95ecac415d6b8ed7634cd0ad08a36f73f7a7b1a923c48 gpu-reference/extension-build/phase4p_ext.cuda.o +27d284f6a369221a931251b5a03ce133cc8231a97942567d4efafbfb45483811 gpu-reference/extension-build/phase4p_ext.o +fa7fb04108f2688fed47132c0af29c283727a999161c11e219ed010c15d6147c gpu-reference/extension.json +859d9f55df89add3344e082081644fd81520756118e9106ecec181d3ba0268f2 oracle/fanin_bursts-float32/case.json +934af1eecfdadd2a5cca6313b602b9bbba115e87793a68cc36f7352bc38fca65 oracle/fanin_bursts-float32/coefficients.json +8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6 oracle/fanin_bursts-float32/environment.json +934af1eecfdadd2a5cca6313b602b9bbba115e87793a68cc36f7352bc38fca65 oracle/fanin_bursts-float32/instrumented/coefficients.json +dfbcf815d17465e4c83a54320687e77c3035c5064f6a81a11bffc5ce35ec0dd1 oracle/fanin_bursts-float32/instrumented/compiled-code.json +d8163907696aec1bf853ecccbe301c50efb4abd5b1c76b9a3dfa34f0e9e36c20 oracle/fanin_bursts-float32/instrumented/completeness.csv +87dfbd207929725101477715d0684af71971d93cb279c3e195704b2b939b3f86 oracle/fanin_bursts-float32/instrumented/connectivity.parquet +20705f7f0f81917eb9630b91808b5121c36345e87a7bc9fc026aaf59dcb6cf41 oracle/fanin_bursts-float32/instrumented/generated-code.json +33a8b070a595bbd95b4d1db7db92b73fa3f1b2e07a2065485f2114b9b73e4f56 oracle/fanin_bursts-float32/instrumented/input-audit.json +65d8941a3f1ffaa814d17fb334abe65d9ceb851dd3f35e6861bad6aacfe764c8 oracle/fanin_bursts-float32/instrumented/queue-audit.json +8d5492b7968694e913d3321b10d5779137045d4689fe50ec50b1ef7637d8fc04 oracle/fanin_bursts-float32/instrumented/schedule.json +660c10c905097d76d91bea09c67ca861534196fc720d0e12102bac074a8525f5 oracle/fanin_bursts-float32/instrumented/state.npz +87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09 oracle/fanin_bursts-float32/proxy-validation.json +660c10c905097d76d91bea09c67ca861534196fc720d0e12102bac074a8525f5 oracle/fanin_bursts-float32/state.npz +16fddc439b2ab0090f17f66231b5e2f293f5e9d1d29bcb608434bca256a81cb7 oracle/fanin_bursts-float32/summary.json +2caa1990718d199f371dbf5e685543bc61df67e08a5ad9a2c8bb1e2834a153a4 oracle/fanin_bursts-float32/unwrapped-audit/coefficients.json +82868f03604ec2a12efea07718960e3bfb1c8152950c3b6bc4fd8e1b1d46cf8d oracle/fanin_bursts-float32/unwrapped-audit/compiled-code.json +d8163907696aec1bf853ecccbe301c50efb4abd5b1c76b9a3dfa34f0e9e36c20 oracle/fanin_bursts-float32/unwrapped-audit/completeness.csv +87dfbd207929725101477715d0684af71971d93cb279c3e195704b2b939b3f86 oracle/fanin_bursts-float32/unwrapped-audit/connectivity.parquet +d0a06d99f840cee691987410486bf9537202d3b57177bbd1a9ae8602232b89a4 oracle/fanin_bursts-float32/unwrapped-audit/generated-code.json +aa47b175208838c2cc1f99a3d4b7317c4f5e3158901c11a86b957aa64a23ac5e oracle/fanin_bursts-float32/unwrapped-audit/input-audit.json +33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7 oracle/fanin_bursts-float32/unwrapped-audit/queue-audit.json +42679bfcc102a0ec20fafe7fdf9cc82b02a0b8809931a49502ac6efd669fc9cd oracle/fanin_bursts-float32/unwrapped-audit/schedule.json +b3882b11df437fbc3294af5986bb92c82c3f674ff98e23bcf9fe292a58738793 oracle/fanin_bursts-float32/unwrapped-audit/state.npz +c5403a077e0a8ab4836f49de38fec39080b73b4571ec55d2440995b5aae48218 oracle/fanin_bursts-float64/case.json +bde79d95ef0097b827d5faf4d5658eafc009d8e9fcef1fddd645c953823e3f64 oracle/fanin_bursts-float64/coefficients.json +8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6 oracle/fanin_bursts-float64/environment.json +bde79d95ef0097b827d5faf4d5658eafc009d8e9fcef1fddd645c953823e3f64 oracle/fanin_bursts-float64/instrumented/coefficients.json +dfbcf815d17465e4c83a54320687e77c3035c5064f6a81a11bffc5ce35ec0dd1 oracle/fanin_bursts-float64/instrumented/compiled-code.json +d8163907696aec1bf853ecccbe301c50efb4abd5b1c76b9a3dfa34f0e9e36c20 oracle/fanin_bursts-float64/instrumented/completeness.csv +87dfbd207929725101477715d0684af71971d93cb279c3e195704b2b939b3f86 oracle/fanin_bursts-float64/instrumented/connectivity.parquet +c2767fee958084c4c7b6ebd99e8863ac01cdf8da2c315e77124480853ba4aa3e oracle/fanin_bursts-float64/instrumented/generated-code.json +81ae40f8b9d83c115b2cbfcdbd1f11f0e00856dea3f0c7b8aab81f7079449cec oracle/fanin_bursts-float64/instrumented/input-audit.json +7aa923702ed6527afc381ed6c13c94faea41dbf81f75fd9b596265eb3c31588a oracle/fanin_bursts-float64/instrumented/queue-audit.json +8d5492b7968694e913d3321b10d5779137045d4689fe50ec50b1ef7637d8fc04 oracle/fanin_bursts-float64/instrumented/schedule.json +48d4cf57a0fd4cd83dfad8497042063022a3a6b2214106080da69deaaaf5fa9e oracle/fanin_bursts-float64/instrumented/state.npz +87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09 oracle/fanin_bursts-float64/proxy-validation.json +48d4cf57a0fd4cd83dfad8497042063022a3a6b2214106080da69deaaaf5fa9e oracle/fanin_bursts-float64/state.npz +d8fc44ae9ed135ef63ae84b5901282c987bfb6daa7a1d912402a940f74a2c179 oracle/fanin_bursts-float64/summary.json +934af1eecfdadd2a5cca6313b602b9bbba115e87793a68cc36f7352bc38fca65 oracle/fanin_bursts-float64/unwrapped-audit/coefficients.json +82868f03604ec2a12efea07718960e3bfb1c8152950c3b6bc4fd8e1b1d46cf8d oracle/fanin_bursts-float64/unwrapped-audit/compiled-code.json +d8163907696aec1bf853ecccbe301c50efb4abd5b1c76b9a3dfa34f0e9e36c20 oracle/fanin_bursts-float64/unwrapped-audit/completeness.csv +87dfbd207929725101477715d0684af71971d93cb279c3e195704b2b939b3f86 oracle/fanin_bursts-float64/unwrapped-audit/connectivity.parquet +f131e05fd1393703981f20a4efb5330eb1ec59a6d35688e5a1f2cdc7805e2d74 oracle/fanin_bursts-float64/unwrapped-audit/generated-code.json +32eb33dcf7559fd63fc25806236b5e5328ab6ebb4fd7602b0cd4786bbde28822 oracle/fanin_bursts-float64/unwrapped-audit/input-audit.json +33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7 oracle/fanin_bursts-float64/unwrapped-audit/queue-audit.json +42679bfcc102a0ec20fafe7fdf9cc82b02a0b8809931a49502ac6efd669fc9cd oracle/fanin_bursts-float64/unwrapped-audit/schedule.json +9f70b316dd4dd445ec083b2a46c06ca2a0900a49a2243c90d7958ff55ea2bdc0 oracle/fanin_bursts-float64/unwrapped-audit/state.npz +69211934e3e3f935bc3425652d6c38eeb6513353a88383973a7182078dd26abc oracle/highest_indegree-float32/case.json +75bd398fd03ade662c9ca5fd3be0f0e745fd0e8deb87354bd3c0c116386a9f3a oracle/highest_indegree-float32/coefficients.json +8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6 oracle/highest_indegree-float32/environment.json +75bd398fd03ade662c9ca5fd3be0f0e745fd0e8deb87354bd3c0c116386a9f3a oracle/highest_indegree-float32/instrumented/coefficients.json +d37bbac320791543bdc13106f71c8aab50c345ca93aeee06d49ce26131e5e198 oracle/highest_indegree-float32/instrumented/compiled-code.json +e90a4d12741fbd0bd0b5fdcf447c2664f7dfcdba7930f4e9e7f05811f0b530f4 oracle/highest_indegree-float32/instrumented/completeness.csv +1228ee73ad73051748dd1db62b5063c005471667fd8baacd6a9e76b134024800 oracle/highest_indegree-float32/instrumented/connectivity.parquet +d75ed5f1158d321ceadcdad048ba8a5e65a38d62bfa99f04d50c25bfca6b98c9 oracle/highest_indegree-float32/instrumented/generated-code.json +d60cc4f72357f4669296c0e49c7f9ae387a044fd2d5faf53868566775c919359 oracle/highest_indegree-float32/instrumented/input-audit.json +fe89d26cc141038c4741f890ac07043d24dfc0bc9101a05c2bddbd1d0cd5411e oracle/highest_indegree-float32/instrumented/queue-audit.json +0db2d5f73709934bf7a91db2908a8dc3301614d09490769bf369aad96ee4f0fb oracle/highest_indegree-float32/instrumented/schedule.json +11de500da330704334d9ce2d128aa2bba32decef851c75bc720a59f91fe534d2 oracle/highest_indegree-float32/instrumented/state.npz +87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09 oracle/highest_indegree-float32/proxy-validation.json +11de500da330704334d9ce2d128aa2bba32decef851c75bc720a59f91fe534d2 oracle/highest_indegree-float32/state.npz +d5b91ade99a1407bfa464c75af655c36fb8329ba252967de13ed4829560a788d oracle/highest_indegree-float32/summary.json +7cfc3cd553fcac4fe52bfa455c5f440a8e98a1a621a135500e9a4b16551f6297 oracle/highest_indegree-float32/unwrapped-audit/coefficients.json +9ef07e82240727c9761386ecdd054475050156677e9b0a3a6bc37b845c1f602c oracle/highest_indegree-float32/unwrapped-audit/compiled-code.json +e90a4d12741fbd0bd0b5fdcf447c2664f7dfcdba7930f4e9e7f05811f0b530f4 oracle/highest_indegree-float32/unwrapped-audit/completeness.csv +1228ee73ad73051748dd1db62b5063c005471667fd8baacd6a9e76b134024800 oracle/highest_indegree-float32/unwrapped-audit/connectivity.parquet +1d622ac2f0e046e2edde7dfb62b3fb7b2ce247c3324410782300eeabb1db4253 oracle/highest_indegree-float32/unwrapped-audit/generated-code.json +38747cbcc998615df238c4b2497b88b85bc706e4e95ecde3ef0ed5029a104a39 oracle/highest_indegree-float32/unwrapped-audit/input-audit.json +33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7 oracle/highest_indegree-float32/unwrapped-audit/queue-audit.json +af9f8f7b182f3c780b23e1448888728ad89be2bbaf7ebe5631d6bff7c7ae77db oracle/highest_indegree-float32/unwrapped-audit/schedule.json +b357f85d5670a0553719b59d1980d2d9231427e3cf439e9cb21f87927f501bdd oracle/highest_indegree-float32/unwrapped-audit/state.npz +f838e4bdc1ed3b3641c4da1414bf0d83f788c7f91a5dc18caef9851685a8ca5e oracle/highest_indegree-float64/case.json +2caa1990718d199f371dbf5e685543bc61df67e08a5ad9a2c8bb1e2834a153a4 oracle/highest_indegree-float64/coefficients.json +8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6 oracle/highest_indegree-float64/environment.json +2caa1990718d199f371dbf5e685543bc61df67e08a5ad9a2c8bb1e2834a153a4 oracle/highest_indegree-float64/instrumented/coefficients.json +d37bbac320791543bdc13106f71c8aab50c345ca93aeee06d49ce26131e5e198 oracle/highest_indegree-float64/instrumented/compiled-code.json +e90a4d12741fbd0bd0b5fdcf447c2664f7dfcdba7930f4e9e7f05811f0b530f4 oracle/highest_indegree-float64/instrumented/completeness.csv +1228ee73ad73051748dd1db62b5063c005471667fd8baacd6a9e76b134024800 oracle/highest_indegree-float64/instrumented/connectivity.parquet +4d9691fc82adf6450724f20815681730f7103910537d43c0255fc617cc9d3ef1 oracle/highest_indegree-float64/instrumented/generated-code.json +ee66710153714e771bc38056901694ecf0eeb56c302fa2ef83f8ba43ca4ef432 oracle/highest_indegree-float64/instrumented/input-audit.json +05e668a0b1691bc44d4a2a363a5511afe4d8c930b70e7c24642316eb74226b97 oracle/highest_indegree-float64/instrumented/queue-audit.json +0db2d5f73709934bf7a91db2908a8dc3301614d09490769bf369aad96ee4f0fb oracle/highest_indegree-float64/instrumented/schedule.json +768d39cdeaa17a8b0fa7a64be5ffbe771e4d00c8db2709c4c5cdb0749f6c3455 oracle/highest_indegree-float64/instrumented/state.npz +87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09 oracle/highest_indegree-float64/proxy-validation.json +768d39cdeaa17a8b0fa7a64be5ffbe771e4d00c8db2709c4c5cdb0749f6c3455 oracle/highest_indegree-float64/state.npz +42ce5d10de1b489f5bd17201b7123fe2361f63f0d82ef9cac3c7250461f47b57 oracle/highest_indegree-float64/summary.json +75bd398fd03ade662c9ca5fd3be0f0e745fd0e8deb87354bd3c0c116386a9f3a oracle/highest_indegree-float64/unwrapped-audit/coefficients.json +9ef07e82240727c9761386ecdd054475050156677e9b0a3a6bc37b845c1f602c oracle/highest_indegree-float64/unwrapped-audit/compiled-code.json +e90a4d12741fbd0bd0b5fdcf447c2664f7dfcdba7930f4e9e7f05811f0b530f4 oracle/highest_indegree-float64/unwrapped-audit/completeness.csv +1228ee73ad73051748dd1db62b5063c005471667fd8baacd6a9e76b134024800 oracle/highest_indegree-float64/unwrapped-audit/connectivity.parquet +1cc7dd07015c0edd32145475c9d07b106b43b029636a1b33ba9df39a079c26a3 oracle/highest_indegree-float64/unwrapped-audit/generated-code.json +f051b4f6988c9f27e955d416e38fb077d8172e80605e0c306cfdc6d9a4006791 oracle/highest_indegree-float64/unwrapped-audit/input-audit.json +33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7 oracle/highest_indegree-float64/unwrapped-audit/queue-audit.json +af9f8f7b182f3c780b23e1448888728ad89be2bbaf7ebe5631d6bff7c7ae77db oracle/highest_indegree-float64/unwrapped-audit/schedule.json +59f64a289f8c81c2cca1f50d920b959ee13e4f928ede30d8814a43c1e650fa52 oracle/highest_indegree-float64/unwrapped-audit/state.npz +ff8f69144e361d8e27616e8755a01cace95850383bc337025639f24abd7b31c5 oracle/mixed_high_indegree-float32/case.json +74615669642e49f242e93e6a9c42d22c21438cbcbc0143d6ddca294465e543da oracle/mixed_high_indegree-float32/coefficients.json +8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6 oracle/mixed_high_indegree-float32/environment.json +74615669642e49f242e93e6a9c42d22c21438cbcbc0143d6ddca294465e543da oracle/mixed_high_indegree-float32/instrumented/coefficients.json +d37bbac320791543bdc13106f71c8aab50c345ca93aeee06d49ce26131e5e198 oracle/mixed_high_indegree-float32/instrumented/compiled-code.json +1f01bd89fa27a1fc11336336d420c1100171017febe074713369fcf51db27363 oracle/mixed_high_indegree-float32/instrumented/completeness.csv +21e51e4ecca6476d5116cfbf140b1fdd5a4a0a8ee976158f801dee8003f91ae2 oracle/mixed_high_indegree-float32/instrumented/connectivity.parquet +200ebe53ec57bdf2edf72a520a4a32468d99dc813b1a3720cc72bb3c973dec5a oracle/mixed_high_indegree-float32/instrumented/generated-code.json +45d8d642b41dd122cb262e54654784511353488320cce35add03becabc059912 oracle/mixed_high_indegree-float32/instrumented/input-audit.json +e6b73b067ea95c9bd09c21dd9c83da230b7923edabc41a9a7c0ff00d8c1e5ca4 oracle/mixed_high_indegree-float32/instrumented/queue-audit.json +0db2d5f73709934bf7a91db2908a8dc3301614d09490769bf369aad96ee4f0fb oracle/mixed_high_indegree-float32/instrumented/schedule.json +5df4b542b303e747bbbfbdb057da15e522465e54d6617349ee99f7192e1603f9 oracle/mixed_high_indegree-float32/instrumented/state.npz +87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09 oracle/mixed_high_indegree-float32/proxy-validation.json +5df4b542b303e747bbbfbdb057da15e522465e54d6617349ee99f7192e1603f9 oracle/mixed_high_indegree-float32/state.npz +2984b25862d977a9158164931e10f987fc6eb9364e2ab714df1c3c3fe45af415 oracle/mixed_high_indegree-float32/summary.json +ec5e4c7e313291d044a1447c276582cbb16ade5cc052675bd83c1016a924942e oracle/mixed_high_indegree-float32/unwrapped-audit/coefficients.json +9ef07e82240727c9761386ecdd054475050156677e9b0a3a6bc37b845c1f602c oracle/mixed_high_indegree-float32/unwrapped-audit/compiled-code.json +1f01bd89fa27a1fc11336336d420c1100171017febe074713369fcf51db27363 oracle/mixed_high_indegree-float32/unwrapped-audit/completeness.csv +21e51e4ecca6476d5116cfbf140b1fdd5a4a0a8ee976158f801dee8003f91ae2 oracle/mixed_high_indegree-float32/unwrapped-audit/connectivity.parquet +0711324a1fd18d75f5b243deba0dae9dd992aa54ecd12d5727b91331c1d7faf0 oracle/mixed_high_indegree-float32/unwrapped-audit/generated-code.json +ce31b2c18c0c434c9d09ad8428945de9db815145d7cd97ac6cf64c8319830ddd oracle/mixed_high_indegree-float32/unwrapped-audit/input-audit.json +33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7 oracle/mixed_high_indegree-float32/unwrapped-audit/queue-audit.json +af9f8f7b182f3c780b23e1448888728ad89be2bbaf7ebe5631d6bff7c7ae77db oracle/mixed_high_indegree-float32/unwrapped-audit/schedule.json +1c75ca2a973cb569e5c65984e277c3f5feddbc99643ef50d7fcb844fe00780d4 oracle/mixed_high_indegree-float32/unwrapped-audit/state.npz +73216eb4215f0caa690415f883ee1d1edafbab28701a1c0b2dfa0efc6202c622 oracle/mixed_high_indegree-float64/case.json +5e605becd694eac6bfd450c8590626dce715dc0de442c3e98272567a81503e12 oracle/mixed_high_indegree-float64/coefficients.json +8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6 oracle/mixed_high_indegree-float64/environment.json +5e605becd694eac6bfd450c8590626dce715dc0de442c3e98272567a81503e12 oracle/mixed_high_indegree-float64/instrumented/coefficients.json +d37bbac320791543bdc13106f71c8aab50c345ca93aeee06d49ce26131e5e198 oracle/mixed_high_indegree-float64/instrumented/compiled-code.json +1f01bd89fa27a1fc11336336d420c1100171017febe074713369fcf51db27363 oracle/mixed_high_indegree-float64/instrumented/completeness.csv +21e51e4ecca6476d5116cfbf140b1fdd5a4a0a8ee976158f801dee8003f91ae2 oracle/mixed_high_indegree-float64/instrumented/connectivity.parquet +c342dd96ec558d76650bc92d6e3905b2dca5f984757a65e7313eb7b5fc879d8e oracle/mixed_high_indegree-float64/instrumented/generated-code.json +2ede5c192bca9326d35a9d24ec98eb460e120684d8d25f37223afdfdcd010f2e oracle/mixed_high_indegree-float64/instrumented/input-audit.json +7dbd83f1582516800c4fa4fc7f4a843bf72cff4666556177a42aea474dd0f720 oracle/mixed_high_indegree-float64/instrumented/queue-audit.json +0db2d5f73709934bf7a91db2908a8dc3301614d09490769bf369aad96ee4f0fb oracle/mixed_high_indegree-float64/instrumented/schedule.json +c267e765682525fce86a72d5a86eb921c2d1cef4200172cdc48d1fb41634d727 oracle/mixed_high_indegree-float64/instrumented/state.npz +87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09 oracle/mixed_high_indegree-float64/proxy-validation.json +c267e765682525fce86a72d5a86eb921c2d1cef4200172cdc48d1fb41634d727 oracle/mixed_high_indegree-float64/state.npz +d7e89190cf331bd4624b12e4863a72abe6c330ba205f72e3a1adba6976d2b1e1 oracle/mixed_high_indegree-float64/summary.json +7cfc3cd553fcac4fe52bfa455c5f440a8e98a1a621a135500e9a4b16551f6297 oracle/mixed_high_indegree-float64/unwrapped-audit/coefficients.json +9ef07e82240727c9761386ecdd054475050156677e9b0a3a6bc37b845c1f602c oracle/mixed_high_indegree-float64/unwrapped-audit/compiled-code.json +1f01bd89fa27a1fc11336336d420c1100171017febe074713369fcf51db27363 oracle/mixed_high_indegree-float64/unwrapped-audit/completeness.csv +21e51e4ecca6476d5116cfbf140b1fdd5a4a0a8ee976158f801dee8003f91ae2 oracle/mixed_high_indegree-float64/unwrapped-audit/connectivity.parquet +1d622ac2f0e046e2edde7dfb62b3fb7b2ce247c3324410782300eeabb1db4253 oracle/mixed_high_indegree-float64/unwrapped-audit/generated-code.json +a4324de251964451d25ce4cd4bbe1a3383de9a9930108d22959ac1303655be6f oracle/mixed_high_indegree-float64/unwrapped-audit/input-audit.json +33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7 oracle/mixed_high_indegree-float64/unwrapped-audit/queue-audit.json +af9f8f7b182f3c780b23e1448888728ad89be2bbaf7ebe5631d6bff7c7ae77db oracle/mixed_high_indegree-float64/unwrapped-audit/schedule.json +a97120abc081f9adae3c66518c5375ce3831f891672204bca5707a505077359d oracle/mixed_high_indegree-float64/unwrapped-audit/state.npz +514451ef42e4a1eef22998de3fe9263d84cdc45e83771194d855859b05057eef oracle/motif_feedforward-float32/case.json +ec5e4c7e313291d044a1447c276582cbb16ade5cc052675bd83c1016a924942e oracle/motif_feedforward-float32/coefficients.json +8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6 oracle/motif_feedforward-float32/environment.json +ec5e4c7e313291d044a1447c276582cbb16ade5cc052675bd83c1016a924942e oracle/motif_feedforward-float32/instrumented/coefficients.json +d37bbac320791543bdc13106f71c8aab50c345ca93aeee06d49ce26131e5e198 oracle/motif_feedforward-float32/instrumented/compiled-code.json +301ae4572c658aa307fc998e009377e9c82467d97d66aa1ac4b3f518385ec5a5 oracle/motif_feedforward-float32/instrumented/completeness.csv +627406997fa994afffa6c4df18cc584c43f4161b389a6669c2ceb64e5ae9dcd1 oracle/motif_feedforward-float32/instrumented/connectivity.parquet +9587d16853d78dac3cc8193142de3210c1b2bd3eddd076e0da070cb8544ebd6a oracle/motif_feedforward-float32/instrumented/generated-code.json +7198a08c9241603eb8f0c5c89272ff19c0b8bb4ed7ecc44f3fcdd25a37224287 oracle/motif_feedforward-float32/instrumented/input-audit.json +b4a57dfcb794a3168dbcc76688e07696769def8bada0bd896ddba7355a3a2fdd oracle/motif_feedforward-float32/instrumented/queue-audit.json +0db2d5f73709934bf7a91db2908a8dc3301614d09490769bf369aad96ee4f0fb oracle/motif_feedforward-float32/instrumented/schedule.json +e24ef4caddd186832c767df704c0073253735a6bbfa4381d76a23614ef7c0f8f oracle/motif_feedforward-float32/instrumented/state.npz +87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09 oracle/motif_feedforward-float32/proxy-validation.json +e24ef4caddd186832c767df704c0073253735a6bbfa4381d76a23614ef7c0f8f oracle/motif_feedforward-float32/state.npz +ebb76b8c5795e16816072f00049b59182e6dc8b2dad826d76e65f5fbd4711f4b oracle/motif_feedforward-float32/summary.json +0bf9991cf8a66dc9eed742d7e613b3f1e3ee89bf59e37080324c8f84cbd34a2d oracle/motif_feedforward-float32/unwrapped-audit/coefficients.json +9ef07e82240727c9761386ecdd054475050156677e9b0a3a6bc37b845c1f602c oracle/motif_feedforward-float32/unwrapped-audit/compiled-code.json +301ae4572c658aa307fc998e009377e9c82467d97d66aa1ac4b3f518385ec5a5 oracle/motif_feedforward-float32/unwrapped-audit/completeness.csv +627406997fa994afffa6c4df18cc584c43f4161b389a6669c2ceb64e5ae9dcd1 oracle/motif_feedforward-float32/unwrapped-audit/connectivity.parquet +aa9a755267ea52baca9275599baef199f7a12023b030e9727821fc4ba34cfa89 oracle/motif_feedforward-float32/unwrapped-audit/generated-code.json +85af6959aad3022a8db686ab9b6b295c231d88c85a3b5eeb7cde56bc09438014 oracle/motif_feedforward-float32/unwrapped-audit/input-audit.json +33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7 oracle/motif_feedforward-float32/unwrapped-audit/queue-audit.json +af9f8f7b182f3c780b23e1448888728ad89be2bbaf7ebe5631d6bff7c7ae77db oracle/motif_feedforward-float32/unwrapped-audit/schedule.json +a8e37466c4d915ef75426afb21fb3ba5f373f5ba042ee25b17820da92f0fc0d3 oracle/motif_feedforward-float32/unwrapped-audit/state.npz +9cee3048169b8298e2510b1578a762939cff01f14ff213de17e1a862b6a2362c oracle/motif_feedforward-float64/case.json +7cfc3cd553fcac4fe52bfa455c5f440a8e98a1a621a135500e9a4b16551f6297 oracle/motif_feedforward-float64/coefficients.json +8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6 oracle/motif_feedforward-float64/environment.json +7cfc3cd553fcac4fe52bfa455c5f440a8e98a1a621a135500e9a4b16551f6297 oracle/motif_feedforward-float64/instrumented/coefficients.json +d37bbac320791543bdc13106f71c8aab50c345ca93aeee06d49ce26131e5e198 oracle/motif_feedforward-float64/instrumented/compiled-code.json +301ae4572c658aa307fc998e009377e9c82467d97d66aa1ac4b3f518385ec5a5 oracle/motif_feedforward-float64/instrumented/completeness.csv +627406997fa994afffa6c4df18cc584c43f4161b389a6669c2ceb64e5ae9dcd1 oracle/motif_feedforward-float64/instrumented/connectivity.parquet +f0e4d7b069925eb0132b7ef2e8779d64cfa4eb2fabed7664222944d7338fbff6 oracle/motif_feedforward-float64/instrumented/generated-code.json +df729fbad17510beab496ddd2801ecfc3aa0c17e5e3034bbdd2011a544c174c3 oracle/motif_feedforward-float64/instrumented/input-audit.json +9cb637d33e2e387f22516c317c6e07f622f03b077af0dc2023e14138f0d900d1 oracle/motif_feedforward-float64/instrumented/queue-audit.json +0db2d5f73709934bf7a91db2908a8dc3301614d09490769bf369aad96ee4f0fb oracle/motif_feedforward-float64/instrumented/schedule.json +21f5487f461f02c60c8b23be2f7def85c52d54f95fd00dbcd9b5f1d16d933c3a oracle/motif_feedforward-float64/instrumented/state.npz +87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09 oracle/motif_feedforward-float64/proxy-validation.json +21f5487f461f02c60c8b23be2f7def85c52d54f95fd00dbcd9b5f1d16d933c3a oracle/motif_feedforward-float64/state.npz +6b600b1c3aca917738398e5ed03b0cc7dc4793df7c03b5a2dbdd07747e331b1f oracle/motif_feedforward-float64/summary.json +ec5e4c7e313291d044a1447c276582cbb16ade5cc052675bd83c1016a924942e oracle/motif_feedforward-float64/unwrapped-audit/coefficients.json +9ef07e82240727c9761386ecdd054475050156677e9b0a3a6bc37b845c1f602c oracle/motif_feedforward-float64/unwrapped-audit/compiled-code.json +301ae4572c658aa307fc998e009377e9c82467d97d66aa1ac4b3f518385ec5a5 oracle/motif_feedforward-float64/unwrapped-audit/completeness.csv +627406997fa994afffa6c4df18cc584c43f4161b389a6669c2ceb64e5ae9dcd1 oracle/motif_feedforward-float64/unwrapped-audit/connectivity.parquet +0711324a1fd18d75f5b243deba0dae9dd992aa54ecd12d5727b91331c1d7faf0 oracle/motif_feedforward-float64/unwrapped-audit/generated-code.json +da721733ca6e25552066d11eab447b8ca7f5494fd9780f98b1a10f43d705ffef oracle/motif_feedforward-float64/unwrapped-audit/input-audit.json +33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7 oracle/motif_feedforward-float64/unwrapped-audit/queue-audit.json +af9f8f7b182f3c780b23e1448888728ad89be2bbaf7ebe5631d6bff7c7ae77db oracle/motif_feedforward-float64/unwrapped-audit/schedule.json +8afa811b03d3a51cc0a188511b0eec8d98d5d33e6e9019b44fc598bf91bb5e4b oracle/motif_feedforward-float64/unwrapped-audit/state.npz +0ba654448ad73f8a7d93d026822d4847d107ebdd887e689c3d73b29355ea46b2 oracle/motif_five-float32/case.json +d98eee7b93f944578eebb05b33e94c2515ee82b5753af1eec756a596e7201ac6 oracle/motif_five-float32/coefficients.json +8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6 oracle/motif_five-float32/environment.json +d98eee7b93f944578eebb05b33e94c2515ee82b5753af1eec756a596e7201ac6 oracle/motif_five-float32/instrumented/coefficients.json +d37bbac320791543bdc13106f71c8aab50c345ca93aeee06d49ce26131e5e198 oracle/motif_five-float32/instrumented/compiled-code.json +301ae4572c658aa307fc998e009377e9c82467d97d66aa1ac4b3f518385ec5a5 oracle/motif_five-float32/instrumented/completeness.csv +43ea5a3c6c53315e9265863a6f05b3e6d8e9b9f299aef665e8bbe9c46f9eb2ce oracle/motif_five-float32/instrumented/connectivity.parquet +b5bff1e1272f13317e217bebe95a6f8b85713a59d2fcc3c81cfbdf316f56a839 oracle/motif_five-float32/instrumented/generated-code.json +3ae9c6d4d215251c5f6b0386e853230174156167bcf5c684e9ff0884af12c632 oracle/motif_five-float32/instrumented/input-audit.json +649034e2f1ad4fbdcbc7bc671166e16d5d742629ca65fececf8929a8c2c52e01 oracle/motif_five-float32/instrumented/queue-audit.json +0db2d5f73709934bf7a91db2908a8dc3301614d09490769bf369aad96ee4f0fb oracle/motif_five-float32/instrumented/schedule.json +3463e35fa10471d5abfd8090db1967fd5c2046364ef4e6b7974b710eb225fff2 oracle/motif_five-float32/instrumented/state.npz +87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09 oracle/motif_five-float32/proxy-validation.json +3463e35fa10471d5abfd8090db1967fd5c2046364ef4e6b7974b710eb225fff2 oracle/motif_five-float32/state.npz +9b650e977f4858b37ffc0884920d4143f6f9704921dd6fc1f42ec71f981eef89 oracle/motif_five-float32/summary.json +d01a405ef9b9be1675c66875d972578ff4c506a468388d8e980f8d449e6dc333 oracle/motif_five-float32/unwrapped-audit/coefficients.json +9ef07e82240727c9761386ecdd054475050156677e9b0a3a6bc37b845c1f602c oracle/motif_five-float32/unwrapped-audit/compiled-code.json +301ae4572c658aa307fc998e009377e9c82467d97d66aa1ac4b3f518385ec5a5 oracle/motif_five-float32/unwrapped-audit/completeness.csv +43ea5a3c6c53315e9265863a6f05b3e6d8e9b9f299aef665e8bbe9c46f9eb2ce oracle/motif_five-float32/unwrapped-audit/connectivity.parquet +e7486df9bef2f372e8d69062750e92ff5e458d772e3b634443b3d9b66d68eccd oracle/motif_five-float32/unwrapped-audit/generated-code.json +7ef4d06198b0ce68e84e6e4c793839ead0d9d3d4e4fe573ed1b4f66e7f828a76 oracle/motif_five-float32/unwrapped-audit/input-audit.json +33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7 oracle/motif_five-float32/unwrapped-audit/queue-audit.json +af9f8f7b182f3c780b23e1448888728ad89be2bbaf7ebe5631d6bff7c7ae77db oracle/motif_five-float32/unwrapped-audit/schedule.json +622ddbd3757da831e87ad713d0735c1c3a2132ccea9fa1ef62ebe09ad22a7f75 oracle/motif_five-float32/unwrapped-audit/state.npz +02428504cba1b7275e6fab9e521d4f417b3d6125996836714347534b567afa66 oracle/motif_five-float64/case.json +a75717c29fc1ccf7beb7496183952821a4990365eab5b3c97c7339981903aad4 oracle/motif_five-float64/coefficients.json +8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6 oracle/motif_five-float64/environment.json +a75717c29fc1ccf7beb7496183952821a4990365eab5b3c97c7339981903aad4 oracle/motif_five-float64/instrumented/coefficients.json +d37bbac320791543bdc13106f71c8aab50c345ca93aeee06d49ce26131e5e198 oracle/motif_five-float64/instrumented/compiled-code.json +301ae4572c658aa307fc998e009377e9c82467d97d66aa1ac4b3f518385ec5a5 oracle/motif_five-float64/instrumented/completeness.csv +43ea5a3c6c53315e9265863a6f05b3e6d8e9b9f299aef665e8bbe9c46f9eb2ce oracle/motif_five-float64/instrumented/connectivity.parquet +c8ff56101e28a5c44128e24bef4f2b9fdb133c2f934c3c359b841dd9f309607e oracle/motif_five-float64/instrumented/generated-code.json +570ddf1c205c30f84634851ba251525855538d1b3ec9ca95227474960076d62a oracle/motif_five-float64/instrumented/input-audit.json +405762068db98becc1843db0bf506cfcfb9b3d33353ac9e4e168c0f52d9b49e7 oracle/motif_five-float64/instrumented/queue-audit.json +0db2d5f73709934bf7a91db2908a8dc3301614d09490769bf369aad96ee4f0fb oracle/motif_five-float64/instrumented/schedule.json +cf6ac75da0a75ccdd5ab6ac1b282fae8b8a07128f3e0a3f0106739348f75dfbb oracle/motif_five-float64/instrumented/state.npz +87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09 oracle/motif_five-float64/proxy-validation.json +cf6ac75da0a75ccdd5ab6ac1b282fae8b8a07128f3e0a3f0106739348f75dfbb oracle/motif_five-float64/state.npz +df9c6c8221fdaf65ea5117c650378bcf1b9d53c80c6f4b1b05481d3aa582fef9 oracle/motif_five-float64/summary.json +0bf9991cf8a66dc9eed742d7e613b3f1e3ee89bf59e37080324c8f84cbd34a2d oracle/motif_five-float64/unwrapped-audit/coefficients.json +9ef07e82240727c9761386ecdd054475050156677e9b0a3a6bc37b845c1f602c oracle/motif_five-float64/unwrapped-audit/compiled-code.json +301ae4572c658aa307fc998e009377e9c82467d97d66aa1ac4b3f518385ec5a5 oracle/motif_five-float64/unwrapped-audit/completeness.csv +43ea5a3c6c53315e9265863a6f05b3e6d8e9b9f299aef665e8bbe9c46f9eb2ce oracle/motif_five-float64/unwrapped-audit/connectivity.parquet +aa9a755267ea52baca9275599baef199f7a12023b030e9727821fc4ba34cfa89 oracle/motif_five-float64/unwrapped-audit/generated-code.json +f1ca7891f879fd508bd42f8bdc919deea0c204dbaf694b3e5d7117f7a263c3d9 oracle/motif_five-float64/unwrapped-audit/input-audit.json +33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7 oracle/motif_five-float64/unwrapped-audit/queue-audit.json +af9f8f7b182f3c780b23e1448888728ad89be2bbaf7ebe5631d6bff7c7ae77db oracle/motif_five-float64/unwrapped-audit/schedule.json +550f7324c5a1384084be04f24a90f9107d4452b379252b6cb7a48f9cdc393eaf oracle/motif_five-float64/unwrapped-audit/state.npz +9d179420654413ca1abfb05f22dee6cfb7d51ad2cd6eef69dffc4005c16f0fd6 oracle/motif_no_input-float32/case.json +de979150b8c18ea8a46a876778327a49353eb5a87e5c1d7d9cafb11c9f6d8483 oracle/motif_no_input-float32/coefficients.json +8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6 oracle/motif_no_input-float32/environment.json +de979150b8c18ea8a46a876778327a49353eb5a87e5c1d7d9cafb11c9f6d8483 oracle/motif_no_input-float32/instrumented/coefficients.json +d37bbac320791543bdc13106f71c8aab50c345ca93aeee06d49ce26131e5e198 oracle/motif_no_input-float32/instrumented/compiled-code.json +301ae4572c658aa307fc998e009377e9c82467d97d66aa1ac4b3f518385ec5a5 oracle/motif_no_input-float32/instrumented/completeness.csv +43ea5a3c6c53315e9265863a6f05b3e6d8e9b9f299aef665e8bbe9c46f9eb2ce oracle/motif_no_input-float32/instrumented/connectivity.parquet +e5aa1ab2a7909ec49496dbef2284053c3e1e879b11a18e0fc77e864f12501818 oracle/motif_no_input-float32/instrumented/generated-code.json +3ae9c6d4d215251c5f6b0386e853230174156167bcf5c684e9ff0884af12c632 oracle/motif_no_input-float32/instrumented/input-audit.json +cee965022108973f9b9da6aeb880f6eb1dfb3d75bd613658f7164784da3adb00 oracle/motif_no_input-float32/instrumented/queue-audit.json +0db2d5f73709934bf7a91db2908a8dc3301614d09490769bf369aad96ee4f0fb oracle/motif_no_input-float32/instrumented/schedule.json +fbf19ad2fa292ecfcfbf893047ed0ee1dc411fd7825f728b21147349085177ad oracle/motif_no_input-float32/instrumented/state.npz +87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09 oracle/motif_no_input-float32/proxy-validation.json +fbf19ad2fa292ecfcfbf893047ed0ee1dc411fd7825f728b21147349085177ad oracle/motif_no_input-float32/state.npz +f6714c8b34ba46595deb08f2b87623d8ffb94dbbea423d8319136948e1b2dea1 oracle/motif_no_input-float32/summary.json +a45521c8cc13306fa535adf1cbf9f476b88061351774660f680abf04ee65899d oracle/motif_no_input-float32/unwrapped-audit/coefficients.json +9ef07e82240727c9761386ecdd054475050156677e9b0a3a6bc37b845c1f602c oracle/motif_no_input-float32/unwrapped-audit/compiled-code.json +301ae4572c658aa307fc998e009377e9c82467d97d66aa1ac4b3f518385ec5a5 oracle/motif_no_input-float32/unwrapped-audit/completeness.csv +43ea5a3c6c53315e9265863a6f05b3e6d8e9b9f299aef665e8bbe9c46f9eb2ce oracle/motif_no_input-float32/unwrapped-audit/connectivity.parquet +27e213d76a91871c492e28be66c7a093fd4e1ba5920b7fd87a59f3b5ccca1b05 oracle/motif_no_input-float32/unwrapped-audit/generated-code.json +7ef4d06198b0ce68e84e6e4c793839ead0d9d3d4e4fe573ed1b4f66e7f828a76 oracle/motif_no_input-float32/unwrapped-audit/input-audit.json +33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7 oracle/motif_no_input-float32/unwrapped-audit/queue-audit.json +af9f8f7b182f3c780b23e1448888728ad89be2bbaf7ebe5631d6bff7c7ae77db oracle/motif_no_input-float32/unwrapped-audit/schedule.json +fbf19ad2fa292ecfcfbf893047ed0ee1dc411fd7825f728b21147349085177ad oracle/motif_no_input-float32/unwrapped-audit/state.npz +e09512d3a290d1b67017d8041beee4445dff7338d25ee5a419662ce0fa1e0294 oracle/motif_no_input-float64/case.json +0bf9991cf8a66dc9eed742d7e613b3f1e3ee89bf59e37080324c8f84cbd34a2d oracle/motif_no_input-float64/coefficients.json +8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6 oracle/motif_no_input-float64/environment.json +0bf9991cf8a66dc9eed742d7e613b3f1e3ee89bf59e37080324c8f84cbd34a2d oracle/motif_no_input-float64/instrumented/coefficients.json +d37bbac320791543bdc13106f71c8aab50c345ca93aeee06d49ce26131e5e198 oracle/motif_no_input-float64/instrumented/compiled-code.json +301ae4572c658aa307fc998e009377e9c82467d97d66aa1ac4b3f518385ec5a5 oracle/motif_no_input-float64/instrumented/completeness.csv +43ea5a3c6c53315e9265863a6f05b3e6d8e9b9f299aef665e8bbe9c46f9eb2ce oracle/motif_no_input-float64/instrumented/connectivity.parquet +e2863283352ed45e14e825141be421dc603061254dd7676cd5db972b676990a9 oracle/motif_no_input-float64/instrumented/generated-code.json +570ddf1c205c30f84634851ba251525855538d1b3ec9ca95227474960076d62a oracle/motif_no_input-float64/instrumented/input-audit.json +d7d8e6eba191b4fb6a8876896c9b932e2a908e66cf6e419065d6b7f1cbeda73e oracle/motif_no_input-float64/instrumented/queue-audit.json +0db2d5f73709934bf7a91db2908a8dc3301614d09490769bf369aad96ee4f0fb oracle/motif_no_input-float64/instrumented/schedule.json +4f8b98d81b6b91aeccdf59788e7cfa6a770fe1ac59753fa8c4777776e559fbe1 oracle/motif_no_input-float64/instrumented/state.npz +87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09 oracle/motif_no_input-float64/proxy-validation.json +4f8b98d81b6b91aeccdf59788e7cfa6a770fe1ac59753fa8c4777776e559fbe1 oracle/motif_no_input-float64/state.npz +5f27219565e45f42327bdf33e08d0c38373d6719f932d88454ab0bc5be7c9f7d oracle/motif_no_input-float64/summary.json +d01a405ef9b9be1675c66875d972578ff4c506a468388d8e980f8d449e6dc333 oracle/motif_no_input-float64/unwrapped-audit/coefficients.json +9ef07e82240727c9761386ecdd054475050156677e9b0a3a6bc37b845c1f602c oracle/motif_no_input-float64/unwrapped-audit/compiled-code.json +301ae4572c658aa307fc998e009377e9c82467d97d66aa1ac4b3f518385ec5a5 oracle/motif_no_input-float64/unwrapped-audit/completeness.csv +43ea5a3c6c53315e9265863a6f05b3e6d8e9b9f299aef665e8bbe9c46f9eb2ce oracle/motif_no_input-float64/unwrapped-audit/connectivity.parquet +e7486df9bef2f372e8d69062750e92ff5e458d772e3b634443b3d9b66d68eccd oracle/motif_no_input-float64/unwrapped-audit/generated-code.json +f1ca7891f879fd508bd42f8bdc919deea0c204dbaf694b3e5d7117f7a263c3d9 oracle/motif_no_input-float64/unwrapped-audit/input-audit.json +33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7 oracle/motif_no_input-float64/unwrapped-audit/queue-audit.json +af9f8f7b182f3c780b23e1448888728ad89be2bbaf7ebe5631d6bff7c7ae77db oracle/motif_no_input-float64/unwrapped-audit/schedule.json +4f8b98d81b6b91aeccdf59788e7cfa6a770fe1ac59753fa8c4777776e559fbe1 oracle/motif_no_input-float64/unwrapped-audit/state.npz +7c2e51163cc02ade1ad547b0f80b72e3a2ce41e9ddbc8488c0963ae8cb8b25fd oracle/motif_pair-float32/case.json +a96c603914560bec97c4da88bdc22a77ba3feaf49c83226793b258c67c856b91 oracle/motif_pair-float32/coefficients.json +8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6 oracle/motif_pair-float32/environment.json +a96c603914560bec97c4da88bdc22a77ba3feaf49c83226793b258c67c856b91 oracle/motif_pair-float32/instrumented/coefficients.json +d37bbac320791543bdc13106f71c8aab50c345ca93aeee06d49ce26131e5e198 oracle/motif_pair-float32/instrumented/compiled-code.json +5af02939034e66e7a8e7c361555203906d69bbba0042b1ab549041db1626f02b oracle/motif_pair-float32/instrumented/completeness.csv +1072f50d478d1890de7602c48f6a7f1b89e11a665a173e7a705a5fab3b3f8771 oracle/motif_pair-float32/instrumented/connectivity.parquet +04dd8561cbfca6932ddc94ffbf3228449a7ab8676b153db775cf1514af9f61cb oracle/motif_pair-float32/instrumented/generated-code.json +c6618376a52844263736e9dd031ff5745543d4db39d51072381d2230a9c61076 oracle/motif_pair-float32/instrumented/input-audit.json +e7aade6f0cedd94c4c07fbe6eb69dbfb345cb2793bf819cc7fd995d708df83e5 oracle/motif_pair-float32/instrumented/queue-audit.json +0db2d5f73709934bf7a91db2908a8dc3301614d09490769bf369aad96ee4f0fb oracle/motif_pair-float32/instrumented/schedule.json +016d9e6cd2e38e3ac4bf5dcd4526771f30885a7152b77e703bfa6debbed047f1 oracle/motif_pair-float32/instrumented/state.npz +87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09 oracle/motif_pair-float32/proxy-validation.json +016d9e6cd2e38e3ac4bf5dcd4526771f30885a7152b77e703bfa6debbed047f1 oracle/motif_pair-float32/state.npz +c282c963d6a2e7c80a70aa20d339f57ea46cdb9a4c296ae1017f37c42f71a66b oracle/motif_pair-float32/summary.json +7de7395618cc75c739c64aa06e9b5111270a04f6e38e4fead6f42bc9838b24d9 oracle/motif_pair-float32/unwrapped-audit/coefficients.json +9ef07e82240727c9761386ecdd054475050156677e9b0a3a6bc37b845c1f602c oracle/motif_pair-float32/unwrapped-audit/compiled-code.json +5af02939034e66e7a8e7c361555203906d69bbba0042b1ab549041db1626f02b oracle/motif_pair-float32/unwrapped-audit/completeness.csv +1072f50d478d1890de7602c48f6a7f1b89e11a665a173e7a705a5fab3b3f8771 oracle/motif_pair-float32/unwrapped-audit/connectivity.parquet +6285bf3f565631bb13f61df1de231f6431e9dbba62c9390a770a481fecf434d4 oracle/motif_pair-float32/unwrapped-audit/generated-code.json +38494b8726f5685faae5116251a91c775d036f984a7d6685d5512b8cc4730197 oracle/motif_pair-float32/unwrapped-audit/input-audit.json +33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7 oracle/motif_pair-float32/unwrapped-audit/queue-audit.json +af9f8f7b182f3c780b23e1448888728ad89be2bbaf7ebe5631d6bff7c7ae77db oracle/motif_pair-float32/unwrapped-audit/schedule.json +4e4306501322819a9124639ca42a8563deb5e6b8d4a32bd076e50304b3ac890f oracle/motif_pair-float32/unwrapped-audit/state.npz +2c3139962eace310ec0592d1e507efc799658ea0fcdde723c5238e5af214915f oracle/motif_pair-float64/case.json +d01a405ef9b9be1675c66875d972578ff4c506a468388d8e980f8d449e6dc333 oracle/motif_pair-float64/coefficients.json +8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6 oracle/motif_pair-float64/environment.json +d01a405ef9b9be1675c66875d972578ff4c506a468388d8e980f8d449e6dc333 oracle/motif_pair-float64/instrumented/coefficients.json +d37bbac320791543bdc13106f71c8aab50c345ca93aeee06d49ce26131e5e198 oracle/motif_pair-float64/instrumented/compiled-code.json +5af02939034e66e7a8e7c361555203906d69bbba0042b1ab549041db1626f02b oracle/motif_pair-float64/instrumented/completeness.csv +1072f50d478d1890de7602c48f6a7f1b89e11a665a173e7a705a5fab3b3f8771 oracle/motif_pair-float64/instrumented/connectivity.parquet +6218cb7a5561987d8a5f4b50df6b8ab178f97d9c8a3b0c2281592030323d19ad oracle/motif_pair-float64/instrumented/generated-code.json +05822e9cca61f7cf9b21e6eb6334e39c783e94d260cb526ac42fd17da4a55bae oracle/motif_pair-float64/instrumented/input-audit.json +f20253a8c675f99d0b51612f0faa6ffe968e63f6059b7e0f865d4730de411d75 oracle/motif_pair-float64/instrumented/queue-audit.json +0db2d5f73709934bf7a91db2908a8dc3301614d09490769bf369aad96ee4f0fb oracle/motif_pair-float64/instrumented/schedule.json +236fcb984139a2e376b026fe33e5fb079a1c3a9a4f1090925fbe2643c92fa31b oracle/motif_pair-float64/instrumented/state.npz +87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09 oracle/motif_pair-float64/proxy-validation.json +236fcb984139a2e376b026fe33e5fb079a1c3a9a4f1090925fbe2643c92fa31b oracle/motif_pair-float64/state.npz +d31801b7409b61b11c039dcedb57695447c170d280ff6bae80836a70710eb9d9 oracle/motif_pair-float64/summary.json +a45521c8cc13306fa535adf1cbf9f476b88061351774660f680abf04ee65899d oracle/motif_pair-float64/unwrapped-audit/coefficients.json +9ef07e82240727c9761386ecdd054475050156677e9b0a3a6bc37b845c1f602c oracle/motif_pair-float64/unwrapped-audit/compiled-code.json +5af02939034e66e7a8e7c361555203906d69bbba0042b1ab549041db1626f02b oracle/motif_pair-float64/unwrapped-audit/completeness.csv +1072f50d478d1890de7602c48f6a7f1b89e11a665a173e7a705a5fab3b3f8771 oracle/motif_pair-float64/unwrapped-audit/connectivity.parquet +27e213d76a91871c492e28be66c7a093fd4e1ba5920b7fd87a59f3b5ccca1b05 oracle/motif_pair-float64/unwrapped-audit/generated-code.json +5ad9da04ebc86c451a2dc3ee1ae515048da3d0517a2772766e948be58a87cf9e oracle/motif_pair-float64/unwrapped-audit/input-audit.json +33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7 oracle/motif_pair-float64/unwrapped-audit/queue-audit.json +af9f8f7b182f3c780b23e1448888728ad89be2bbaf7ebe5631d6bff7c7ae77db oracle/motif_pair-float64/unwrapped-audit/schedule.json +beb3ee5242eacc3f92c611b02bd9a987f83c130305e97a2af8d0ea9a6e4d546f oracle/motif_pair-float64/unwrapped-audit/state.npz +a8cfb8d4d18e0619d6da058dae7e8488e22eaf1c78d79e30b7950cef9805392e oracle/motif_trio-float32/case.json +7c1b1089b738c3acbca361d026af0818c2bedd1058226a4b1613107835f7e063 oracle/motif_trio-float32/coefficients.json +8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6 oracle/motif_trio-float32/environment.json +7c1b1089b738c3acbca361d026af0818c2bedd1058226a4b1613107835f7e063 oracle/motif_trio-float32/instrumented/coefficients.json +d37bbac320791543bdc13106f71c8aab50c345ca93aeee06d49ce26131e5e198 oracle/motif_trio-float32/instrumented/compiled-code.json +e8795d5efb2eebefaae419c6df6d18d3cea3c390d9df7987f55823f5a860169e oracle/motif_trio-float32/instrumented/completeness.csv +22570cdceb09128d4bde46fd75897af776f7d91d89b8581d13133f55779f1e91 oracle/motif_trio-float32/instrumented/connectivity.parquet +8c8e0ef283417f030223be90143fe431a2e55c00e197ccfb42a603bcb8e0ac6d oracle/motif_trio-float32/instrumented/generated-code.json +aeb9de630a338539ef77e631d6fad439b8c8bac45f72c9b1ea5a746762f1478e oracle/motif_trio-float32/instrumented/input-audit.json +b4e878392aba4af8d5f54a972a0345a1e5ae61f02d3cecd84c66ee16e1c14070 oracle/motif_trio-float32/instrumented/queue-audit.json +0db2d5f73709934bf7a91db2908a8dc3301614d09490769bf369aad96ee4f0fb oracle/motif_trio-float32/instrumented/schedule.json +ce04a18d25df422285be6ee80d36c949da506ebc885a87d31e109ee3d31f292b oracle/motif_trio-float32/instrumented/state.npz +87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09 oracle/motif_trio-float32/proxy-validation.json +ce04a18d25df422285be6ee80d36c949da506ebc885a87d31e109ee3d31f292b oracle/motif_trio-float32/state.npz +d854013887eb352536cebd66f3060cb0b7d7048f170a415e56e58641d27c8be7 oracle/motif_trio-float32/summary.json +e93700e27b476c87d3bd9631847df5930580d588188f2d6356f8fd4278640c62 oracle/motif_trio-float32/unwrapped-audit/coefficients.json +9ef07e82240727c9761386ecdd054475050156677e9b0a3a6bc37b845c1f602c oracle/motif_trio-float32/unwrapped-audit/compiled-code.json +e8795d5efb2eebefaae419c6df6d18d3cea3c390d9df7987f55823f5a860169e oracle/motif_trio-float32/unwrapped-audit/completeness.csv +22570cdceb09128d4bde46fd75897af776f7d91d89b8581d13133f55779f1e91 oracle/motif_trio-float32/unwrapped-audit/connectivity.parquet +9f4389a017bd872ea48ce57dce09ff7feddc58e4d3e3de3e91a485d8e4efe661 oracle/motif_trio-float32/unwrapped-audit/generated-code.json +b66ee25f7bb8b96360c9c0c3b919cca442eaf90f83644e6ec7ad42f0a5644691 oracle/motif_trio-float32/unwrapped-audit/input-audit.json +33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7 oracle/motif_trio-float32/unwrapped-audit/queue-audit.json +af9f8f7b182f3c780b23e1448888728ad89be2bbaf7ebe5631d6bff7c7ae77db oracle/motif_trio-float32/unwrapped-audit/schedule.json +f700680def60fd4c63c322d7cbb69b0c42083401f303510f6ea07bd3b78ada8d oracle/motif_trio-float32/unwrapped-audit/state.npz +a72c3e1c5887c5174e5bc1bdd488e21652c2d40e1a64c17bec055d1c33ad8163 oracle/motif_trio-float64/case.json +7de7395618cc75c739c64aa06e9b5111270a04f6e38e4fead6f42bc9838b24d9 oracle/motif_trio-float64/coefficients.json +8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6 oracle/motif_trio-float64/environment.json +7de7395618cc75c739c64aa06e9b5111270a04f6e38e4fead6f42bc9838b24d9 oracle/motif_trio-float64/instrumented/coefficients.json +d37bbac320791543bdc13106f71c8aab50c345ca93aeee06d49ce26131e5e198 oracle/motif_trio-float64/instrumented/compiled-code.json +e8795d5efb2eebefaae419c6df6d18d3cea3c390d9df7987f55823f5a860169e oracle/motif_trio-float64/instrumented/completeness.csv +22570cdceb09128d4bde46fd75897af776f7d91d89b8581d13133f55779f1e91 oracle/motif_trio-float64/instrumented/connectivity.parquet +6219a02ab212b7391b8686191afcdf1189aa04c3eb60c3d6faffe54f2130c232 oracle/motif_trio-float64/instrumented/generated-code.json +dca8d6b6f6e544292d87ece37af55ea38f48e26265132984c82293a83d3a5126 oracle/motif_trio-float64/instrumented/input-audit.json +29957621c31b54a95a988fe4a82363c02c7726b27778870b80dc9d63c1741c7f oracle/motif_trio-float64/instrumented/queue-audit.json +0db2d5f73709934bf7a91db2908a8dc3301614d09490769bf369aad96ee4f0fb oracle/motif_trio-float64/instrumented/schedule.json +bf670c8bc344163408fb96baf2df5d0fab9804f134fdd9011205ff6873d2084a oracle/motif_trio-float64/instrumented/state.npz +87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09 oracle/motif_trio-float64/proxy-validation.json +bf670c8bc344163408fb96baf2df5d0fab9804f134fdd9011205ff6873d2084a oracle/motif_trio-float64/state.npz +96f65fd87b834a3b4e79be2017c42f7e28aea8588393f3ba64ef92d2c9d5e4f7 oracle/motif_trio-float64/summary.json +7c1b1089b738c3acbca361d026af0818c2bedd1058226a4b1613107835f7e063 oracle/motif_trio-float64/unwrapped-audit/coefficients.json +9ef07e82240727c9761386ecdd054475050156677e9b0a3a6bc37b845c1f602c oracle/motif_trio-float64/unwrapped-audit/compiled-code.json +e8795d5efb2eebefaae419c6df6d18d3cea3c390d9df7987f55823f5a860169e oracle/motif_trio-float64/unwrapped-audit/completeness.csv +22570cdceb09128d4bde46fd75897af776f7d91d89b8581d13133f55779f1e91 oracle/motif_trio-float64/unwrapped-audit/connectivity.parquet +3dfe75cb3a716d21a5c93328ca9afebf1540f68bf873af5005720b8b41a81231 oracle/motif_trio-float64/unwrapped-audit/generated-code.json +eca8ca955d53b8e6e0568c3f0020bcfd40b8b536f64f74040623dd50235c62ef oracle/motif_trio-float64/unwrapped-audit/input-audit.json +33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7 oracle/motif_trio-float64/unwrapped-audit/queue-audit.json +af9f8f7b182f3c780b23e1448888728ad89be2bbaf7ebe5631d6bff7c7ae77db oracle/motif_trio-float64/unwrapped-audit/schedule.json +40522d4509583dcad23412e017f76b76c5acc8c35069fd98ce2a20e90d85964c oracle/motif_trio-float64/unwrapped-audit/state.npz +83987a7bbeb3dde14fac3de2f73ce9270b0be4d0d1a444212e0a42fea8099df9 oracle/ordered_cancellation-float32/case.json +25028e6abaf2d0674eff984499f9b03e540ea7ec39006e1792242a71a662654c oracle/ordered_cancellation-float32/coefficients.json +8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6 oracle/ordered_cancellation-float32/environment.json +25028e6abaf2d0674eff984499f9b03e540ea7ec39006e1792242a71a662654c oracle/ordered_cancellation-float32/instrumented/coefficients.json +d37bbac320791543bdc13106f71c8aab50c345ca93aeee06d49ce26131e5e198 oracle/ordered_cancellation-float32/instrumented/compiled-code.json +d861bdcdccde99f4c49e489f5f22e274a3e810fa365d0858513d91092f6ddeed oracle/ordered_cancellation-float32/instrumented/completeness.csv +5fd8201a0e8f908045308387d8b87bff1efc86f643b0ab2808623110949b7923 oracle/ordered_cancellation-float32/instrumented/connectivity.parquet +7f4e8f22ed3dcdf089914e79c574bbbb404f4eb6bb3fecca4a680e3f9d3c0857 oracle/ordered_cancellation-float32/instrumented/generated-code.json +6375f3b8727a3b9023eb16a811cb2ab95ca75f0d039190faa015801f0fa472ce oracle/ordered_cancellation-float32/instrumented/input-audit.json +215e1d7357f2adbd81c2dc4e71948d1341cda30ec05ea55adc46e546c3952780 oracle/ordered_cancellation-float32/instrumented/queue-audit.json +0db2d5f73709934bf7a91db2908a8dc3301614d09490769bf369aad96ee4f0fb oracle/ordered_cancellation-float32/instrumented/schedule.json +c937b1ec1e1ec63d1f0aedd3ab91b506f745849f3b66d8223d0d831bd9a689b0 oracle/ordered_cancellation-float32/instrumented/state.npz +87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09 oracle/ordered_cancellation-float32/proxy-validation.json +c937b1ec1e1ec63d1f0aedd3ab91b506f745849f3b66d8223d0d831bd9a689b0 oracle/ordered_cancellation-float32/state.npz +5fde5e19bb7f3ea8bace360458c67652575827fd2f8f493cafade16537c7efcf oracle/ordered_cancellation-float32/summary.json +5c7757cd44e4f994f9d1496a3533ffc3ae993d3f9327764e57183e4167a02ef6 oracle/ordered_cancellation-float32/unwrapped-audit/coefficients.json +9ef07e82240727c9761386ecdd054475050156677e9b0a3a6bc37b845c1f602c oracle/ordered_cancellation-float32/unwrapped-audit/compiled-code.json +d861bdcdccde99f4c49e489f5f22e274a3e810fa365d0858513d91092f6ddeed oracle/ordered_cancellation-float32/unwrapped-audit/completeness.csv +5fd8201a0e8f908045308387d8b87bff1efc86f643b0ab2808623110949b7923 oracle/ordered_cancellation-float32/unwrapped-audit/connectivity.parquet +78041f723fdc221809a9202f586abfb828114e0c60101e72b8f82dbb7b349b4e oracle/ordered_cancellation-float32/unwrapped-audit/generated-code.json +853eb8557130dd59256f4d8b53ba1f104aea43f6e6d2aab68e12f2d3fced8e90 oracle/ordered_cancellation-float32/unwrapped-audit/input-audit.json +33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7 oracle/ordered_cancellation-float32/unwrapped-audit/queue-audit.json +af9f8f7b182f3c780b23e1448888728ad89be2bbaf7ebe5631d6bff7c7ae77db oracle/ordered_cancellation-float32/unwrapped-audit/schedule.json +527d40df651506784cab1224749b43a68d7faf08addd6ed0d621f72bc614bc5b oracle/ordered_cancellation-float32/unwrapped-audit/state.npz +42a5b1bd97192138c1aa231a7cc200fb4cd50e2eaf71ca79ba50005444272761 oracle/ordered_cancellation-float64/case.json +e93700e27b476c87d3bd9631847df5930580d588188f2d6356f8fd4278640c62 oracle/ordered_cancellation-float64/coefficients.json +8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6 oracle/ordered_cancellation-float64/environment.json +e93700e27b476c87d3bd9631847df5930580d588188f2d6356f8fd4278640c62 oracle/ordered_cancellation-float64/instrumented/coefficients.json +d37bbac320791543bdc13106f71c8aab50c345ca93aeee06d49ce26131e5e198 oracle/ordered_cancellation-float64/instrumented/compiled-code.json +d861bdcdccde99f4c49e489f5f22e274a3e810fa365d0858513d91092f6ddeed oracle/ordered_cancellation-float64/instrumented/completeness.csv +5fd8201a0e8f908045308387d8b87bff1efc86f643b0ab2808623110949b7923 oracle/ordered_cancellation-float64/instrumented/connectivity.parquet +ce982dd6dd2bf6f81d608e820add84fbe611d51a6157fbae6fb2b9e1e30dd571 oracle/ordered_cancellation-float64/instrumented/generated-code.json +4969d3f0ae5857d3eca879568c757e6d4b631d4fb0f90212eb5951836b41d1f3 oracle/ordered_cancellation-float64/instrumented/input-audit.json +0de23642c9438c99c3c1f93efb4ee282ba55e2ebb9d04b77ae93d4a10fd92fa4 oracle/ordered_cancellation-float64/instrumented/queue-audit.json +0db2d5f73709934bf7a91db2908a8dc3301614d09490769bf369aad96ee4f0fb oracle/ordered_cancellation-float64/instrumented/schedule.json +1ad4991463a440d466ec28bc32bb35572f84b351716a8150ed6360d90d36942b oracle/ordered_cancellation-float64/instrumented/state.npz +87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09 oracle/ordered_cancellation-float64/proxy-validation.json +1ad4991463a440d466ec28bc32bb35572f84b351716a8150ed6360d90d36942b oracle/ordered_cancellation-float64/state.npz +538d114715e29bfe83252cd5ce86bdc69e416f643422d7d66bc3b9cc634a2382 oracle/ordered_cancellation-float64/summary.json +25028e6abaf2d0674eff984499f9b03e540ea7ec39006e1792242a71a662654c oracle/ordered_cancellation-float64/unwrapped-audit/coefficients.json +9ef07e82240727c9761386ecdd054475050156677e9b0a3a6bc37b845c1f602c oracle/ordered_cancellation-float64/unwrapped-audit/compiled-code.json +d861bdcdccde99f4c49e489f5f22e274a3e810fa365d0858513d91092f6ddeed oracle/ordered_cancellation-float64/unwrapped-audit/completeness.csv +5fd8201a0e8f908045308387d8b87bff1efc86f643b0ab2808623110949b7923 oracle/ordered_cancellation-float64/unwrapped-audit/connectivity.parquet +2e921b0a8d0b8be1bc83ece8d54edc08bc8e5c746c765b917f88cd3517ffea92 oracle/ordered_cancellation-float64/unwrapped-audit/generated-code.json +859874145af010d744d285cf471ae9cb7f410e02666dedd15abb189ced0dd22d oracle/ordered_cancellation-float64/unwrapped-audit/input-audit.json +33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7 oracle/ordered_cancellation-float64/unwrapped-audit/queue-audit.json +af9f8f7b182f3c780b23e1448888728ad89be2bbaf7ebe5631d6bff7c7ae77db oracle/ordered_cancellation-float64/unwrapped-audit/schedule.json +eace764d5bb58f882457ddde9409230b65e99e97c52b56028cf9497d17f5a1ff oracle/ordered_cancellation-float64/unwrapped-audit/state.npz +fd295fc5ccc133bfa70d2e9f7b4d9ca839b23beb337b5fdd4183be00987c6dd4 oracle/release_selfloop-float32/case.json +641e4016edb1690746a62aab09485c91852d5862d25fe85dab390121fb21779f oracle/release_selfloop-float32/coefficients.json +8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6 oracle/release_selfloop-float32/environment.json +641e4016edb1690746a62aab09485c91852d5862d25fe85dab390121fb21779f oracle/release_selfloop-float32/instrumented/coefficients.json +dfbcf815d17465e4c83a54320687e77c3035c5064f6a81a11bffc5ce35ec0dd1 oracle/release_selfloop-float32/instrumented/compiled-code.json +c79ddcee44e7786a8805ed8bd4685d8107764e5dff4952b204e5163f8630ce80 oracle/release_selfloop-float32/instrumented/completeness.csv +7dbc19bebd51061ac3272c69fe12a7a0a0d179ab21ff6d35193070c64db310f4 oracle/release_selfloop-float32/instrumented/connectivity.parquet +94ba0cc5f884ff7e332d1859286ba39e4bc7fa684546db29088e22a5fb96a14b oracle/release_selfloop-float32/instrumented/generated-code.json +4047c46214a2c9d06289ed7db728e2f1afa23cb1e1e9437634d4c4f56540d3a2 oracle/release_selfloop-float32/instrumented/input-audit.json +40bf803d062804b7bb6ce070743fc805423f873311d8bb453d2cc5db2ea62bb3 oracle/release_selfloop-float32/instrumented/queue-audit.json +8d5492b7968694e913d3321b10d5779137045d4689fe50ec50b1ef7637d8fc04 oracle/release_selfloop-float32/instrumented/schedule.json +dd8c3ac01e4d8035d94d0772efbb81948ba427f5ef66caf8d104f4819845a3cc oracle/release_selfloop-float32/instrumented/state.npz +87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09 oracle/release_selfloop-float32/proxy-validation.json +dd8c3ac01e4d8035d94d0772efbb81948ba427f5ef66caf8d104f4819845a3cc oracle/release_selfloop-float32/state.npz +979d2a0d15f9d6f746e930fa5c0eb8def666713669026b69140c65687630401e oracle/release_selfloop-float32/summary.json +b31b081bcc455e5a3e29ab3c7094c020e9a4f56f47cbd108bfa12c23abb4f83a oracle/release_selfloop-float32/unwrapped-audit/coefficients.json +82868f03604ec2a12efea07718960e3bfb1c8152950c3b6bc4fd8e1b1d46cf8d oracle/release_selfloop-float32/unwrapped-audit/compiled-code.json +c79ddcee44e7786a8805ed8bd4685d8107764e5dff4952b204e5163f8630ce80 oracle/release_selfloop-float32/unwrapped-audit/completeness.csv +7dbc19bebd51061ac3272c69fe12a7a0a0d179ab21ff6d35193070c64db310f4 oracle/release_selfloop-float32/unwrapped-audit/connectivity.parquet +7fb472acf561ca1c043f0fc3a46941cdb7846d1ca8df820a15b725ad1f144ed9 oracle/release_selfloop-float32/unwrapped-audit/generated-code.json +35a01e501ae88e4350583ba961a0e67e3be2c486c2fc9c2c49905924e2bc004f oracle/release_selfloop-float32/unwrapped-audit/input-audit.json +33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7 oracle/release_selfloop-float32/unwrapped-audit/queue-audit.json +42679bfcc102a0ec20fafe7fdf9cc82b02a0b8809931a49502ac6efd669fc9cd oracle/release_selfloop-float32/unwrapped-audit/schedule.json +30310b802cec33bc1f8a2f7b01e73cc4a040714279cf7406123a896397077ad6 oracle/release_selfloop-float32/unwrapped-audit/state.npz +6a7d03115b6dbff20bcca4708f5ffea8de006e9f091bac804e8f1d2db168220c oracle/release_selfloop-float64/case.json +5c7757cd44e4f994f9d1496a3533ffc3ae993d3f9327764e57183e4167a02ef6 oracle/release_selfloop-float64/coefficients.json +8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6 oracle/release_selfloop-float64/environment.json +5c7757cd44e4f994f9d1496a3533ffc3ae993d3f9327764e57183e4167a02ef6 oracle/release_selfloop-float64/instrumented/coefficients.json +dfbcf815d17465e4c83a54320687e77c3035c5064f6a81a11bffc5ce35ec0dd1 oracle/release_selfloop-float64/instrumented/compiled-code.json +c79ddcee44e7786a8805ed8bd4685d8107764e5dff4952b204e5163f8630ce80 oracle/release_selfloop-float64/instrumented/completeness.csv +7dbc19bebd51061ac3272c69fe12a7a0a0d179ab21ff6d35193070c64db310f4 oracle/release_selfloop-float64/instrumented/connectivity.parquet +0d51e9ee6cad7494f92e4f90c362be175b66388d4bed51c1ef14a7aba6822eee oracle/release_selfloop-float64/instrumented/generated-code.json +adcc4735605e955cc3f82c52e078c3aa0ed6a5f6134a536431efa5595af0b553 oracle/release_selfloop-float64/instrumented/input-audit.json +d1b7304bec0a1b2ffd069cc04b16aa05c19aff71104ccd1fa6324ac80683c6c6 oracle/release_selfloop-float64/instrumented/queue-audit.json +8d5492b7968694e913d3321b10d5779137045d4689fe50ec50b1ef7637d8fc04 oracle/release_selfloop-float64/instrumented/schedule.json +2615645c5ae1bea1d9ba279c6639e35209907e4e103db6d10c05ad23dc11919d oracle/release_selfloop-float64/instrumented/state.npz +87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09 oracle/release_selfloop-float64/proxy-validation.json +2615645c5ae1bea1d9ba279c6639e35209907e4e103db6d10c05ad23dc11919d oracle/release_selfloop-float64/state.npz +4312b4466d22b9ea9d4e797dee7ffece32356d0483a12e6886df48a4b68a83a9 oracle/release_selfloop-float64/summary.json +641e4016edb1690746a62aab09485c91852d5862d25fe85dab390121fb21779f oracle/release_selfloop-float64/unwrapped-audit/coefficients.json +82868f03604ec2a12efea07718960e3bfb1c8152950c3b6bc4fd8e1b1d46cf8d oracle/release_selfloop-float64/unwrapped-audit/compiled-code.json +c79ddcee44e7786a8805ed8bd4685d8107764e5dff4952b204e5163f8630ce80 oracle/release_selfloop-float64/unwrapped-audit/completeness.csv +7dbc19bebd51061ac3272c69fe12a7a0a0d179ab21ff6d35193070c64db310f4 oracle/release_selfloop-float64/unwrapped-audit/connectivity.parquet +59f811addd08ca9edd87e10f52560ea5c7fffcfcb3fe809b2a35222b73788586 oracle/release_selfloop-float64/unwrapped-audit/generated-code.json +149bcf4eccdde513b08be26169d1fb502a65436ec56b8bdabb0c36be4bab1949 oracle/release_selfloop-float64/unwrapped-audit/input-audit.json +33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7 oracle/release_selfloop-float64/unwrapped-audit/queue-audit.json +42679bfcc102a0ec20fafe7fdf9cc82b02a0b8809931a49502ac6efd669fc9cd oracle/release_selfloop-float64/unwrapped-audit/schedule.json +e49aacc647ff1b1c42eeb7d8b25b797c2b2bcef4a2a3b9c1e7e78945e87fe65e oracle/release_selfloop-float64/unwrapped-audit/state.npz +41ffb65d2bb6c0cbce029a2bcc9c13a3d9cdd26bd1d2c38cad0f02d71ca33ad9 oracle/signed_random-float32/case.json +b31b081bcc455e5a3e29ab3c7094c020e9a4f56f47cbd108bfa12c23abb4f83a oracle/signed_random-float32/coefficients.json +8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6 oracle/signed_random-float32/environment.json +b31b081bcc455e5a3e29ab3c7094c020e9a4f56f47cbd108bfa12c23abb4f83a oracle/signed_random-float32/instrumented/coefficients.json +dfbcf815d17465e4c83a54320687e77c3035c5064f6a81a11bffc5ce35ec0dd1 oracle/signed_random-float32/instrumented/compiled-code.json +847d1cf9168f7309567f41a98b9258003eb1174f46d3b61f19fab79c8a629c4f oracle/signed_random-float32/instrumented/completeness.csv +8e5386c56312953312d0aaef7f5d816544d859fbe66b0583ddcc2093f33c062d oracle/signed_random-float32/instrumented/connectivity.parquet +a1fc01a10b78668091c0e85a41fe5e090b886631237f155dc7e2203f12a86a2f oracle/signed_random-float32/instrumented/generated-code.json +1e75500b3d33a04cb3ebdb8978dec818f5c609e3528ed896b76225b461bed4c8 oracle/signed_random-float32/instrumented/input-audit.json +632d60b3927ca573c01d427658b25d3a7c5b8dab6a95957e29ea5512ccf40c45 oracle/signed_random-float32/instrumented/queue-audit.json +8d5492b7968694e913d3321b10d5779137045d4689fe50ec50b1ef7637d8fc04 oracle/signed_random-float32/instrumented/schedule.json +8657a63c2ea9703b8e37b0339eb63c24f31c597cf20cf214bb5e088312489d4a oracle/signed_random-float32/instrumented/state.npz +87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09 oracle/signed_random-float32/proxy-validation.json +8657a63c2ea9703b8e37b0339eb63c24f31c597cf20cf214bb5e088312489d4a oracle/signed_random-float32/state.npz +1b09126a1c80ec7e1239ebbc5ba7e8654644e091a9f4d1f86ef5fe1bea7942c1 oracle/signed_random-float32/summary.json +d87699f97f7e1c60379593c077990e8267d55c01a4b87c62a754764b3c67edde oracle/signed_random-float32/unwrapped-audit/coefficients.json +82868f03604ec2a12efea07718960e3bfb1c8152950c3b6bc4fd8e1b1d46cf8d oracle/signed_random-float32/unwrapped-audit/compiled-code.json +847d1cf9168f7309567f41a98b9258003eb1174f46d3b61f19fab79c8a629c4f oracle/signed_random-float32/unwrapped-audit/completeness.csv +8e5386c56312953312d0aaef7f5d816544d859fbe66b0583ddcc2093f33c062d oracle/signed_random-float32/unwrapped-audit/connectivity.parquet +4392e7f76087a91d08e8143261cb912d5489dcccfb0bd8b2f6edb9759f24b119 oracle/signed_random-float32/unwrapped-audit/generated-code.json +55acf52e153a3c1427954dab23d11d2b5de39b842d56b302b744f40b5300093f oracle/signed_random-float32/unwrapped-audit/input-audit.json +33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7 oracle/signed_random-float32/unwrapped-audit/queue-audit.json +42679bfcc102a0ec20fafe7fdf9cc82b02a0b8809931a49502ac6efd669fc9cd oracle/signed_random-float32/unwrapped-audit/schedule.json +217adfa0e6236f4213fb9c8ccdc3263e5cf73e1e65b9799b1feaabaf35dbfc00 oracle/signed_random-float32/unwrapped-audit/state.npz +3a998345bf8746c0e2229574005dc64647a9911ed54e3db709d01e0c5400db50 oracle/signed_random-float64/case.json +18c982eeea655a6efb2ab684941ed13dcbea4cf8bf5add0bde564e1991c46918 oracle/signed_random-float64/coefficients.json +8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6 oracle/signed_random-float64/environment.json +18c982eeea655a6efb2ab684941ed13dcbea4cf8bf5add0bde564e1991c46918 oracle/signed_random-float64/instrumented/coefficients.json +dfbcf815d17465e4c83a54320687e77c3035c5064f6a81a11bffc5ce35ec0dd1 oracle/signed_random-float64/instrumented/compiled-code.json +847d1cf9168f7309567f41a98b9258003eb1174f46d3b61f19fab79c8a629c4f oracle/signed_random-float64/instrumented/completeness.csv +8e5386c56312953312d0aaef7f5d816544d859fbe66b0583ddcc2093f33c062d oracle/signed_random-float64/instrumented/connectivity.parquet +016c7778c92643344b85c0d4a02c4a3596e8fd96bef364b074d3bca217268b40 oracle/signed_random-float64/instrumented/generated-code.json +5c0283e72857d6b597fae4b7ae6e170a49b578c249ab61297b0abcb3a3dd08d2 oracle/signed_random-float64/instrumented/input-audit.json +20a4213741e9ef87ab021f779e259129a49e89708d44c74717dc284b90264c52 oracle/signed_random-float64/instrumented/queue-audit.json +8d5492b7968694e913d3321b10d5779137045d4689fe50ec50b1ef7637d8fc04 oracle/signed_random-float64/instrumented/schedule.json +148f6098bb58c952afe07b680a79355091cfb7d6c21e2fc49fc4c902a191cafd oracle/signed_random-float64/instrumented/state.npz +87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09 oracle/signed_random-float64/proxy-validation.json +148f6098bb58c952afe07b680a79355091cfb7d6c21e2fc49fc4c902a191cafd oracle/signed_random-float64/state.npz +c6ab83e4fe4b7758f74af24407a1df22f1283115d561e410c4ffda58e4fcc0d7 oracle/signed_random-float64/summary.json +d87699f97f7e1c60379593c077990e8267d55c01a4b87c62a754764b3c67edde oracle/signed_random-float64/unwrapped-audit/coefficients.json +82868f03604ec2a12efea07718960e3bfb1c8152950c3b6bc4fd8e1b1d46cf8d oracle/signed_random-float64/unwrapped-audit/compiled-code.json +847d1cf9168f7309567f41a98b9258003eb1174f46d3b61f19fab79c8a629c4f oracle/signed_random-float64/unwrapped-audit/completeness.csv +8e5386c56312953312d0aaef7f5d816544d859fbe66b0583ddcc2093f33c062d oracle/signed_random-float64/unwrapped-audit/connectivity.parquet +89c9d663e1a33f36044a05d58ca417669c3d4a8746b2580127e75778a991711d oracle/signed_random-float64/unwrapped-audit/generated-code.json +0bbea9b06c74e659398f117e2a3d9c444d3e16fcf8ce9c2042cdc09d99318e4c oracle/signed_random-float64/unwrapped-audit/input-audit.json +33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7 oracle/signed_random-float64/unwrapped-audit/queue-audit.json +42679bfcc102a0ec20fafe7fdf9cc82b02a0b8809931a49502ac6efd669fc9cd oracle/signed_random-float64/unwrapped-audit/schedule.json +e516f877a467296ef6139dbd7442a5db5c3b4befa5fee0b3c5e258515f54a092 oracle/signed_random-float64/unwrapped-audit/state.npz +a5eb5baa4ca36263c75f80c348dd444836241cd270598ca660a9a4176557eb8c oracle/threshold_rounding-float32/case.json +c463f321c25ce79fbb95756ca3fcc8b4b9e2b36a31ce074439b6a45d0641fcff oracle/threshold_rounding-float32/coefficients.json +8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6 oracle/threshold_rounding-float32/environment.json +c463f321c25ce79fbb95756ca3fcc8b4b9e2b36a31ce074439b6a45d0641fcff oracle/threshold_rounding-float32/instrumented/coefficients.json +d37bbac320791543bdc13106f71c8aab50c345ca93aeee06d49ce26131e5e198 oracle/threshold_rounding-float32/instrumented/compiled-code.json +c391cd11c54130ce647d85f3b175256f1bfc2d5b50601ede4231cb7038cea401 oracle/threshold_rounding-float32/instrumented/completeness.csv +abf150cbffed88d715f9282ad1f63a27652af8cef3e672bfbdaaa1f072a27355 oracle/threshold_rounding-float32/instrumented/connectivity.parquet +80aba5afd83fd57e943ad930e58d25290488f32c47d1cfc6d807130462e0b9ee oracle/threshold_rounding-float32/instrumented/generated-code.json +61743ad6576a8d4d0dab49f2989cdf4e33bd0c6dc6205411b4b9ce446b671150 oracle/threshold_rounding-float32/instrumented/input-audit.json +42db107c806b29780165845cf05e63f4e300b6c2352fa933454d5b7eef9d0f86 oracle/threshold_rounding-float32/instrumented/queue-audit.json +0db2d5f73709934bf7a91db2908a8dc3301614d09490769bf369aad96ee4f0fb oracle/threshold_rounding-float32/instrumented/schedule.json +e225d3b95c5455cfb5f850e8fc3b3c97e99b4bd87bbfce6c2e6f764f32432a44 oracle/threshold_rounding-float32/instrumented/state.npz +87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09 oracle/threshold_rounding-float32/proxy-validation.json +e225d3b95c5455cfb5f850e8fc3b3c97e99b4bd87bbfce6c2e6f764f32432a44 oracle/threshold_rounding-float32/state.npz +ed9025646a6f6cbfcdb542dfd4ad700b68f3ddf6e4dca4156843b7c4658a0115 oracle/threshold_rounding-float32/summary.json +e034e68f3a14e480bbef791cef03d2ebb4f654675663035c0788c8d4c4fe00e2 oracle/threshold_rounding-float32/unwrapped-audit/coefficients.json +9ef07e82240727c9761386ecdd054475050156677e9b0a3a6bc37b845c1f602c oracle/threshold_rounding-float32/unwrapped-audit/compiled-code.json +c391cd11c54130ce647d85f3b175256f1bfc2d5b50601ede4231cb7038cea401 oracle/threshold_rounding-float32/unwrapped-audit/completeness.csv +abf150cbffed88d715f9282ad1f63a27652af8cef3e672bfbdaaa1f072a27355 oracle/threshold_rounding-float32/unwrapped-audit/connectivity.parquet +5dba98727c043059d343a65c895990307c5e34cfe1d17d7f6a439a21cba5bf7c oracle/threshold_rounding-float32/unwrapped-audit/generated-code.json +9ff3841577d5755a5108c77147464655b07fb9fba2879d647cd0c94f96183548 oracle/threshold_rounding-float32/unwrapped-audit/input-audit.json +33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7 oracle/threshold_rounding-float32/unwrapped-audit/queue-audit.json +af9f8f7b182f3c780b23e1448888728ad89be2bbaf7ebe5631d6bff7c7ae77db oracle/threshold_rounding-float32/unwrapped-audit/schedule.json +e225d3b95c5455cfb5f850e8fc3b3c97e99b4bd87bbfce6c2e6f764f32432a44 oracle/threshold_rounding-float32/unwrapped-audit/state.npz +f2d7a8d5a067f0356ce106def5e8e1cde709e080837cfd87844cecfc6c7df884 oracle/threshold_rounding-float64/case.json +d87699f97f7e1c60379593c077990e8267d55c01a4b87c62a754764b3c67edde oracle/threshold_rounding-float64/coefficients.json +8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6 oracle/threshold_rounding-float64/environment.json +d87699f97f7e1c60379593c077990e8267d55c01a4b87c62a754764b3c67edde oracle/threshold_rounding-float64/instrumented/coefficients.json +d37bbac320791543bdc13106f71c8aab50c345ca93aeee06d49ce26131e5e198 oracle/threshold_rounding-float64/instrumented/compiled-code.json +c391cd11c54130ce647d85f3b175256f1bfc2d5b50601ede4231cb7038cea401 oracle/threshold_rounding-float64/instrumented/completeness.csv +abf150cbffed88d715f9282ad1f63a27652af8cef3e672bfbdaaa1f072a27355 oracle/threshold_rounding-float64/instrumented/connectivity.parquet +f8855c24be8282f84e30d36e1d94c37389f0fb3a65537b121407311c25596f6b oracle/threshold_rounding-float64/instrumented/generated-code.json +8e10d2ac7488b62aacd4de02d4a0c16605b7ea3767c5c14678ce02919f0b24f0 oracle/threshold_rounding-float64/instrumented/input-audit.json +242f188267ccd2c787842ebb71e00d0eeac1c05abfb60beddc88f1ce629d46ba oracle/threshold_rounding-float64/instrumented/queue-audit.json +0db2d5f73709934bf7a91db2908a8dc3301614d09490769bf369aad96ee4f0fb oracle/threshold_rounding-float64/instrumented/schedule.json +2b7071d125814ce8855806157f8ff5b778f554076e6ab8f2488ad99fd8b447e0 oracle/threshold_rounding-float64/instrumented/state.npz +87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09 oracle/threshold_rounding-float64/proxy-validation.json +2b7071d125814ce8855806157f8ff5b778f554076e6ab8f2488ad99fd8b447e0 oracle/threshold_rounding-float64/state.npz +4f5705946624e474f686ce2ec300cbc743b4cf4984281bf0c28394d8af2fd9ad oracle/threshold_rounding-float64/summary.json +c463f321c25ce79fbb95756ca3fcc8b4b9e2b36a31ce074439b6a45d0641fcff oracle/threshold_rounding-float64/unwrapped-audit/coefficients.json +9ef07e82240727c9761386ecdd054475050156677e9b0a3a6bc37b845c1f602c oracle/threshold_rounding-float64/unwrapped-audit/compiled-code.json +c391cd11c54130ce647d85f3b175256f1bfc2d5b50601ede4231cb7038cea401 oracle/threshold_rounding-float64/unwrapped-audit/completeness.csv +abf150cbffed88d715f9282ad1f63a27652af8cef3e672bfbdaaa1f072a27355 oracle/threshold_rounding-float64/unwrapped-audit/connectivity.parquet +679659ac5f0f6f82d0f7e130c37d640b5ffc22211191cdf56c350929cf539c58 oracle/threshold_rounding-float64/unwrapped-audit/generated-code.json +b3a74657044ee0f3dbc4190b453dc4b8d6615f9be27d94141075de1e18095fa2 oracle/threshold_rounding-float64/unwrapped-audit/input-audit.json +33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7 oracle/threshold_rounding-float64/unwrapped-audit/queue-audit.json +af9f8f7b182f3c780b23e1448888728ad89be2bbaf7ebe5631d6bff7c7ae77db oracle/threshold_rounding-float64/unwrapped-audit/schedule.json +2b7071d125814ce8855806157f8ff5b778f554076e6ab8f2488ad99fd8b447e0 oracle/threshold_rounding-float64/unwrapped-audit/state.npz +3b0095dd04f6467323150497ac84c4d375a83f9ed3130250955eb65f8d406063 protocol/case-hashes.json +f2cbcbf0dd85a61a7267a7567332b00f162d42e69d655792c1bf980d3f1b7c90 protocol/preregistered.json +863d7c13334f75e0dd270f1bb870c4a2d86dbf2ff7324a4146560509aab1abd0 regression/frozen-five.json +9ac57b06217a4d7d75a36a8611df398381b4313772ba39b6af0b92a0dd2cd073 regression/gpu-complete.json +c4dba5e26a96277f128887d20734705675507395755747f4af1e8a36dc36a538 regression/old-integrity-after.json +c4dba5e26a96277f128887d20734705675507395755747f4af1e8a36dc36a538 regression/old-integrity-before.json +58f6d1c1afe4f96a82a247ae46d8a987d74cc6f59a79eded650bf24ca2a18751 regression/oracle-complete.json +a86caca4ecbd96c2b7cf24371b28f80f37170fa8769cdd9a31c822434be1eef5 manifest.json diff --git a/registry/phase4ae-author-runtime/evidence/gpu-reference/extension.json b/registry/phase4ae-author-runtime/evidence/gpu-reference/extension.json new file mode 100644 index 0000000..c4babdf --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu-reference/extension.json @@ -0,0 +1,17 @@ +{ + "binary": "/data/digital-drosophila/experiments/phase4ae-author-runtime/gpu-reference/extension-build/male_cns_lif_deterministic_v2_ext.so", + "binary_sha256": "2b5d56ae5b40051b5b2cdaa51cdc39bed86d03bb804594f82b5855c14ec3889c", + "build_seconds": 54.80219339599989, + "flags": { + "cuda": [ + "-O3", + "--fmad=false", + "-std=c++20" + ], + "cxx": [ + "-O3", + "-ffp-contract=off" + ] + }, + "status": "PASS" +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/fanin_bursts-float32-r0/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/fanin_bursts-float32-r0/comparison.json new file mode 100644 index 0000000..08d5e0e --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/fanin_bursts-float32-r0/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "fanin_bursts", + "precision": "float32", + "repeat": 0, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 1539, + "gpu_events": 1539, + "due_edges": 1545, + "accepted_edges": 1285, + "attempted_requests": 2049, + "accepted_requests": 1537 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/fanin_bursts-float32-r0/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/fanin_bursts-float32-r0/metrics.json new file mode 100644 index 0000000..0b4f257 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/fanin_bursts-float32-r0/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float32", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986813545227, + "c0": -0.00025935107260011137, + "cg": 0.004937935154885054, + "cv": 0.9950124621391296, + "threshold": -0.04500000178813934, + "reset": -0.052000001072883606, + "seed_volt": -0.04399999976158142 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 257, + "edges": 258, + "steps": 600, + "total_spikes": 1539, + "arriving_edges": 1545, + "accepted_arriving_edges": 1285, + "requested": 2049, + "accepted_requests": 1537, + "rejected_requests": 512, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.0002160389999517065, + "diagnostic_simulation_seconds": 0.16387280199978704, + "wall_seconds": 0.1797110560000874, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 2976256, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "90850d6968a7832e415d0966b57e216a65f5ba8f63e488e497148b6525806d79", + "arrays.npz": "f3a900e9032754619549005131283cbaf87fdaa9093887a90a295589dac590fb" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/fanin_bursts-float32-r1/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/fanin_bursts-float32-r1/comparison.json new file mode 100644 index 0000000..05ea606 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/fanin_bursts-float32-r1/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "fanin_bursts", + "precision": "float32", + "repeat": 1, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 1539, + "gpu_events": 1539, + "due_edges": 1545, + "accepted_edges": 1285, + "attempted_requests": 2049, + "accepted_requests": 1537 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/fanin_bursts-float32-r1/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/fanin_bursts-float32-r1/metrics.json new file mode 100644 index 0000000..e4a3c33 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/fanin_bursts-float32-r1/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float32", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986813545227, + "c0": -0.00025935107260011137, + "cg": 0.004937935154885054, + "cv": 0.9950124621391296, + "threshold": -0.04500000178813934, + "reset": -0.052000001072883606, + "seed_volt": -0.04399999976158142 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 257, + "edges": 258, + "steps": 600, + "total_spikes": 1539, + "arriving_edges": 1545, + "accepted_arriving_edges": 1285, + "requested": 2049, + "accepted_requests": 1537, + "rejected_requests": 512, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.00021554800014200737, + "diagnostic_simulation_seconds": 0.16467205800017837, + "wall_seconds": 0.18174553200014998, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 2976256, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "90850d6968a7832e415d0966b57e216a65f5ba8f63e488e497148b6525806d79", + "arrays.npz": "f3a900e9032754619549005131283cbaf87fdaa9093887a90a295589dac590fb" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/fanin_bursts-float32-r2/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/fanin_bursts-float32-r2/comparison.json new file mode 100644 index 0000000..19e24f5 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/fanin_bursts-float32-r2/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "fanin_bursts", + "precision": "float32", + "repeat": 2, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 1539, + "gpu_events": 1539, + "due_edges": 1545, + "accepted_edges": 1285, + "attempted_requests": 2049, + "accepted_requests": 1537 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/fanin_bursts-float32-r2/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/fanin_bursts-float32-r2/metrics.json new file mode 100644 index 0000000..a2e79cc --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/fanin_bursts-float32-r2/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float32", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986813545227, + "c0": -0.00025935107260011137, + "cg": 0.004937935154885054, + "cv": 0.9950124621391296, + "threshold": -0.04500000178813934, + "reset": -0.052000001072883606, + "seed_volt": -0.04399999976158142 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 257, + "edges": 258, + "steps": 600, + "total_spikes": 1539, + "arriving_edges": 1545, + "accepted_arriving_edges": 1285, + "requested": 2049, + "accepted_requests": 1537, + "rejected_requests": 512, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.0002177420001316932, + "diagnostic_simulation_seconds": 0.1611082429999442, + "wall_seconds": 0.17735012299999653, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 2976256, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "90850d6968a7832e415d0966b57e216a65f5ba8f63e488e497148b6525806d79", + "arrays.npz": "f3a900e9032754619549005131283cbaf87fdaa9093887a90a295589dac590fb" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/fanin_bursts-float64-r0/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/fanin_bursts-float64-r0/comparison.json new file mode 100644 index 0000000..b4d8045 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/fanin_bursts-float64-r0/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "fanin_bursts", + "precision": "float64", + "repeat": 0, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 1539, + "gpu_events": 1539, + "due_edges": 1545, + "accepted_edges": 1285, + "attempted_requests": 2049, + "accepted_requests": 1537 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/fanin_bursts-float64-r0/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/fanin_bursts-float64-r0/metrics.json new file mode 100644 index 0000000..d09a62e --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/fanin_bursts-float64-r0/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float64", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 257, + "edges": 258, + "steps": 600, + "total_spikes": 1539, + "arriving_edges": 1545, + "accepted_arriving_edges": 1285, + "requested": 2049, + "accepted_requests": 1537, + "rejected_requests": 512, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.03421430100024736, + "diagnostic_simulation_seconds": 0.43457396100029655, + "wall_seconds": 0.62978444700002, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 5446656, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "90850d6968a7832e415d0966b57e216a65f5ba8f63e488e497148b6525806d79", + "arrays.npz": "f3a900e9032754619549005131283cbaf87fdaa9093887a90a295589dac590fb" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/fanin_bursts-float64-r1/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/fanin_bursts-float64-r1/comparison.json new file mode 100644 index 0000000..a1c0745 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/fanin_bursts-float64-r1/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "fanin_bursts", + "precision": "float64", + "repeat": 1, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 1539, + "gpu_events": 1539, + "due_edges": 1545, + "accepted_edges": 1285, + "attempted_requests": 2049, + "accepted_requests": 1537 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/fanin_bursts-float64-r1/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/fanin_bursts-float64-r1/metrics.json new file mode 100644 index 0000000..e0af5bd --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/fanin_bursts-float64-r1/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float64", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 257, + "edges": 258, + "steps": 600, + "total_spikes": 1539, + "arriving_edges": 1545, + "accepted_arriving_edges": 1285, + "requested": 2049, + "accepted_requests": 1537, + "rejected_requests": 512, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.00021033799976066803, + "diagnostic_simulation_seconds": 0.16542889599986665, + "wall_seconds": 0.19187480399978085, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 5446656, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "90850d6968a7832e415d0966b57e216a65f5ba8f63e488e497148b6525806d79", + "arrays.npz": "f3a900e9032754619549005131283cbaf87fdaa9093887a90a295589dac590fb" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/fanin_bursts-float64-r2/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/fanin_bursts-float64-r2/comparison.json new file mode 100644 index 0000000..73eec53 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/fanin_bursts-float64-r2/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "fanin_bursts", + "precision": "float64", + "repeat": 2, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 1539, + "gpu_events": 1539, + "due_edges": 1545, + "accepted_edges": 1285, + "attempted_requests": 2049, + "accepted_requests": 1537 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/fanin_bursts-float64-r2/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/fanin_bursts-float64-r2/metrics.json new file mode 100644 index 0000000..569247b --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/fanin_bursts-float64-r2/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float64", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 257, + "edges": 258, + "steps": 600, + "total_spikes": 1539, + "arriving_edges": 1545, + "accepted_arriving_edges": 1285, + "requested": 2049, + "accepted_requests": 1537, + "rejected_requests": 512, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.00022369299995261827, + "diagnostic_simulation_seconds": 0.16044491299999208, + "wall_seconds": 0.1855477020003491, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 5446656, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "90850d6968a7832e415d0966b57e216a65f5ba8f63e488e497148b6525806d79", + "arrays.npz": "f3a900e9032754619549005131283cbaf87fdaa9093887a90a295589dac590fb" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/highest_indegree-float32-r0/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/highest_indegree-float32-r0/comparison.json new file mode 100644 index 0000000..f73aa60 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/highest_indegree-float32-r0/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "highest_indegree", + "precision": "float32", + "repeat": 0, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 101, + "gpu_events": 101, + "due_edges": 930, + "accepted_edges": 839, + "attempted_requests": 96, + "accepted_requests": 96 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/highest_indegree-float32-r0/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/highest_indegree-float32-r0/metrics.json new file mode 100644 index 0000000..b15da9a --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/highest_indegree-float32-r0/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float32", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986813545227, + "c0": -0.00025935107260011137, + "cg": 0.004937935154885054, + "cv": 0.9950124621391296, + "threshold": -0.04500000178813934, + "reset": -0.052000001072883606, + "seed_volt": -0.04399999976158142 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 128, + "edges": 320, + "steps": 500, + "total_spikes": 101, + "arriving_edges": 930, + "accepted_arriving_edges": 839, + "requested": 96, + "accepted_requests": 96, + "rejected_requests": 0, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.0002038769998762291, + "diagnostic_simulation_seconds": 0.1377275740001096, + "wall_seconds": 0.16177492599990728, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 1235968, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "eab2c18f120fd3e9f067f489cee0a4c07477607facf3094083d3e3fa60bfd1ef", + "arrays.npz": "02ab938969b4369b1e08bc4a82e8c5fe68683f7318baf5eb052098d63fab0302" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/highest_indegree-float32-r1/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/highest_indegree-float32-r1/comparison.json new file mode 100644 index 0000000..ad18054 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/highest_indegree-float32-r1/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "highest_indegree", + "precision": "float32", + "repeat": 1, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 101, + "gpu_events": 101, + "due_edges": 930, + "accepted_edges": 839, + "attempted_requests": 96, + "accepted_requests": 96 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/highest_indegree-float32-r1/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/highest_indegree-float32-r1/metrics.json new file mode 100644 index 0000000..5d9ddd7 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/highest_indegree-float32-r1/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float32", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986813545227, + "c0": -0.00025935107260011137, + "cg": 0.004937935154885054, + "cv": 0.9950124621391296, + "threshold": -0.04500000178813934, + "reset": -0.052000001072883606, + "seed_volt": -0.04399999976158142 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 128, + "edges": 320, + "steps": 500, + "total_spikes": 101, + "arriving_edges": 930, + "accepted_arriving_edges": 839, + "requested": 96, + "accepted_requests": 96, + "rejected_requests": 0, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.00019391799969525891, + "diagnostic_simulation_seconds": 0.13686487499990108, + "wall_seconds": 0.16172354499985886, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 1235968, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "eab2c18f120fd3e9f067f489cee0a4c07477607facf3094083d3e3fa60bfd1ef", + "arrays.npz": "02ab938969b4369b1e08bc4a82e8c5fe68683f7318baf5eb052098d63fab0302" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/highest_indegree-float32-r2/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/highest_indegree-float32-r2/comparison.json new file mode 100644 index 0000000..feaf210 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/highest_indegree-float32-r2/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "highest_indegree", + "precision": "float32", + "repeat": 2, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 101, + "gpu_events": 101, + "due_edges": 930, + "accepted_edges": 839, + "attempted_requests": 96, + "accepted_requests": 96 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/highest_indegree-float32-r2/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/highest_indegree-float32-r2/metrics.json new file mode 100644 index 0000000..ba15204 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/highest_indegree-float32-r2/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float32", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986813545227, + "c0": -0.00025935107260011137, + "cg": 0.004937935154885054, + "cv": 0.9950124621391296, + "threshold": -0.04500000178813934, + "reset": -0.052000001072883606, + "seed_volt": -0.04399999976158142 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 128, + "edges": 320, + "steps": 500, + "total_spikes": 101, + "arriving_edges": 930, + "accepted_arriving_edges": 839, + "requested": 96, + "accepted_requests": 96, + "rejected_requests": 0, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.00021593900009975187, + "diagnostic_simulation_seconds": 0.13913817499997094, + "wall_seconds": 0.163460675999886, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 1235968, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "eab2c18f120fd3e9f067f489cee0a4c07477607facf3094083d3e3fa60bfd1ef", + "arrays.npz": "02ab938969b4369b1e08bc4a82e8c5fe68683f7318baf5eb052098d63fab0302" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/highest_indegree-float64-r0/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/highest_indegree-float64-r0/comparison.json new file mode 100644 index 0000000..d616749 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/highest_indegree-float64-r0/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "highest_indegree", + "precision": "float64", + "repeat": 0, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 101, + "gpu_events": 101, + "due_edges": 930, + "accepted_edges": 839, + "attempted_requests": 96, + "accepted_requests": 96 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/highest_indegree-float64-r0/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/highest_indegree-float64-r0/metrics.json new file mode 100644 index 0000000..b621d63 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/highest_indegree-float64-r0/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float64", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 128, + "edges": 320, + "steps": 500, + "total_spikes": 101, + "arriving_edges": 930, + "accepted_arriving_edges": 839, + "requested": 96, + "accepted_requests": 96, + "rejected_requests": 0, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.00022267200029091327, + "diagnostic_simulation_seconds": 0.13863277600012225, + "wall_seconds": 0.1678203790002044, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 2262016, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "eab2c18f120fd3e9f067f489cee0a4c07477607facf3094083d3e3fa60bfd1ef", + "arrays.npz": "02ab938969b4369b1e08bc4a82e8c5fe68683f7318baf5eb052098d63fab0302" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/highest_indegree-float64-r1/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/highest_indegree-float64-r1/comparison.json new file mode 100644 index 0000000..e21d601 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/highest_indegree-float64-r1/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "highest_indegree", + "precision": "float64", + "repeat": 1, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 101, + "gpu_events": 101, + "due_edges": 930, + "accepted_edges": 839, + "attempted_requests": 96, + "accepted_requests": 96 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/highest_indegree-float64-r1/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/highest_indegree-float64-r1/metrics.json new file mode 100644 index 0000000..e475aa2 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/highest_indegree-float64-r1/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float64", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 128, + "edges": 320, + "steps": 500, + "total_spikes": 101, + "arriving_edges": 930, + "accepted_arriving_edges": 839, + "requested": 96, + "accepted_requests": 96, + "rejected_requests": 0, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.00022176999982548296, + "diagnostic_simulation_seconds": 0.14188342799980092, + "wall_seconds": 0.1717069649998848, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 2262016, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "eab2c18f120fd3e9f067f489cee0a4c07477607facf3094083d3e3fa60bfd1ef", + "arrays.npz": "02ab938969b4369b1e08bc4a82e8c5fe68683f7318baf5eb052098d63fab0302" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/highest_indegree-float64-r2/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/highest_indegree-float64-r2/comparison.json new file mode 100644 index 0000000..0582dd7 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/highest_indegree-float64-r2/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "highest_indegree", + "precision": "float64", + "repeat": 2, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 101, + "gpu_events": 101, + "due_edges": 930, + "accepted_edges": 839, + "attempted_requests": 96, + "accepted_requests": 96 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/highest_indegree-float64-r2/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/highest_indegree-float64-r2/metrics.json new file mode 100644 index 0000000..6bf6fe6 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/highest_indegree-float64-r2/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float64", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 128, + "edges": 320, + "steps": 500, + "total_spikes": 101, + "arriving_edges": 930, + "accepted_arriving_edges": 839, + "requested": 96, + "accepted_requests": 96, + "rejected_requests": 0, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.00021653000021615298, + "diagnostic_simulation_seconds": 0.13805553999964104, + "wall_seconds": 0.1668446970002151, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 2262016, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "eab2c18f120fd3e9f067f489cee0a4c07477607facf3094083d3e3fa60bfd1ef", + "arrays.npz": "02ab938969b4369b1e08bc4a82e8c5fe68683f7318baf5eb052098d63fab0302" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/mixed_high_indegree-float32-r0/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/mixed_high_indegree-float32-r0/comparison.json new file mode 100644 index 0000000..8880a75 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/mixed_high_indegree-float32-r0/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "mixed_high_indegree", + "precision": "float32", + "repeat": 0, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 106, + "gpu_events": 106, + "due_edges": 626, + "accepted_edges": 556, + "attempted_requests": 96, + "accepted_requests": 96 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/mixed_high_indegree-float32-r0/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/mixed_high_indegree-float32-r0/metrics.json new file mode 100644 index 0000000..0d33981 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/mixed_high_indegree-float32-r0/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float32", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986813545227, + "c0": -0.00025935107260011137, + "cg": 0.004937935154885054, + "cv": 0.9950124621391296, + "threshold": -0.04500000178813934, + "reset": -0.052000001072883606, + "seed_volt": -0.04399999976158142 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 128, + "edges": 266, + "steps": 500, + "total_spikes": 106, + "arriving_edges": 626, + "accepted_arriving_edges": 556, + "requested": 96, + "accepted_requests": 96, + "rejected_requests": 0, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.0002014019996749994, + "diagnostic_simulation_seconds": 0.14375347899976987, + "wall_seconds": 0.16654734799976723, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 1235968, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "11f07dd0a3e62b6ee66373022539a68daad766dce26fa759654f0201599f6703", + "arrays.npz": "63fb734a967aee5f77709788ad9bd7d8783c2209c34f0e1d9aa6a0a8b7a6ecf5" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/mixed_high_indegree-float32-r1/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/mixed_high_indegree-float32-r1/comparison.json new file mode 100644 index 0000000..1d2c3d4 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/mixed_high_indegree-float32-r1/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "mixed_high_indegree", + "precision": "float32", + "repeat": 1, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 106, + "gpu_events": 106, + "due_edges": 626, + "accepted_edges": 556, + "attempted_requests": 96, + "accepted_requests": 96 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/mixed_high_indegree-float32-r1/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/mixed_high_indegree-float32-r1/metrics.json new file mode 100644 index 0000000..4b15f7a --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/mixed_high_indegree-float32-r1/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float32", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986813545227, + "c0": -0.00025935107260011137, + "cg": 0.004937935154885054, + "cv": 0.9950124621391296, + "threshold": -0.04500000178813934, + "reset": -0.052000001072883606, + "seed_volt": -0.04399999976158142 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 128, + "edges": 266, + "steps": 500, + "total_spikes": 106, + "arriving_edges": 626, + "accepted_arriving_edges": 556, + "requested": 96, + "accepted_requests": 96, + "rejected_requests": 0, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.00020576000042638043, + "diagnostic_simulation_seconds": 0.1416857659996822, + "wall_seconds": 0.16383130800022627, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 1235968, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "11f07dd0a3e62b6ee66373022539a68daad766dce26fa759654f0201599f6703", + "arrays.npz": "63fb734a967aee5f77709788ad9bd7d8783c2209c34f0e1d9aa6a0a8b7a6ecf5" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/mixed_high_indegree-float32-r2/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/mixed_high_indegree-float32-r2/comparison.json new file mode 100644 index 0000000..07b155f --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/mixed_high_indegree-float32-r2/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "mixed_high_indegree", + "precision": "float32", + "repeat": 2, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 106, + "gpu_events": 106, + "due_edges": 626, + "accepted_edges": 556, + "attempted_requests": 96, + "accepted_requests": 96 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/mixed_high_indegree-float32-r2/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/mixed_high_indegree-float32-r2/metrics.json new file mode 100644 index 0000000..3ed0494 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/mixed_high_indegree-float32-r2/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float32", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986813545227, + "c0": -0.00025935107260011137, + "cg": 0.004937935154885054, + "cv": 0.9950124621391296, + "threshold": -0.04500000178813934, + "reset": -0.052000001072883606, + "seed_volt": -0.04399999976158142 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 128, + "edges": 266, + "steps": 500, + "total_spikes": 106, + "arriving_edges": 626, + "accepted_arriving_edges": 556, + "requested": 96, + "accepted_requests": 96, + "rejected_requests": 0, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.00019358800000190968, + "diagnostic_simulation_seconds": 0.14196772700006477, + "wall_seconds": 0.16415478499993696, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 1235968, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "11f07dd0a3e62b6ee66373022539a68daad766dce26fa759654f0201599f6703", + "arrays.npz": "63fb734a967aee5f77709788ad9bd7d8783c2209c34f0e1d9aa6a0a8b7a6ecf5" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/mixed_high_indegree-float64-r0/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/mixed_high_indegree-float64-r0/comparison.json new file mode 100644 index 0000000..e19b95f --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/mixed_high_indegree-float64-r0/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "mixed_high_indegree", + "precision": "float64", + "repeat": 0, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 106, + "gpu_events": 106, + "due_edges": 626, + "accepted_edges": 556, + "attempted_requests": 96, + "accepted_requests": 96 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/mixed_high_indegree-float64-r0/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/mixed_high_indegree-float64-r0/metrics.json new file mode 100644 index 0000000..dba01d9 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/mixed_high_indegree-float64-r0/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float64", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 128, + "edges": 266, + "steps": 500, + "total_spikes": 106, + "arriving_edges": 626, + "accepted_arriving_edges": 556, + "requested": 96, + "accepted_requests": 96, + "rejected_requests": 0, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.00020496899969657534, + "diagnostic_simulation_seconds": 0.14339891300005547, + "wall_seconds": 0.17037530399966272, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 2262016, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "11f07dd0a3e62b6ee66373022539a68daad766dce26fa759654f0201599f6703", + "arrays.npz": "63fb734a967aee5f77709788ad9bd7d8783c2209c34f0e1d9aa6a0a8b7a6ecf5" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/mixed_high_indegree-float64-r1/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/mixed_high_indegree-float64-r1/comparison.json new file mode 100644 index 0000000..3ac527c --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/mixed_high_indegree-float64-r1/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "mixed_high_indegree", + "precision": "float64", + "repeat": 1, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 106, + "gpu_events": 106, + "due_edges": 626, + "accepted_edges": 556, + "attempted_requests": 96, + "accepted_requests": 96 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/mixed_high_indegree-float64-r1/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/mixed_high_indegree-float64-r1/metrics.json new file mode 100644 index 0000000..75b8575 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/mixed_high_indegree-float64-r1/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float64", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 128, + "edges": 266, + "steps": 500, + "total_spikes": 106, + "arriving_edges": 626, + "accepted_arriving_edges": 556, + "requested": 96, + "accepted_requests": 96, + "rejected_requests": 0, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.00020051100000273436, + "diagnostic_simulation_seconds": 0.14240601999972569, + "wall_seconds": 0.16942483899993022, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 2262016, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "11f07dd0a3e62b6ee66373022539a68daad766dce26fa759654f0201599f6703", + "arrays.npz": "63fb734a967aee5f77709788ad9bd7d8783c2209c34f0e1d9aa6a0a8b7a6ecf5" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/mixed_high_indegree-float64-r2/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/mixed_high_indegree-float64-r2/comparison.json new file mode 100644 index 0000000..d298e7f --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/mixed_high_indegree-float64-r2/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "mixed_high_indegree", + "precision": "float64", + "repeat": 2, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 106, + "gpu_events": 106, + "due_edges": 626, + "accepted_edges": 556, + "attempted_requests": 96, + "accepted_requests": 96 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/mixed_high_indegree-float64-r2/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/mixed_high_indegree-float64-r2/metrics.json new file mode 100644 index 0000000..3ca9e8f --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/mixed_high_indegree-float64-r2/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float64", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 128, + "edges": 266, + "steps": 500, + "total_spikes": 106, + "arriving_edges": 626, + "accepted_arriving_edges": 556, + "requested": 96, + "accepted_requests": 96, + "rejected_requests": 0, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.00019028199994863826, + "diagnostic_simulation_seconds": 0.14271545099973082, + "wall_seconds": 0.1695392299998275, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 2262016, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "11f07dd0a3e62b6ee66373022539a68daad766dce26fa759654f0201599f6703", + "arrays.npz": "63fb734a967aee5f77709788ad9bd7d8783c2209c34f0e1d9aa6a0a8b7a6ecf5" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/motif_feedforward-float32-r0/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/motif_feedforward-float32-r0/comparison.json new file mode 100644 index 0000000..dfa4e5a --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/motif_feedforward-float32-r0/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "motif_feedforward", + "precision": "float32", + "repeat": 0, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 3, + "gpu_events": 3, + "due_edges": 3, + "accepted_edges": 3, + "attempted_requests": 1, + "accepted_requests": 1 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/motif_feedforward-float32-r0/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/motif_feedforward-float32-r0/metrics.json new file mode 100644 index 0000000..1c3bc57 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/motif_feedforward-float32-r0/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float32", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986813545227, + "c0": -0.00025935107260011137, + "cg": 0.004937935154885054, + "cv": 0.9950124621391296, + "threshold": -0.04500000178813934, + "reset": -0.052000001072883606, + "seed_volt": -0.04399999976158142 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 5, + "edges": 4, + "steps": 1000, + "total_spikes": 3, + "arriving_edges": 3, + "accepted_arriving_edges": 3, + "requested": 1, + "accepted_requests": 1, + "rejected_requests": 0, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.00016819100028442335, + "diagnostic_simulation_seconds": 0.2594092049998835, + "wall_seconds": 0.26215386400008356, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 109568, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "1bb9ef28864e46336581d23fc15eaf80a329ee4d1a439abd0fc18c52f87a2b77", + "arrays.npz": "cdba32792924258112a2fd6ffaca5e329c71404840a290a9187e5d3e2b6550d4" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/motif_feedforward-float32-r1/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/motif_feedforward-float32-r1/comparison.json new file mode 100644 index 0000000..2f8072d --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/motif_feedforward-float32-r1/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "motif_feedforward", + "precision": "float32", + "repeat": 1, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 3, + "gpu_events": 3, + "due_edges": 3, + "accepted_edges": 3, + "attempted_requests": 1, + "accepted_requests": 1 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/motif_feedforward-float32-r1/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/motif_feedforward-float32-r1/metrics.json new file mode 100644 index 0000000..b4b4c08 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/motif_feedforward-float32-r1/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float32", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986813545227, + "c0": -0.00025935107260011137, + "cg": 0.004937935154885054, + "cv": 0.9950124621391296, + "threshold": -0.04500000178813934, + "reset": -0.052000001072883606, + "seed_volt": -0.04399999976158142 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 5, + "edges": 4, + "steps": 1000, + "total_spikes": 3, + "arriving_edges": 3, + "accepted_arriving_edges": 3, + "requested": 1, + "accepted_requests": 1, + "rejected_requests": 0, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.00018854799964174163, + "diagnostic_simulation_seconds": 0.2609780329999012, + "wall_seconds": 0.2642778059998818, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 109568, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "1bb9ef28864e46336581d23fc15eaf80a329ee4d1a439abd0fc18c52f87a2b77", + "arrays.npz": "cdba32792924258112a2fd6ffaca5e329c71404840a290a9187e5d3e2b6550d4" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/motif_feedforward-float32-r2/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/motif_feedforward-float32-r2/comparison.json new file mode 100644 index 0000000..e862e96 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/motif_feedforward-float32-r2/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "motif_feedforward", + "precision": "float32", + "repeat": 2, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 3, + "gpu_events": 3, + "due_edges": 3, + "accepted_edges": 3, + "attempted_requests": 1, + "accepted_requests": 1 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/motif_feedforward-float32-r2/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/motif_feedforward-float32-r2/metrics.json new file mode 100644 index 0000000..cd93975 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/motif_feedforward-float32-r2/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float32", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986813545227, + "c0": -0.00025935107260011137, + "cg": 0.004937935154885054, + "cv": 0.9950124621391296, + "threshold": -0.04500000178813934, + "reset": -0.052000001072883606, + "seed_volt": -0.04399999976158142 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 5, + "edges": 4, + "steps": 1000, + "total_spikes": 3, + "arriving_edges": 3, + "accepted_arriving_edges": 3, + "requested": 1, + "accepted_requests": 1, + "rejected_requests": 0, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.0002065710000351828, + "diagnostic_simulation_seconds": 0.2581014049997066, + "wall_seconds": 0.2608520139997381, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 109568, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "1bb9ef28864e46336581d23fc15eaf80a329ee4d1a439abd0fc18c52f87a2b77", + "arrays.npz": "cdba32792924258112a2fd6ffaca5e329c71404840a290a9187e5d3e2b6550d4" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/motif_feedforward-float64-r0/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/motif_feedforward-float64-r0/comparison.json new file mode 100644 index 0000000..3dcef72 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/motif_feedforward-float64-r0/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "motif_feedforward", + "precision": "float64", + "repeat": 0, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 3, + "gpu_events": 3, + "due_edges": 3, + "accepted_edges": 3, + "attempted_requests": 1, + "accepted_requests": 1 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/motif_feedforward-float64-r0/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/motif_feedforward-float64-r0/metrics.json new file mode 100644 index 0000000..a0c7004 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/motif_feedforward-float64-r0/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float64", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 5, + "edges": 4, + "steps": 1000, + "total_spikes": 3, + "arriving_edges": 3, + "accepted_arriving_edges": 3, + "requested": 1, + "accepted_requests": 1, + "rejected_requests": 0, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.0001944689997799287, + "diagnostic_simulation_seconds": 0.2595021759998417, + "wall_seconds": 0.2630789499999082, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 189440, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "1bb9ef28864e46336581d23fc15eaf80a329ee4d1a439abd0fc18c52f87a2b77", + "arrays.npz": "cdba32792924258112a2fd6ffaca5e329c71404840a290a9187e5d3e2b6550d4" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/motif_feedforward-float64-r1/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/motif_feedforward-float64-r1/comparison.json new file mode 100644 index 0000000..a27451a --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/motif_feedforward-float64-r1/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "motif_feedforward", + "precision": "float64", + "repeat": 1, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 3, + "gpu_events": 3, + "due_edges": 3, + "accepted_edges": 3, + "attempted_requests": 1, + "accepted_requests": 1 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/motif_feedforward-float64-r1/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/motif_feedforward-float64-r1/metrics.json new file mode 100644 index 0000000..84c4457 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/motif_feedforward-float64-r1/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float64", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 5, + "edges": 4, + "steps": 1000, + "total_spikes": 3, + "arriving_edges": 3, + "accepted_arriving_edges": 3, + "requested": 1, + "accepted_requests": 1, + "rejected_requests": 0, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.00015972500023053726, + "diagnostic_simulation_seconds": 0.2602792309999131, + "wall_seconds": 0.2636794300001384, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 189440, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "1bb9ef28864e46336581d23fc15eaf80a329ee4d1a439abd0fc18c52f87a2b77", + "arrays.npz": "cdba32792924258112a2fd6ffaca5e329c71404840a290a9187e5d3e2b6550d4" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/motif_feedforward-float64-r2/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/motif_feedforward-float64-r2/comparison.json new file mode 100644 index 0000000..67b957f --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/motif_feedforward-float64-r2/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "motif_feedforward", + "precision": "float64", + "repeat": 2, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 3, + "gpu_events": 3, + "due_edges": 3, + "accepted_edges": 3, + "attempted_requests": 1, + "accepted_requests": 1 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/motif_feedforward-float64-r2/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/motif_feedforward-float64-r2/metrics.json new file mode 100644 index 0000000..0f4249a --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/motif_feedforward-float64-r2/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float64", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 5, + "edges": 4, + "steps": 1000, + "total_spikes": 3, + "arriving_edges": 3, + "accepted_arriving_edges": 3, + "requested": 1, + "accepted_requests": 1, + "rejected_requests": 0, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.00016598699994574417, + "diagnostic_simulation_seconds": 0.25763149300018995, + "wall_seconds": 0.2609611110001424, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 189440, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "1bb9ef28864e46336581d23fc15eaf80a329ee4d1a439abd0fc18c52f87a2b77", + "arrays.npz": "cdba32792924258112a2fd6ffaca5e329c71404840a290a9187e5d3e2b6550d4" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/motif_five-float32-r0/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/motif_five-float32-r0/comparison.json new file mode 100644 index 0000000..c05452a --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/motif_five-float32-r0/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "motif_five", + "precision": "float32", + "repeat": 0, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 60, + "gpu_events": 60, + "due_edges": 185, + "accepted_edges": 155, + "attempted_requests": 1, + "accepted_requests": 1 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/motif_five-float32-r0/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/motif_five-float32-r0/metrics.json new file mode 100644 index 0000000..246de6f --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/motif_five-float32-r0/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float32", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986813545227, + "c0": -0.00025935107260011137, + "cg": 0.004937935154885054, + "cv": 0.9950124621391296, + "threshold": -0.04500000178813934, + "reset": -0.052000001072883606, + "seed_volt": -0.04399999976158142 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 5, + "edges": 13, + "steps": 1000, + "total_spikes": 60, + "arriving_edges": 185, + "accepted_arriving_edges": 155, + "requested": 1, + "accepted_requests": 1, + "rejected_requests": 0, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.00018459099965184578, + "diagnostic_simulation_seconds": 0.3082984409998062, + "wall_seconds": 0.31204186399963874, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 109568, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "f78ba9423ed1dfb686cd79a0a003cda0bf9e7603d37e8d318118e08766ece7b3", + "arrays.npz": "712a18275609cc71875e4ea04ca97222de917de9b1d6760f4052e2a3f0dd465e" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/motif_five-float32-r1/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/motif_five-float32-r1/comparison.json new file mode 100644 index 0000000..09c7342 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/motif_five-float32-r1/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "motif_five", + "precision": "float32", + "repeat": 1, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 60, + "gpu_events": 60, + "due_edges": 185, + "accepted_edges": 155, + "attempted_requests": 1, + "accepted_requests": 1 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/motif_five-float32-r1/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/motif_five-float32-r1/metrics.json new file mode 100644 index 0000000..a93c751 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/motif_five-float32-r1/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float32", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986813545227, + "c0": -0.00025935107260011137, + "cg": 0.004937935154885054, + "cv": 0.9950124621391296, + "threshold": -0.04500000178813934, + "reset": -0.052000001072883606, + "seed_volt": -0.04399999976158142 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 5, + "edges": 13, + "steps": 1000, + "total_spikes": 60, + "arriving_edges": 185, + "accepted_arriving_edges": 155, + "requested": 1, + "accepted_requests": 1, + "rejected_requests": 0, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.00016160800032594125, + "diagnostic_simulation_seconds": 0.30764471299971774, + "wall_seconds": 0.3115395660001923, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 109568, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "f78ba9423ed1dfb686cd79a0a003cda0bf9e7603d37e8d318118e08766ece7b3", + "arrays.npz": "712a18275609cc71875e4ea04ca97222de917de9b1d6760f4052e2a3f0dd465e" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/motif_five-float32-r2/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/motif_five-float32-r2/comparison.json new file mode 100644 index 0000000..781867b --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/motif_five-float32-r2/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "motif_five", + "precision": "float32", + "repeat": 2, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 60, + "gpu_events": 60, + "due_edges": 185, + "accepted_edges": 155, + "attempted_requests": 1, + "accepted_requests": 1 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/motif_five-float32-r2/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/motif_five-float32-r2/metrics.json new file mode 100644 index 0000000..ded53d6 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/motif_five-float32-r2/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float32", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986813545227, + "c0": -0.00025935107260011137, + "cg": 0.004937935154885054, + "cv": 0.9950124621391296, + "threshold": -0.04500000178813934, + "reset": -0.052000001072883606, + "seed_volt": -0.04399999976158142 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 5, + "edges": 13, + "steps": 1000, + "total_spikes": 60, + "arriving_edges": 185, + "accepted_arriving_edges": 155, + "requested": 1, + "accepted_requests": 1, + "rejected_requests": 0, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.0001617789998817898, + "diagnostic_simulation_seconds": 0.3065581679998104, + "wall_seconds": 0.31034543200030384, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 109568, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "f78ba9423ed1dfb686cd79a0a003cda0bf9e7603d37e8d318118e08766ece7b3", + "arrays.npz": "712a18275609cc71875e4ea04ca97222de917de9b1d6760f4052e2a3f0dd465e" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/motif_five-float64-r0/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/motif_five-float64-r0/comparison.json new file mode 100644 index 0000000..a63ad75 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/motif_five-float64-r0/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "motif_five", + "precision": "float64", + "repeat": 0, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 60, + "gpu_events": 60, + "due_edges": 185, + "accepted_edges": 155, + "attempted_requests": 1, + "accepted_requests": 1 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/motif_five-float64-r0/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/motif_five-float64-r0/metrics.json new file mode 100644 index 0000000..ef22aaf --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/motif_five-float64-r0/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float64", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 5, + "edges": 13, + "steps": 1000, + "total_spikes": 60, + "arriving_edges": 185, + "accepted_arriving_edges": 155, + "requested": 1, + "accepted_requests": 1, + "rejected_requests": 0, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.00016768999967098352, + "diagnostic_simulation_seconds": 0.3074906550000378, + "wall_seconds": 0.3120816030000242, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 189440, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "f78ba9423ed1dfb686cd79a0a003cda0bf9e7603d37e8d318118e08766ece7b3", + "arrays.npz": "712a18275609cc71875e4ea04ca97222de917de9b1d6760f4052e2a3f0dd465e" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/motif_five-float64-r1/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/motif_five-float64-r1/comparison.json new file mode 100644 index 0000000..ce41259 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/motif_five-float64-r1/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "motif_five", + "precision": "float64", + "repeat": 1, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 60, + "gpu_events": 60, + "due_edges": 185, + "accepted_edges": 155, + "attempted_requests": 1, + "accepted_requests": 1 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/motif_five-float64-r1/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/motif_five-float64-r1/metrics.json new file mode 100644 index 0000000..c4d2ca4 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/motif_five-float64-r1/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float64", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 5, + "edges": 13, + "steps": 1000, + "total_spikes": 60, + "arriving_edges": 185, + "accepted_arriving_edges": 155, + "requested": 1, + "accepted_requests": 1, + "rejected_requests": 0, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.0001685209999777726, + "diagnostic_simulation_seconds": 0.3072411349999129, + "wall_seconds": 0.3115505020000455, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 189440, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "f78ba9423ed1dfb686cd79a0a003cda0bf9e7603d37e8d318118e08766ece7b3", + "arrays.npz": "712a18275609cc71875e4ea04ca97222de917de9b1d6760f4052e2a3f0dd465e" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/motif_five-float64-r2/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/motif_five-float64-r2/comparison.json new file mode 100644 index 0000000..c34704d --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/motif_five-float64-r2/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "motif_five", + "precision": "float64", + "repeat": 2, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 60, + "gpu_events": 60, + "due_edges": 185, + "accepted_edges": 155, + "attempted_requests": 1, + "accepted_requests": 1 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/motif_five-float64-r2/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/motif_five-float64-r2/metrics.json new file mode 100644 index 0000000..ab89632 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/motif_five-float64-r2/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float64", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 5, + "edges": 13, + "steps": 1000, + "total_spikes": 60, + "arriving_edges": 185, + "accepted_arriving_edges": 155, + "requested": 1, + "accepted_requests": 1, + "rejected_requests": 0, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.00016542499997740379, + "diagnostic_simulation_seconds": 0.30913330000021233, + "wall_seconds": 0.3135759040001176, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 189440, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "f78ba9423ed1dfb686cd79a0a003cda0bf9e7603d37e8d318118e08766ece7b3", + "arrays.npz": "712a18275609cc71875e4ea04ca97222de917de9b1d6760f4052e2a3f0dd465e" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/motif_no_input-float32-r0/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/motif_no_input-float32-r0/comparison.json new file mode 100644 index 0000000..dc96e00 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/motif_no_input-float32-r0/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "motif_no_input", + "precision": "float32", + "repeat": 0, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 0, + "gpu_events": 0, + "due_edges": 0, + "accepted_edges": 0, + "attempted_requests": 0, + "accepted_requests": 0 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/motif_no_input-float32-r0/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/motif_no_input-float32-r0/metrics.json new file mode 100644 index 0000000..09418d1 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/motif_no_input-float32-r0/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float32", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986813545227, + "c0": -0.00025935107260011137, + "cg": 0.004937935154885054, + "cv": 0.9950124621391296, + "threshold": -0.04500000178813934, + "reset": -0.052000001072883606, + "seed_volt": -0.04399999976158142 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 5, + "edges": 13, + "steps": 1000, + "total_spikes": 0, + "arriving_edges": 0, + "accepted_arriving_edges": 0, + "requested": 0, + "accepted_requests": 0, + "rejected_requests": 0, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.00016382300009354367, + "diagnostic_simulation_seconds": 0.2560492630000226, + "wall_seconds": 0.25887218500020026, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 102400, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "02adfcd0717aa2d98eb571107136eae7186166ce1c7d7eb87df23bedb452fbd9", + "arrays.npz": "3e3f7c2bd477e097761d3e34745f88fb215636c74d89a9e77a2b9a5f2fc738c3" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/motif_no_input-float32-r1/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/motif_no_input-float32-r1/comparison.json new file mode 100644 index 0000000..31bbeaa --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/motif_no_input-float32-r1/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "motif_no_input", + "precision": "float32", + "repeat": 1, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 0, + "gpu_events": 0, + "due_edges": 0, + "accepted_edges": 0, + "attempted_requests": 0, + "accepted_requests": 0 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/motif_no_input-float32-r1/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/motif_no_input-float32-r1/metrics.json new file mode 100644 index 0000000..3449b27 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/motif_no_input-float32-r1/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float32", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986813545227, + "c0": -0.00025935107260011137, + "cg": 0.004937935154885054, + "cv": 0.9950124621391296, + "threshold": -0.04500000178813934, + "reset": -0.052000001072883606, + "seed_volt": -0.04399999976158142 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 5, + "edges": 13, + "steps": 1000, + "total_spikes": 0, + "arriving_edges": 0, + "accepted_arriving_edges": 0, + "requested": 0, + "accepted_requests": 0, + "rejected_requests": 0, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.00020400699986566906, + "diagnostic_simulation_seconds": 0.2550842149998971, + "wall_seconds": 0.25747468000008666, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 102400, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "02adfcd0717aa2d98eb571107136eae7186166ce1c7d7eb87df23bedb452fbd9", + "arrays.npz": "3e3f7c2bd477e097761d3e34745f88fb215636c74d89a9e77a2b9a5f2fc738c3" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/motif_no_input-float32-r2/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/motif_no_input-float32-r2/comparison.json new file mode 100644 index 0000000..dfc9b29 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/motif_no_input-float32-r2/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "motif_no_input", + "precision": "float32", + "repeat": 2, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 0, + "gpu_events": 0, + "due_edges": 0, + "accepted_edges": 0, + "attempted_requests": 0, + "accepted_requests": 0 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/motif_no_input-float32-r2/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/motif_no_input-float32-r2/metrics.json new file mode 100644 index 0000000..a3fe379 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/motif_no_input-float32-r2/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float32", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986813545227, + "c0": -0.00025935107260011137, + "cg": 0.004937935154885054, + "cv": 0.9950124621391296, + "threshold": -0.04500000178813934, + "reset": -0.052000001072883606, + "seed_volt": -0.04399999976158142 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 5, + "edges": 13, + "steps": 1000, + "total_spikes": 0, + "arriving_edges": 0, + "accepted_arriving_edges": 0, + "requested": 0, + "accepted_requests": 0, + "rejected_requests": 0, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.00016584600007263361, + "diagnostic_simulation_seconds": 0.2552194849999978, + "wall_seconds": 0.2575016490000053, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 102400, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "02adfcd0717aa2d98eb571107136eae7186166ce1c7d7eb87df23bedb452fbd9", + "arrays.npz": "3e3f7c2bd477e097761d3e34745f88fb215636c74d89a9e77a2b9a5f2fc738c3" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/motif_no_input-float64-r0/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/motif_no_input-float64-r0/comparison.json new file mode 100644 index 0000000..036386e --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/motif_no_input-float64-r0/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "motif_no_input", + "precision": "float64", + "repeat": 0, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 0, + "gpu_events": 0, + "due_edges": 0, + "accepted_edges": 0, + "attempted_requests": 0, + "accepted_requests": 0 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/motif_no_input-float64-r0/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/motif_no_input-float64-r0/metrics.json new file mode 100644 index 0000000..c1f8fd8 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/motif_no_input-float64-r0/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float64", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 5, + "edges": 13, + "steps": 1000, + "total_spikes": 0, + "arriving_edges": 0, + "accepted_arriving_edges": 0, + "requested": 0, + "accepted_requests": 0, + "rejected_requests": 0, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.000176245000147901, + "diagnostic_simulation_seconds": 0.25657017800040194, + "wall_seconds": 0.25931909400014774, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 182272, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "02adfcd0717aa2d98eb571107136eae7186166ce1c7d7eb87df23bedb452fbd9", + "arrays.npz": "3e3f7c2bd477e097761d3e34745f88fb215636c74d89a9e77a2b9a5f2fc738c3" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/motif_no_input-float64-r1/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/motif_no_input-float64-r1/comparison.json new file mode 100644 index 0000000..5b717f2 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/motif_no_input-float64-r1/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "motif_no_input", + "precision": "float64", + "repeat": 1, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 0, + "gpu_events": 0, + "due_edges": 0, + "accepted_edges": 0, + "attempted_requests": 0, + "accepted_requests": 0 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/motif_no_input-float64-r1/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/motif_no_input-float64-r1/metrics.json new file mode 100644 index 0000000..9fd158d --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/motif_no_input-float64-r1/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float64", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 5, + "edges": 13, + "steps": 1000, + "total_spikes": 0, + "arriving_edges": 0, + "accepted_arriving_edges": 0, + "requested": 0, + "accepted_requests": 0, + "rejected_requests": 0, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.00015920399982860545, + "diagnostic_simulation_seconds": 0.25570574199991825, + "wall_seconds": 0.25834135900004185, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 182272, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "02adfcd0717aa2d98eb571107136eae7186166ce1c7d7eb87df23bedb452fbd9", + "arrays.npz": "3e3f7c2bd477e097761d3e34745f88fb215636c74d89a9e77a2b9a5f2fc738c3" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/motif_no_input-float64-r2/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/motif_no_input-float64-r2/comparison.json new file mode 100644 index 0000000..b326e24 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/motif_no_input-float64-r2/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "motif_no_input", + "precision": "float64", + "repeat": 2, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 0, + "gpu_events": 0, + "due_edges": 0, + "accepted_edges": 0, + "attempted_requests": 0, + "accepted_requests": 0 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/motif_no_input-float64-r2/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/motif_no_input-float64-r2/metrics.json new file mode 100644 index 0000000..c11e2b3 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/motif_no_input-float64-r2/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float64", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 5, + "edges": 13, + "steps": 1000, + "total_spikes": 0, + "arriving_edges": 0, + "accepted_arriving_edges": 0, + "requested": 0, + "accepted_requests": 0, + "rejected_requests": 0, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.0001584330002515344, + "diagnostic_simulation_seconds": 0.2556000760000643, + "wall_seconds": 0.2581806120001602, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 182272, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "02adfcd0717aa2d98eb571107136eae7186166ce1c7d7eb87df23bedb452fbd9", + "arrays.npz": "3e3f7c2bd477e097761d3e34745f88fb215636c74d89a9e77a2b9a5f2fc738c3" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/motif_pair-float32-r0/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/motif_pair-float32-r0/comparison.json new file mode 100644 index 0000000..7d2cb0f --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/motif_pair-float32-r0/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "motif_pair", + "precision": "float32", + "repeat": 0, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 22, + "gpu_events": 22, + "due_edges": 21, + "accepted_edges": 21, + "attempted_requests": 1, + "accepted_requests": 1 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/motif_pair-float32-r0/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/motif_pair-float32-r0/metrics.json new file mode 100644 index 0000000..e253a64 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/motif_pair-float32-r0/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float32", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986813545227, + "c0": -0.00025935107260011137, + "cg": 0.004937935154885054, + "cv": 0.9950124621391296, + "threshold": -0.04500000178813934, + "reset": -0.052000001072883606, + "seed_volt": -0.04399999976158142 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 2, + "edges": 2, + "steps": 1000, + "total_spikes": 22, + "arriving_edges": 21, + "accepted_arriving_edges": 21, + "requested": 1, + "accepted_requests": 1, + "rejected_requests": 0, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.00018420000014884863, + "diagnostic_simulation_seconds": 0.2725007209996875, + "wall_seconds": 0.27486929499991675, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 51712, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "faee4cdcdc93293b4b5e15d852a6a97b76767ce6aa7c534b12c6f204264daa7a", + "arrays.npz": "7c01e762480777b22474264f28cc413e554314602fad320a33b53dd028a1fb5a" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/motif_pair-float32-r1/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/motif_pair-float32-r1/comparison.json new file mode 100644 index 0000000..dc1f506 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/motif_pair-float32-r1/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "motif_pair", + "precision": "float32", + "repeat": 1, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 22, + "gpu_events": 22, + "due_edges": 21, + "accepted_edges": 21, + "attempted_requests": 1, + "accepted_requests": 1 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/motif_pair-float32-r1/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/motif_pair-float32-r1/metrics.json new file mode 100644 index 0000000..367361b --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/motif_pair-float32-r1/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float32", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986813545227, + "c0": -0.00025935107260011137, + "cg": 0.004937935154885054, + "cv": 0.9950124621391296, + "threshold": -0.04500000178813934, + "reset": -0.052000001072883606, + "seed_volt": -0.04399999976158142 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 2, + "edges": 2, + "steps": 1000, + "total_spikes": 22, + "arriving_edges": 21, + "accepted_arriving_edges": 21, + "requested": 1, + "accepted_requests": 1, + "rejected_requests": 0, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.00015990500014595455, + "diagnostic_simulation_seconds": 0.27323022299970035, + "wall_seconds": 0.2755656160002218, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 51712, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "faee4cdcdc93293b4b5e15d852a6a97b76767ce6aa7c534b12c6f204264daa7a", + "arrays.npz": "7c01e762480777b22474264f28cc413e554314602fad320a33b53dd028a1fb5a" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/motif_pair-float32-r2/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/motif_pair-float32-r2/comparison.json new file mode 100644 index 0000000..772b908 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/motif_pair-float32-r2/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "motif_pair", + "precision": "float32", + "repeat": 2, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 22, + "gpu_events": 22, + "due_edges": 21, + "accepted_edges": 21, + "attempted_requests": 1, + "accepted_requests": 1 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/motif_pair-float32-r2/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/motif_pair-float32-r2/metrics.json new file mode 100644 index 0000000..821f0c0 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/motif_pair-float32-r2/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float32", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986813545227, + "c0": -0.00025935107260011137, + "cg": 0.004937935154885054, + "cv": 0.9950124621391296, + "threshold": -0.04500000178813934, + "reset": -0.052000001072883606, + "seed_volt": -0.04399999976158142 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 2, + "edges": 2, + "steps": 1000, + "total_spikes": 22, + "arriving_edges": 21, + "accepted_arriving_edges": 21, + "requested": 1, + "accepted_requests": 1, + "rejected_requests": 0, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.00015941399988150806, + "diagnostic_simulation_seconds": 0.27294590599967705, + "wall_seconds": 0.27523873999962234, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 51712, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "faee4cdcdc93293b4b5e15d852a6a97b76767ce6aa7c534b12c6f204264daa7a", + "arrays.npz": "7c01e762480777b22474264f28cc413e554314602fad320a33b53dd028a1fb5a" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/motif_pair-float64-r0/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/motif_pair-float64-r0/comparison.json new file mode 100644 index 0000000..d8f1755 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/motif_pair-float64-r0/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "motif_pair", + "precision": "float64", + "repeat": 0, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 22, + "gpu_events": 22, + "due_edges": 21, + "accepted_edges": 21, + "attempted_requests": 1, + "accepted_requests": 1 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/motif_pair-float64-r0/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/motif_pair-float64-r0/metrics.json new file mode 100644 index 0000000..55ce565 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/motif_pair-float64-r0/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float64", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 2, + "edges": 2, + "steps": 1000, + "total_spikes": 22, + "arriving_edges": 21, + "accepted_arriving_edges": 21, + "requested": 1, + "accepted_requests": 1, + "rejected_requests": 0, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.00018125499991583638, + "diagnostic_simulation_seconds": 0.274172586000077, + "wall_seconds": 0.27661284300029365, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 83968, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "faee4cdcdc93293b4b5e15d852a6a97b76767ce6aa7c534b12c6f204264daa7a", + "arrays.npz": "7c01e762480777b22474264f28cc413e554314602fad320a33b53dd028a1fb5a" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/motif_pair-float64-r1/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/motif_pair-float64-r1/comparison.json new file mode 100644 index 0000000..3d1fda0 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/motif_pair-float64-r1/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "motif_pair", + "precision": "float64", + "repeat": 1, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 22, + "gpu_events": 22, + "due_edges": 21, + "accepted_edges": 21, + "attempted_requests": 1, + "accepted_requests": 1 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/motif_pair-float64-r1/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/motif_pair-float64-r1/metrics.json new file mode 100644 index 0000000..d49af29 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/motif_pair-float64-r1/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float64", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 2, + "edges": 2, + "steps": 1000, + "total_spikes": 22, + "arriving_edges": 21, + "accepted_arriving_edges": 21, + "requested": 1, + "accepted_requests": 1, + "rejected_requests": 0, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.00015986500011422322, + "diagnostic_simulation_seconds": 0.2729806560000725, + "wall_seconds": 0.275331768000342, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 83968, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "faee4cdcdc93293b4b5e15d852a6a97b76767ce6aa7c534b12c6f204264daa7a", + "arrays.npz": "7c01e762480777b22474264f28cc413e554314602fad320a33b53dd028a1fb5a" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/motif_pair-float64-r2/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/motif_pair-float64-r2/comparison.json new file mode 100644 index 0000000..1a0799a --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/motif_pair-float64-r2/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "motif_pair", + "precision": "float64", + "repeat": 2, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 22, + "gpu_events": 22, + "due_edges": 21, + "accepted_edges": 21, + "attempted_requests": 1, + "accepted_requests": 1 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/motif_pair-float64-r2/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/motif_pair-float64-r2/metrics.json new file mode 100644 index 0000000..512c549 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/motif_pair-float64-r2/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float64", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 2, + "edges": 2, + "steps": 1000, + "total_spikes": 22, + "arriving_edges": 21, + "accepted_arriving_edges": 21, + "requested": 1, + "accepted_requests": 1, + "rejected_requests": 0, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.00016103699999803212, + "diagnostic_simulation_seconds": 0.274426448000213, + "wall_seconds": 0.2773065259998475, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 83968, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "faee4cdcdc93293b4b5e15d852a6a97b76767ce6aa7c534b12c6f204264daa7a", + "arrays.npz": "7c01e762480777b22474264f28cc413e554314602fad320a33b53dd028a1fb5a" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/motif_trio-float32-r0/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/motif_trio-float32-r0/comparison.json new file mode 100644 index 0000000..331f9a8 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/motif_trio-float32-r0/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "motif_trio", + "precision": "float32", + "repeat": 0, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 45, + "gpu_events": 45, + "due_edges": 88, + "accepted_edges": 87, + "attempted_requests": 1, + "accepted_requests": 1 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/motif_trio-float32-r0/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/motif_trio-float32-r0/metrics.json new file mode 100644 index 0000000..2524c5a --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/motif_trio-float32-r0/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float32", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986813545227, + "c0": -0.00025935107260011137, + "cg": 0.004937935154885054, + "cv": 0.9950124621391296, + "threshold": -0.04500000178813934, + "reset": -0.052000001072883606, + "seed_volt": -0.04399999976158142 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 3, + "edges": 6, + "steps": 1000, + "total_spikes": 45, + "arriving_edges": 88, + "accepted_arriving_edges": 87, + "requested": 1, + "accepted_requests": 1, + "rejected_requests": 0, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.00017180700024255202, + "diagnostic_simulation_seconds": 0.2947866049998993, + "wall_seconds": 0.29771240800027954, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 71168, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "da4b6cea0b8a33ca15e552425b55ce699d74ddf81660b02eeb30d5edcc4494cd", + "arrays.npz": "a40e803b1227d4bb6b2c24d76bdf1454cb63ace61ebb9e77ff01010dd91cab37" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/motif_trio-float32-r1/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/motif_trio-float32-r1/comparison.json new file mode 100644 index 0000000..e8e26ab --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/motif_trio-float32-r1/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "motif_trio", + "precision": "float32", + "repeat": 1, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 45, + "gpu_events": 45, + "due_edges": 88, + "accepted_edges": 87, + "attempted_requests": 1, + "accepted_requests": 1 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/motif_trio-float32-r1/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/motif_trio-float32-r1/metrics.json new file mode 100644 index 0000000..b31405b --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/motif_trio-float32-r1/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float32", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986813545227, + "c0": -0.00025935107260011137, + "cg": 0.004937935154885054, + "cv": 0.9950124621391296, + "threshold": -0.04500000178813934, + "reset": -0.052000001072883606, + "seed_volt": -0.04399999976158142 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 3, + "edges": 6, + "steps": 1000, + "total_spikes": 45, + "arriving_edges": 88, + "accepted_arriving_edges": 87, + "requested": 1, + "accepted_requests": 1, + "rejected_requests": 0, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.00015936399995553074, + "diagnostic_simulation_seconds": 0.29450925199989797, + "wall_seconds": 0.29703039799960607, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 71168, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "da4b6cea0b8a33ca15e552425b55ce699d74ddf81660b02eeb30d5edcc4494cd", + "arrays.npz": "a40e803b1227d4bb6b2c24d76bdf1454cb63ace61ebb9e77ff01010dd91cab37" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/motif_trio-float32-r2/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/motif_trio-float32-r2/comparison.json new file mode 100644 index 0000000..7a98d4c --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/motif_trio-float32-r2/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "motif_trio", + "precision": "float32", + "repeat": 2, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 45, + "gpu_events": 45, + "due_edges": 88, + "accepted_edges": 87, + "attempted_requests": 1, + "accepted_requests": 1 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/motif_trio-float32-r2/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/motif_trio-float32-r2/metrics.json new file mode 100644 index 0000000..bfd0ab3 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/motif_trio-float32-r2/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float32", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986813545227, + "c0": -0.00025935107260011137, + "cg": 0.004937935154885054, + "cv": 0.9950124621391296, + "threshold": -0.04500000178813934, + "reset": -0.052000001072883606, + "seed_volt": -0.04399999976158142 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 3, + "edges": 6, + "steps": 1000, + "total_spikes": 45, + "arriving_edges": 88, + "accepted_arriving_edges": 87, + "requested": 1, + "accepted_requests": 1, + "rejected_requests": 0, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.00016504499990332988, + "diagnostic_simulation_seconds": 0.29396144199972696, + "wall_seconds": 0.2965002020000611, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 71168, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "da4b6cea0b8a33ca15e552425b55ce699d74ddf81660b02eeb30d5edcc4494cd", + "arrays.npz": "a40e803b1227d4bb6b2c24d76bdf1454cb63ace61ebb9e77ff01010dd91cab37" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/motif_trio-float64-r0/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/motif_trio-float64-r0/comparison.json new file mode 100644 index 0000000..67f8864 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/motif_trio-float64-r0/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "motif_trio", + "precision": "float64", + "repeat": 0, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 45, + "gpu_events": 45, + "due_edges": 88, + "accepted_edges": 87, + "attempted_requests": 1, + "accepted_requests": 1 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/motif_trio-float64-r0/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/motif_trio-float64-r0/metrics.json new file mode 100644 index 0000000..045fd64 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/motif_trio-float64-r0/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float64", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 3, + "edges": 6, + "steps": 1000, + "total_spikes": 45, + "arriving_edges": 88, + "accepted_arriving_edges": 87, + "requested": 1, + "accepted_requests": 1, + "rejected_requests": 0, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.00019101299994872534, + "diagnostic_simulation_seconds": 0.29472619999978633, + "wall_seconds": 0.2979112619996158, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 118784, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "da4b6cea0b8a33ca15e552425b55ce699d74ddf81660b02eeb30d5edcc4494cd", + "arrays.npz": "a40e803b1227d4bb6b2c24d76bdf1454cb63ace61ebb9e77ff01010dd91cab37" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/motif_trio-float64-r1/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/motif_trio-float64-r1/comparison.json new file mode 100644 index 0000000..ab68f1f --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/motif_trio-float64-r1/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "motif_trio", + "precision": "float64", + "repeat": 1, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 45, + "gpu_events": 45, + "due_edges": 88, + "accepted_edges": 87, + "attempted_requests": 1, + "accepted_requests": 1 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/motif_trio-float64-r1/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/motif_trio-float64-r1/metrics.json new file mode 100644 index 0000000..ff6a55a --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/motif_trio-float64-r1/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float64", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 3, + "edges": 6, + "steps": 1000, + "total_spikes": 45, + "arriving_edges": 88, + "accepted_arriving_edges": 87, + "requested": 1, + "accepted_requests": 1, + "rejected_requests": 0, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.00015973500012478326, + "diagnostic_simulation_seconds": 0.29434226200010016, + "wall_seconds": 0.2971508289997473, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 118784, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "da4b6cea0b8a33ca15e552425b55ce699d74ddf81660b02eeb30d5edcc4494cd", + "arrays.npz": "a40e803b1227d4bb6b2c24d76bdf1454cb63ace61ebb9e77ff01010dd91cab37" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/motif_trio-float64-r2/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/motif_trio-float64-r2/comparison.json new file mode 100644 index 0000000..c04dac6 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/motif_trio-float64-r2/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "motif_trio", + "precision": "float64", + "repeat": 2, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 45, + "gpu_events": 45, + "due_edges": 88, + "accepted_edges": 87, + "attempted_requests": 1, + "accepted_requests": 1 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/motif_trio-float64-r2/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/motif_trio-float64-r2/metrics.json new file mode 100644 index 0000000..77890c0 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/motif_trio-float64-r2/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float64", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 3, + "edges": 6, + "steps": 1000, + "total_spikes": 45, + "arriving_edges": 88, + "accepted_arriving_edges": 87, + "requested": 1, + "accepted_requests": 1, + "rejected_requests": 0, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.00016770000001997687, + "diagnostic_simulation_seconds": 0.29579545800015694, + "wall_seconds": 0.29855177800027377, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 118784, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "da4b6cea0b8a33ca15e552425b55ce699d74ddf81660b02eeb30d5edcc4494cd", + "arrays.npz": "a40e803b1227d4bb6b2c24d76bdf1454cb63ace61ebb9e77ff01010dd91cab37" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/ordered_cancellation-float32-r0/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/ordered_cancellation-float32-r0/comparison.json new file mode 100644 index 0000000..bd8f127 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/ordered_cancellation-float32-r0/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "ordered_cancellation", + "precision": "float32", + "repeat": 0, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 32, + "gpu_events": 32, + "due_edges": 32, + "accepted_edges": 32, + "attempted_requests": 32, + "accepted_requests": 32 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/ordered_cancellation-float32-r0/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/ordered_cancellation-float32-r0/metrics.json new file mode 100644 index 0000000..1d827fb --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/ordered_cancellation-float32-r0/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float32", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986813545227, + "c0": -0.00025935107260011137, + "cg": 0.004937935154885054, + "cv": 0.9950124621391296, + "threshold": -0.04500000178813934, + "reset": -0.052000001072883606, + "seed_volt": -0.04399999976158142 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 33, + "edges": 32, + "steps": 160, + "total_spikes": 32, + "arriving_edges": 32, + "accepted_arriving_edges": 32, + "requested": 32, + "accepted_requests": 32, + "rejected_requests": 0, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.00016767899978731293, + "diagnostic_simulation_seconds": 0.04158968299998378, + "wall_seconds": 0.044290660999649845, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 114688, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "1866003021cc39ad50858fe0d9f56d74e8dd16bd574eef15c0625b604cd987b2", + "arrays.npz": "97e033aaacc5703bca141b03a1db1d33522a3bf8c7ae182bafd15cafcb4c1e23" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/ordered_cancellation-float32-r1/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/ordered_cancellation-float32-r1/comparison.json new file mode 100644 index 0000000..a8e71c7 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/ordered_cancellation-float32-r1/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "ordered_cancellation", + "precision": "float32", + "repeat": 1, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 32, + "gpu_events": 32, + "due_edges": 32, + "accepted_edges": 32, + "attempted_requests": 32, + "accepted_requests": 32 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/ordered_cancellation-float32-r1/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/ordered_cancellation-float32-r1/metrics.json new file mode 100644 index 0000000..1ad1eae --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/ordered_cancellation-float32-r1/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float32", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986813545227, + "c0": -0.00025935107260011137, + "cg": 0.004937935154885054, + "cv": 0.9950124621391296, + "threshold": -0.04500000178813934, + "reset": -0.052000001072883606, + "seed_volt": -0.04399999976158142 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 33, + "edges": 32, + "steps": 160, + "total_spikes": 32, + "arriving_edges": 32, + "accepted_arriving_edges": 32, + "requested": 32, + "accepted_requests": 32, + "rejected_requests": 0, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.00015894299986030092, + "diagnostic_simulation_seconds": 0.041533930000241526, + "wall_seconds": 0.04400209799996446, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 114688, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "1866003021cc39ad50858fe0d9f56d74e8dd16bd574eef15c0625b604cd987b2", + "arrays.npz": "97e033aaacc5703bca141b03a1db1d33522a3bf8c7ae182bafd15cafcb4c1e23" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/ordered_cancellation-float32-r2/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/ordered_cancellation-float32-r2/comparison.json new file mode 100644 index 0000000..0a226f6 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/ordered_cancellation-float32-r2/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "ordered_cancellation", + "precision": "float32", + "repeat": 2, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 32, + "gpu_events": 32, + "due_edges": 32, + "accepted_edges": 32, + "attempted_requests": 32, + "accepted_requests": 32 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/ordered_cancellation-float32-r2/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/ordered_cancellation-float32-r2/metrics.json new file mode 100644 index 0000000..f7ef057 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/ordered_cancellation-float32-r2/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float32", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986813545227, + "c0": -0.00025935107260011137, + "cg": 0.004937935154885054, + "cv": 0.9950124621391296, + "threshold": -0.04500000178813934, + "reset": -0.052000001072883606, + "seed_volt": -0.04399999976158142 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 33, + "edges": 32, + "steps": 160, + "total_spikes": 32, + "arriving_edges": 32, + "accepted_arriving_edges": 32, + "requested": 32, + "accepted_requests": 32, + "rejected_requests": 0, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.00015896300010354025, + "diagnostic_simulation_seconds": 0.04088885900000605, + "wall_seconds": 0.043396560000019235, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 114688, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "1866003021cc39ad50858fe0d9f56d74e8dd16bd574eef15c0625b604cd987b2", + "arrays.npz": "97e033aaacc5703bca141b03a1db1d33522a3bf8c7ae182bafd15cafcb4c1e23" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/ordered_cancellation-float64-r0/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/ordered_cancellation-float64-r0/comparison.json new file mode 100644 index 0000000..3c5e184 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/ordered_cancellation-float64-r0/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "ordered_cancellation", + "precision": "float64", + "repeat": 0, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 32, + "gpu_events": 32, + "due_edges": 32, + "accepted_edges": 32, + "attempted_requests": 32, + "accepted_requests": 32 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/ordered_cancellation-float64-r0/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/ordered_cancellation-float64-r0/metrics.json new file mode 100644 index 0000000..f8641f0 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/ordered_cancellation-float64-r0/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float64", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 33, + "edges": 32, + "steps": 160, + "total_spikes": 32, + "arriving_edges": 32, + "accepted_arriving_edges": 32, + "requested": 32, + "accepted_requests": 32, + "rejected_requests": 0, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.00016970399974525208, + "diagnostic_simulation_seconds": 0.04241535799974372, + "wall_seconds": 0.0463549639998746, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 199168, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "1866003021cc39ad50858fe0d9f56d74e8dd16bd574eef15c0625b604cd987b2", + "arrays.npz": "97e033aaacc5703bca141b03a1db1d33522a3bf8c7ae182bafd15cafcb4c1e23" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/ordered_cancellation-float64-r1/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/ordered_cancellation-float64-r1/comparison.json new file mode 100644 index 0000000..07c2883 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/ordered_cancellation-float64-r1/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "ordered_cancellation", + "precision": "float64", + "repeat": 1, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 32, + "gpu_events": 32, + "due_edges": 32, + "accepted_edges": 32, + "attempted_requests": 32, + "accepted_requests": 32 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/ordered_cancellation-float64-r1/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/ordered_cancellation-float64-r1/metrics.json new file mode 100644 index 0000000..a6c6fa0 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/ordered_cancellation-float64-r1/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float64", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 33, + "edges": 32, + "steps": 160, + "total_spikes": 32, + "arriving_edges": 32, + "accepted_arriving_edges": 32, + "requested": 32, + "accepted_requests": 32, + "rejected_requests": 0, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.00020318499991844874, + "diagnostic_simulation_seconds": 0.04119985299985274, + "wall_seconds": 0.04416042100001505, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 199168, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "1866003021cc39ad50858fe0d9f56d74e8dd16bd574eef15c0625b604cd987b2", + "arrays.npz": "97e033aaacc5703bca141b03a1db1d33522a3bf8c7ae182bafd15cafcb4c1e23" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/ordered_cancellation-float64-r2/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/ordered_cancellation-float64-r2/comparison.json new file mode 100644 index 0000000..50f94dd --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/ordered_cancellation-float64-r2/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "ordered_cancellation", + "precision": "float64", + "repeat": 2, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 32, + "gpu_events": 32, + "due_edges": 32, + "accepted_edges": 32, + "attempted_requests": 32, + "accepted_requests": 32 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/ordered_cancellation-float64-r2/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/ordered_cancellation-float64-r2/metrics.json new file mode 100644 index 0000000..10e2676 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/ordered_cancellation-float64-r2/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float64", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 33, + "edges": 32, + "steps": 160, + "total_spikes": 32, + "arriving_edges": 32, + "accepted_arriving_edges": 32, + "requested": 32, + "accepted_requests": 32, + "rejected_requests": 0, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.00016286099980789004, + "diagnostic_simulation_seconds": 0.04077759299980244, + "wall_seconds": 0.04367801899979895, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 199168, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "1866003021cc39ad50858fe0d9f56d74e8dd16bd574eef15c0625b604cd987b2", + "arrays.npz": "97e033aaacc5703bca141b03a1db1d33522a3bf8c7ae182bafd15cafcb4c1e23" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/release_selfloop-float32-r0/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/release_selfloop-float32-r0/comparison.json new file mode 100644 index 0000000..b544066 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/release_selfloop-float32-r0/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "release_selfloop", + "precision": "float32", + "repeat": 0, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 8, + "gpu_events": 8, + "due_edges": 11, + "accepted_edges": 4, + "attempted_requests": 6, + "accepted_requests": 6 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/release_selfloop-float32-r0/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/release_selfloop-float32-r0/metrics.json new file mode 100644 index 0000000..f955258 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/release_selfloop-float32-r0/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float32", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986813545227, + "c0": -0.00025935107260011137, + "cg": 0.004937935154885054, + "cv": 0.9950124621391296, + "threshold": -0.04500000178813934, + "reset": -0.052000001072883606, + "seed_volt": -0.04399999976158142 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 4, + "edges": 5, + "steps": 160, + "total_spikes": 8, + "arriving_edges": 11, + "accepted_arriving_edges": 4, + "requested": 6, + "accepted_requests": 6, + "rejected_requests": 0, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.00016453400030513876, + "diagnostic_simulation_seconds": 0.043971211000098265, + "wall_seconds": 0.046139686000060465, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 26624, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "f63a2d3a4e99220a42944461a3223c459e3a1e7c02d22dc5e30cd129dd9452d1", + "arrays.npz": "aececf2fd48c52804d84852483e467b13d23b7b675c8b7b0d967c02aee960a5f" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/release_selfloop-float32-r1/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/release_selfloop-float32-r1/comparison.json new file mode 100644 index 0000000..c55199f --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/release_selfloop-float32-r1/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "release_selfloop", + "precision": "float32", + "repeat": 1, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 8, + "gpu_events": 8, + "due_edges": 11, + "accepted_edges": 4, + "attempted_requests": 6, + "accepted_requests": 6 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/release_selfloop-float32-r1/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/release_selfloop-float32-r1/metrics.json new file mode 100644 index 0000000..aa76af8 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/release_selfloop-float32-r1/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float32", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986813545227, + "c0": -0.00025935107260011137, + "cg": 0.004937935154885054, + "cv": 0.9950124621391296, + "threshold": -0.04500000178813934, + "reset": -0.052000001072883606, + "seed_volt": -0.04399999976158142 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 4, + "edges": 5, + "steps": 160, + "total_spikes": 8, + "arriving_edges": 11, + "accepted_arriving_edges": 4, + "requested": 6, + "accepted_requests": 6, + "rejected_requests": 0, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.00016417300003013224, + "diagnostic_simulation_seconds": 0.044752655000138475, + "wall_seconds": 0.04709388900027989, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 26624, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "f63a2d3a4e99220a42944461a3223c459e3a1e7c02d22dc5e30cd129dd9452d1", + "arrays.npz": "aececf2fd48c52804d84852483e467b13d23b7b675c8b7b0d967c02aee960a5f" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/release_selfloop-float32-r2/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/release_selfloop-float32-r2/comparison.json new file mode 100644 index 0000000..b48635e --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/release_selfloop-float32-r2/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "release_selfloop", + "precision": "float32", + "repeat": 2, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 8, + "gpu_events": 8, + "due_edges": 11, + "accepted_edges": 4, + "attempted_requests": 6, + "accepted_requests": 6 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/release_selfloop-float32-r2/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/release_selfloop-float32-r2/metrics.json new file mode 100644 index 0000000..35ce244 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/release_selfloop-float32-r2/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float32", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986813545227, + "c0": -0.00025935107260011137, + "cg": 0.004937935154885054, + "cv": 0.9950124621391296, + "threshold": -0.04500000178813934, + "reset": -0.052000001072883606, + "seed_volt": -0.04399999976158142 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 4, + "edges": 5, + "steps": 160, + "total_spikes": 8, + "arriving_edges": 11, + "accepted_arriving_edges": 4, + "requested": 6, + "accepted_requests": 6, + "rejected_requests": 0, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.00015760099995532073, + "diagnostic_simulation_seconds": 0.04388131499990777, + "wall_seconds": 0.045996542000011686, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 26624, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "f63a2d3a4e99220a42944461a3223c459e3a1e7c02d22dc5e30cd129dd9452d1", + "arrays.npz": "aececf2fd48c52804d84852483e467b13d23b7b675c8b7b0d967c02aee960a5f" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/release_selfloop-float64-r0/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/release_selfloop-float64-r0/comparison.json new file mode 100644 index 0000000..006c316 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/release_selfloop-float64-r0/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "release_selfloop", + "precision": "float64", + "repeat": 0, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 8, + "gpu_events": 8, + "due_edges": 11, + "accepted_edges": 4, + "attempted_requests": 6, + "accepted_requests": 6 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/release_selfloop-float64-r0/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/release_selfloop-float64-r0/metrics.json new file mode 100644 index 0000000..5a18658 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/release_selfloop-float64-r0/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float64", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 4, + "edges": 5, + "steps": 160, + "total_spikes": 8, + "arriving_edges": 11, + "accepted_arriving_edges": 4, + "requested": 6, + "accepted_requests": 6, + "rejected_requests": 0, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.0001632920002521132, + "diagnostic_simulation_seconds": 0.04443611999977293, + "wall_seconds": 0.046648657000332605, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 36864, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "f63a2d3a4e99220a42944461a3223c459e3a1e7c02d22dc5e30cd129dd9452d1", + "arrays.npz": "aececf2fd48c52804d84852483e467b13d23b7b675c8b7b0d967c02aee960a5f" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/release_selfloop-float64-r1/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/release_selfloop-float64-r1/comparison.json new file mode 100644 index 0000000..4f18859 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/release_selfloop-float64-r1/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "release_selfloop", + "precision": "float64", + "repeat": 1, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 8, + "gpu_events": 8, + "due_edges": 11, + "accepted_edges": 4, + "attempted_requests": 6, + "accepted_requests": 6 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/release_selfloop-float64-r1/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/release_selfloop-float64-r1/metrics.json new file mode 100644 index 0000000..1afd428 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/release_selfloop-float64-r1/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float64", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 4, + "edges": 5, + "steps": 160, + "total_spikes": 8, + "arriving_edges": 11, + "accepted_arriving_edges": 4, + "requested": 6, + "accepted_requests": 6, + "rejected_requests": 0, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.00015753100024085143, + "diagnostic_simulation_seconds": 0.04389507099995171, + "wall_seconds": 0.046053517000018473, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 36864, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "f63a2d3a4e99220a42944461a3223c459e3a1e7c02d22dc5e30cd129dd9452d1", + "arrays.npz": "aececf2fd48c52804d84852483e467b13d23b7b675c8b7b0d967c02aee960a5f" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/release_selfloop-float64-r2/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/release_selfloop-float64-r2/comparison.json new file mode 100644 index 0000000..a0afa86 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/release_selfloop-float64-r2/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "release_selfloop", + "precision": "float64", + "repeat": 2, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 8, + "gpu_events": 8, + "due_edges": 11, + "accepted_edges": 4, + "attempted_requests": 6, + "accepted_requests": 6 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/release_selfloop-float64-r2/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/release_selfloop-float64-r2/metrics.json new file mode 100644 index 0000000..0bbe1e3 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/release_selfloop-float64-r2/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float64", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 4, + "edges": 5, + "steps": 160, + "total_spikes": 8, + "arriving_edges": 11, + "accepted_arriving_edges": 4, + "requested": 6, + "accepted_requests": 6, + "rejected_requests": 0, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.00015886399978626287, + "diagnostic_simulation_seconds": 0.044506469999760156, + "wall_seconds": 0.04666292299998531, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 36864, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "f63a2d3a4e99220a42944461a3223c459e3a1e7c02d22dc5e30cd129dd9452d1", + "arrays.npz": "aececf2fd48c52804d84852483e467b13d23b7b675c8b7b0d967c02aee960a5f" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/signed_random-float32-r0/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/signed_random-float32-r0/comparison.json new file mode 100644 index 0000000..be381f4 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/signed_random-float32-r0/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "signed_random", + "precision": "float32", + "repeat": 0, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 400, + "gpu_events": 400, + "due_edges": 3072, + "accepted_edges": 2517, + "attempted_requests": 27, + "accepted_requests": 23 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/signed_random-float32-r0/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/signed_random-float32-r0/metrics.json new file mode 100644 index 0000000..28ce7a2 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/signed_random-float32-r0/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float32", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986813545227, + "c0": -0.00025935107260011137, + "cg": 0.004937935154885054, + "cv": 0.9950124621391296, + "threshold": -0.04500000178813934, + "reset": -0.052000001072883606, + "seed_volt": -0.04399999976158142 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 128, + "edges": 1024, + "steps": 400, + "total_spikes": 400, + "arriving_edges": 3072, + "accepted_arriving_edges": 2517, + "requested": 27, + "accepted_requests": 23, + "rejected_requests": 4, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.00022807200002716854, + "diagnostic_simulation_seconds": 0.3017425110001568, + "wall_seconds": 0.33679788900008134, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 996352, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "7c6af1bf5fd8f68c84fe000ec6b4977d05f6db17f4b9338d8ad49376036cbf32", + "arrays.npz": "b29ac37913a97f3e3a9a3136b0949e9cbaf3a42ddcd1c7cec1e5b356a5da1ac7" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/signed_random-float32-r1/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/signed_random-float32-r1/comparison.json new file mode 100644 index 0000000..60fb7f5 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/signed_random-float32-r1/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "signed_random", + "precision": "float32", + "repeat": 1, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 400, + "gpu_events": 400, + "due_edges": 3072, + "accepted_edges": 2517, + "attempted_requests": 27, + "accepted_requests": 23 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/signed_random-float32-r1/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/signed_random-float32-r1/metrics.json new file mode 100644 index 0000000..f628c20 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/signed_random-float32-r1/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float32", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986813545227, + "c0": -0.00025935107260011137, + "cg": 0.004937935154885054, + "cv": 0.9950124621391296, + "threshold": -0.04500000178813934, + "reset": -0.052000001072883606, + "seed_volt": -0.04399999976158142 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 128, + "edges": 1024, + "steps": 400, + "total_spikes": 400, + "arriving_edges": 3072, + "accepted_arriving_edges": 2517, + "requested": 27, + "accepted_requests": 23, + "rejected_requests": 4, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.00021461699998326367, + "diagnostic_simulation_seconds": 0.29839768400006506, + "wall_seconds": 0.33253030700007, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 996352, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "7c6af1bf5fd8f68c84fe000ec6b4977d05f6db17f4b9338d8ad49376036cbf32", + "arrays.npz": "b29ac37913a97f3e3a9a3136b0949e9cbaf3a42ddcd1c7cec1e5b356a5da1ac7" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/signed_random-float32-r2/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/signed_random-float32-r2/comparison.json new file mode 100644 index 0000000..fbecc36 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/signed_random-float32-r2/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "signed_random", + "precision": "float32", + "repeat": 2, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 400, + "gpu_events": 400, + "due_edges": 3072, + "accepted_edges": 2517, + "attempted_requests": 27, + "accepted_requests": 23 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/signed_random-float32-r2/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/signed_random-float32-r2/metrics.json new file mode 100644 index 0000000..0c13fc6 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/signed_random-float32-r2/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float32", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986813545227, + "c0": -0.00025935107260011137, + "cg": 0.004937935154885054, + "cv": 0.9950124621391296, + "threshold": -0.04500000178813934, + "reset": -0.052000001072883606, + "seed_volt": -0.04399999976158142 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 128, + "edges": 1024, + "steps": 400, + "total_spikes": 400, + "arriving_edges": 3072, + "accepted_arriving_edges": 2517, + "requested": 27, + "accepted_requests": 23, + "rejected_requests": 4, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.00018149499965147697, + "diagnostic_simulation_seconds": 0.29861683999979505, + "wall_seconds": 0.33253292399967904, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 996352, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "7c6af1bf5fd8f68c84fe000ec6b4977d05f6db17f4b9338d8ad49376036cbf32", + "arrays.npz": "b29ac37913a97f3e3a9a3136b0949e9cbaf3a42ddcd1c7cec1e5b356a5da1ac7" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/signed_random-float64-r0/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/signed_random-float64-r0/comparison.json new file mode 100644 index 0000000..630259a --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/signed_random-float64-r0/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "signed_random", + "precision": "float64", + "repeat": 0, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 400, + "gpu_events": 400, + "due_edges": 3072, + "accepted_edges": 2517, + "attempted_requests": 27, + "accepted_requests": 23 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/signed_random-float64-r0/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/signed_random-float64-r0/metrics.json new file mode 100644 index 0000000..38ef1c0 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/signed_random-float64-r0/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float64", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 128, + "edges": 1024, + "steps": 400, + "total_spikes": 400, + "arriving_edges": 3072, + "accepted_arriving_edges": 2517, + "requested": 27, + "accepted_requests": 23, + "rejected_requests": 4, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.00018526199983170955, + "diagnostic_simulation_seconds": 0.29999442700000145, + "wall_seconds": 0.34272561899979337, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 1820672, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "7c6af1bf5fd8f68c84fe000ec6b4977d05f6db17f4b9338d8ad49376036cbf32", + "arrays.npz": "b29ac37913a97f3e3a9a3136b0949e9cbaf3a42ddcd1c7cec1e5b356a5da1ac7" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/signed_random-float64-r1/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/signed_random-float64-r1/comparison.json new file mode 100644 index 0000000..8ed9898 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/signed_random-float64-r1/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "signed_random", + "precision": "float64", + "repeat": 1, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 400, + "gpu_events": 400, + "due_edges": 3072, + "accepted_edges": 2517, + "attempted_requests": 27, + "accepted_requests": 23 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/signed_random-float64-r1/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/signed_random-float64-r1/metrics.json new file mode 100644 index 0000000..a09ffe8 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/signed_random-float64-r1/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float64", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 128, + "edges": 1024, + "steps": 400, + "total_spikes": 400, + "arriving_edges": 3072, + "accepted_arriving_edges": 2517, + "requested": 27, + "accepted_requests": 23, + "rejected_requests": 4, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.00021102900018377113, + "diagnostic_simulation_seconds": 0.29909457799976735, + "wall_seconds": 0.34192463299996234, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 1820672, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "7c6af1bf5fd8f68c84fe000ec6b4977d05f6db17f4b9338d8ad49376036cbf32", + "arrays.npz": "b29ac37913a97f3e3a9a3136b0949e9cbaf3a42ddcd1c7cec1e5b356a5da1ac7" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/signed_random-float64-r2/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/signed_random-float64-r2/comparison.json new file mode 100644 index 0000000..229c15b --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/signed_random-float64-r2/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "signed_random", + "precision": "float64", + "repeat": 2, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 400, + "gpu_events": 400, + "due_edges": 3072, + "accepted_edges": 2517, + "attempted_requests": 27, + "accepted_requests": 23 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/signed_random-float64-r2/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/signed_random-float64-r2/metrics.json new file mode 100644 index 0000000..f137ffe --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/signed_random-float64-r2/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float64", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 128, + "edges": 1024, + "steps": 400, + "total_spikes": 400, + "arriving_edges": 3072, + "accepted_arriving_edges": 2517, + "requested": 27, + "accepted_requests": 23, + "rejected_requests": 4, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.00020559899985528318, + "diagnostic_simulation_seconds": 0.2996240659999785, + "wall_seconds": 0.34172961300009774, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 1820672, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "7c6af1bf5fd8f68c84fe000ec6b4977d05f6db17f4b9338d8ad49376036cbf32", + "arrays.npz": "b29ac37913a97f3e3a9a3136b0949e9cbaf3a42ddcd1c7cec1e5b356a5da1ac7" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/threshold_rounding-float32-r0/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/threshold_rounding-float32-r0/comparison.json new file mode 100644 index 0000000..4617342 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/threshold_rounding-float32-r0/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "threshold_rounding", + "precision": "float32", + "repeat": 0, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 3, + "gpu_events": 3, + "due_edges": 0, + "accepted_edges": 0, + "attempted_requests": 0, + "accepted_requests": 0 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/threshold_rounding-float32-r0/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/threshold_rounding-float32-r0/metrics.json new file mode 100644 index 0000000..87cbc39 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/threshold_rounding-float32-r0/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float32", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986813545227, + "c0": -0.00025935107260011137, + "cg": 0.004937935154885054, + "cv": 0.9950124621391296, + "threshold": -0.04500000178813934, + "reset": -0.052000001072883606, + "seed_volt": -0.04399999976158142 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 10, + "edges": 1, + "steps": 100, + "total_spikes": 3, + "arriving_edges": 0, + "accepted_arriving_edges": 0, + "requested": 0, + "accepted_requests": 0, + "rejected_requests": 0, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.00018202599994765478, + "diagnostic_simulation_seconds": 0.025687165999897843, + "wall_seconds": 0.027946798999892053, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 28160, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "8a000b9052226e0d4db020cc1dbfc839ac2aa98f01cb9361de2209dbe8706495", + "arrays.npz": "4acb2f79684a0ffd1c9666da608f8b0ad4f5c150ba5b0d6a2d08e2778a20a298" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/threshold_rounding-float32-r1/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/threshold_rounding-float32-r1/comparison.json new file mode 100644 index 0000000..2c272c2 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/threshold_rounding-float32-r1/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "threshold_rounding", + "precision": "float32", + "repeat": 1, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 3, + "gpu_events": 3, + "due_edges": 0, + "accepted_edges": 0, + "attempted_requests": 0, + "accepted_requests": 0 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/threshold_rounding-float32-r1/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/threshold_rounding-float32-r1/metrics.json new file mode 100644 index 0000000..c4051a8 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/threshold_rounding-float32-r1/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float32", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986813545227, + "c0": -0.00025935107260011137, + "cg": 0.004937935154885054, + "cv": 0.9950124621391296, + "threshold": -0.04500000178813934, + "reset": -0.052000001072883606, + "seed_volt": -0.04399999976158142 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 10, + "edges": 1, + "steps": 100, + "total_spikes": 3, + "arriving_edges": 0, + "accepted_arriving_edges": 0, + "requested": 0, + "accepted_requests": 0, + "rejected_requests": 0, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.00016257000015684753, + "diagnostic_simulation_seconds": 0.025444396999773744, + "wall_seconds": 0.027560264999920037, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 28160, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "8a000b9052226e0d4db020cc1dbfc839ac2aa98f01cb9361de2209dbe8706495", + "arrays.npz": "4acb2f79684a0ffd1c9666da608f8b0ad4f5c150ba5b0d6a2d08e2778a20a298" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/threshold_rounding-float32-r2/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/threshold_rounding-float32-r2/comparison.json new file mode 100644 index 0000000..030ad94 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/threshold_rounding-float32-r2/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "threshold_rounding", + "precision": "float32", + "repeat": 2, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 3, + "gpu_events": 3, + "due_edges": 0, + "accepted_edges": 0, + "attempted_requests": 0, + "accepted_requests": 0 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/threshold_rounding-float32-r2/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/threshold_rounding-float32-r2/metrics.json new file mode 100644 index 0000000..0e1cd5d --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/threshold_rounding-float32-r2/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float32", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986813545227, + "c0": -0.00025935107260011137, + "cg": 0.004937935154885054, + "cv": 0.9950124621391296, + "threshold": -0.04500000178813934, + "reset": -0.052000001072883606, + "seed_volt": -0.04399999976158142 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 10, + "edges": 1, + "steps": 100, + "total_spikes": 3, + "arriving_edges": 0, + "accepted_arriving_edges": 0, + "requested": 0, + "accepted_requests": 0, + "rejected_requests": 0, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.00015761199983899132, + "diagnostic_simulation_seconds": 0.02541363000000274, + "wall_seconds": 0.027592264999839244, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 28160, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "8a000b9052226e0d4db020cc1dbfc839ac2aa98f01cb9361de2209dbe8706495", + "arrays.npz": "4acb2f79684a0ffd1c9666da608f8b0ad4f5c150ba5b0d6a2d08e2778a20a298" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/threshold_rounding-float64-r0/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/threshold_rounding-float64-r0/comparison.json new file mode 100644 index 0000000..f859546 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/threshold_rounding-float64-r0/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "threshold_rounding", + "precision": "float64", + "repeat": 0, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 4, + "gpu_events": 4, + "due_edges": 0, + "accepted_edges": 0, + "attempted_requests": 0, + "accepted_requests": 0 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/threshold_rounding-float64-r0/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/threshold_rounding-float64-r0/metrics.json new file mode 100644 index 0000000..bb468c0 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/threshold_rounding-float64-r0/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float64", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 10, + "edges": 1, + "steps": 100, + "total_spikes": 4, + "arriving_edges": 0, + "accepted_arriving_edges": 0, + "requested": 0, + "accepted_requests": 0, + "rejected_requests": 0, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.00019265599985374138, + "diagnostic_simulation_seconds": 0.025635439999859955, + "wall_seconds": 0.028111202999753004, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 44032, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "8a000b9052226e0d4db020cc1dbfc839ac2aa98f01cb9361de2209dbe8706495", + "arrays.npz": "4acb2f79684a0ffd1c9666da608f8b0ad4f5c150ba5b0d6a2d08e2778a20a298" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/threshold_rounding-float64-r1/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/threshold_rounding-float64-r1/comparison.json new file mode 100644 index 0000000..395fc13 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/threshold_rounding-float64-r1/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "threshold_rounding", + "precision": "float64", + "repeat": 1, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 4, + "gpu_events": 4, + "due_edges": 0, + "accepted_edges": 0, + "attempted_requests": 0, + "accepted_requests": 0 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/threshold_rounding-float64-r1/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/threshold_rounding-float64-r1/metrics.json new file mode 100644 index 0000000..df57f1b --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/threshold_rounding-float64-r1/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float64", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 10, + "edges": 1, + "steps": 100, + "total_spikes": 4, + "arriving_edges": 0, + "accepted_arriving_edges": 0, + "requested": 0, + "accepted_requests": 0, + "rejected_requests": 0, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.00016648800010443665, + "diagnostic_simulation_seconds": 0.025467789999765955, + "wall_seconds": 0.02765216599982523, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 44032, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "8a000b9052226e0d4db020cc1dbfc839ac2aa98f01cb9361de2209dbe8706495", + "arrays.npz": "4acb2f79684a0ffd1c9666da608f8b0ad4f5c150ba5b0d6a2d08e2778a20a298" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/threshold_rounding-float64-r2/comparison.json b/registry/phase4ae-author-runtime/evidence/gpu/threshold_rounding-float64-r2/comparison.json new file mode 100644 index 0000000..80da50a --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/threshold_rounding-float64-r2/comparison.json @@ -0,0 +1,51 @@ +{ + "case": "threshold_rounding", + "precision": "float64", + "repeat": 2, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 4, + "gpu_events": 4, + "due_edges": 0, + "accepted_edges": 0, + "attempted_requests": 0, + "accepted_requests": 0 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true +} diff --git a/registry/phase4ae-author-runtime/evidence/gpu/threshold_rounding-float64-r2/metrics.json b/registry/phase4ae-author-runtime/evidence/gpu/threshold_rounding-float64-r2/metrics.json new file mode 100644 index 0000000..48ba583 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/gpu/threshold_rounding-float64-r2/metrics.json @@ -0,0 +1,68 @@ +{ + "precision": "float64", + "state_units": "SI volts; refractory is steps", + "coefficients_double_input": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "coefficients_effective_dtype": { + "gd": 0.9801986733067553, + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "threshold": -0.045, + "reset": -0.052000000000000005, + "seed_volt": -0.044 + }, + "weights_origin": "caller supplied oracle SI weight array", + "nodes": 10, + "edges": 1, + "steps": 100, + "total_spikes": 4, + "arriving_edges": 0, + "accepted_arriving_edges": 0, + "requested": 0, + "accepted_requests": 0, + "rejected_requests": 0, + "all_finite": true, + "delay_steps": 18, + "refractory_steps": 22, + "build_or_cache_seconds": 0.000156890000198473, + "diagnostic_simulation_seconds": 0.02521229800004221, + "wall_seconds": 0.02759957799980839, + "gpu": "NVIDIA GeForce RTX 4090", + "device": "cuda:0", + "peak_allocated_vram_bytes": 44032, + "peak_reserved_vram_bytes": 23068672, + "build": { + "sources": { + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e" + }, + "torch": "2.14.0+cu130", + "torch_cuda": "13.0", + "arch_list": "8.9", + "cuda_flags": [ + "-O2", + "--fmad=false", + "--ftz=false", + "--prec-div=true", + "--prec-sqrt=true" + ] + }, + "input_sha256": { + "spec.json": "8a000b9052226e0d4db020cc1dbfc839ac2aa98f01cb9361de2209dbe8706495", + "arrays.npz": "4acb2f79684a0ffd1c9666da608f8b0ad4f5c150ba5b0d6a2d08e2778a20a298" + }, + "arrival_order_scope": "GPU expanded edges, stable target grouping; compare relative order per tick and target", + "performance_runtime_claim": false, + "oracle_validation_claim": false, + "whole_brain_run": false, + "learning": false, + "cpu_transfer_each_step_for_diagnostics": true +} diff --git a/registry/phase4ae-author-runtime/evidence/manifest.json b/registry/phase4ae-author-runtime/evidence/manifest.json new file mode 100644 index 0000000..be4b8bc --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/manifest.json @@ -0,0 +1,4585 @@ +{ + "root": "/data/digital-drosophila/experiments/phase4ae-author-runtime", + "files": [ + { + "path": "REPORT.md", + "bytes": 2195, + "sha256": "b868f1af329c95f5c264e42b05f53b13b6a86ef4a8a4ffb728cb8eee1e6f4223" + }, + { + "path": "audit/final-status.json", + "bytes": 351, + "sha256": "ea2305390f21d0aa35de76efae59819cb5548391b6cab57b9d72a3472d017013" + }, + { + "path": "cases/fanin_bursts/arrays.npz", + "bytes": 4730, + "sha256": "f3a900e9032754619549005131283cbaf87fdaa9093887a90a295589dac590fb" + }, + { + "path": "cases/fanin_bursts/spec.json", + "bytes": 561, + "sha256": "90850d6968a7832e415d0966b57e216a65f5ba8f63e488e497148b6525806d79" + }, + { + "path": "cases/highest_indegree/anatomical-edges.csv", + "bytes": 7936, + "sha256": "aec331ee87f0da905d55b4dbb61a7e72fae734246ae6fbf462d7f6348dcdae1b" + }, + { + "path": "cases/highest_indegree/arrays.npz", + "bytes": 4601, + "sha256": "02ab938969b4369b1e08bc4a82e8c5fe68683f7318baf5eb052098d63fab0302" + }, + { + "path": "cases/highest_indegree/identities.csv", + "bytes": 3895, + "sha256": "5a837548ac8d45d495765d012f4495f4f68b2c9b0eda3eabd759869fc793fe77" + }, + { + "path": "cases/highest_indegree/spec.json", + "bytes": 956, + "sha256": "eab2c18f120fd3e9f067f489cee0a4c07477607facf3094083d3e3fa60bfd1ef" + }, + { + "path": "cases/mixed_high_indegree/anatomical-edges.csv", + "bytes": 6625, + "sha256": "4bb7f2b5344916035a87bffec9b26570ef21842010fcf78ff1a71230496c4757" + }, + { + "path": "cases/mixed_high_indegree/arrays.npz", + "bytes": 4445, + "sha256": "63fb734a967aee5f77709788ad9bd7d8783c2209c34f0e1d9aa6a0a8b7a6ecf5" + }, + { + "path": "cases/mixed_high_indegree/identities.csv", + "bytes": 3634, + "sha256": "ad8f92fab6e2c38ed2b369b7f03c5b75d3c26433ad43bde6e2fc76f8058dd009" + }, + { + "path": "cases/mixed_high_indegree/spec.json", + "bytes": 959, + "sha256": "11f07dd0a3e62b6ee66373022539a68daad766dce26fa759654f0201599f6703" + }, + { + "path": "cases/motif_feedforward/arrays.npz", + "bytes": 1903, + "sha256": "cdba32792924258112a2fd6ffaca5e329c71404840a290a9187e5d3e2b6550d4" + }, + { + "path": "cases/motif_feedforward/spec.json", + "bytes": 540, + "sha256": "1bb9ef28864e46336581d23fc15eaf80a329ee4d1a439abd0fc18c52f87a2b77" + }, + { + "path": "cases/motif_five/arrays.npz", + "bytes": 1970, + "sha256": "712a18275609cc71875e4ea04ca97222de917de9b1d6760f4052e2a3f0dd465e" + }, + { + "path": "cases/motif_five/spec.json", + "bytes": 533, + "sha256": "f78ba9423ed1dfb686cd79a0a003cda0bf9e7603d37e8d318118e08766ece7b3" + }, + { + "path": "cases/motif_no_input/arrays.npz", + "bytes": 1969, + "sha256": "3e3f7c2bd477e097761d3e34745f88fb215636c74d89a9e77a2b9a5f2fc738c3" + }, + { + "path": "cases/motif_no_input/spec.json", + "bytes": 537, + "sha256": "02adfcd0717aa2d98eb571107136eae7186166ce1c7d7eb87df23bedb452fbd9" + }, + { + "path": "cases/motif_pair/arrays.npz", + "bytes": 1822, + "sha256": "7c01e762480777b22474264f28cc413e554314602fad320a33b53dd028a1fb5a" + }, + { + "path": "cases/motif_pair/spec.json", + "bytes": 533, + "sha256": "faee4cdcdc93293b4b5e15d852a6a97b76767ce6aa7c534b12c6f204264daa7a" + }, + { + "path": "cases/motif_trio/arrays.npz", + "bytes": 1876, + "sha256": "a40e803b1227d4bb6b2c24d76bdf1454cb63ace61ebb9e77ff01010dd91cab37" + }, + { + "path": "cases/motif_trio/spec.json", + "bytes": 533, + "sha256": "da4b6cea0b8a33ca15e552425b55ce699d74ddf81660b02eeb30d5edcc4494cd" + }, + { + "path": "cases/ordered_cancellation/arrays.npz", + "bytes": 2162, + "sha256": "97e033aaacc5703bca141b03a1db1d33522a3bf8c7ae182bafd15cafcb4c1e23" + }, + { + "path": "cases/ordered_cancellation/spec.json", + "bytes": 569, + "sha256": "1866003021cc39ad50858fe0d9f56d74e8dd16bd574eef15c0625b604cd987b2" + }, + { + "path": "cases/release_selfloop/arrays.npz", + "bytes": 1854, + "sha256": "aececf2fd48c52804d84852483e467b13d23b7b675c8b7b0d967c02aee960a5f" + }, + { + "path": "cases/release_selfloop/spec.json", + "bytes": 538, + "sha256": "f63a2d3a4e99220a42944461a3223c459e3a1e7c02d22dc5e30cd129dd9452d1" + }, + { + "path": "cases/signed_random/arrays.npz", + "bytes": 20577, + "sha256": "b29ac37913a97f3e3a9a3136b0949e9cbaf3a42ddcd1c7cec1e5b356a5da1ac7" + }, + { + "path": "cases/signed_random/spec.json", + "bytes": 571, + "sha256": "7c6af1bf5fd8f68c84fe000ec6b4977d05f6db17f4b9338d8ad49376036cbf32" + }, + { + "path": "cases/threshold_rounding/arrays.npz", + "bytes": 1849, + "sha256": "4acb2f79684a0ffd1c9666da608f8b0ad4f5c150ba5b0d6a2d08e2778a20a298" + }, + { + "path": "cases/threshold_rounding/spec.json", + "bytes": 577, + "sha256": "8a000b9052226e0d4db020cc1dbfc839ac2aa98f01cb9361de2209dbe8706495" + }, + { + "path": "extension-build/author_cuda_8b92086ce274b694/.ninja_deps", + "bytes": 726096, + "sha256": "2263468c2217a9aaff057fa46c83358e78bd398f0f93efd5aa1365501afec520" + }, + { + "path": "extension-build/author_cuda_8b92086ce274b694/.ninja_log", + "bytes": 217, + "sha256": "1a743a54d2b43b0e1537ba1e7a3274cea3a8e95c34b01d81269b1326d86dc982" + }, + { + "path": "extension-build/author_cuda_8b92086ce274b694/author_cuda_8b92086ce274b694.so", + "bytes": 371672, + "sha256": "9fc6af40c39adb319fa1a29a22d6672fe0ca620fdaa663e01a074f820c712ac5" + }, + { + "path": "extension-build/author_cuda_8b92086ce274b694/author_ext.cuda.o", + "bytes": 235784, + "sha256": "88ad1791aea2e67fcdf2e66902e7ccc752a1fc727ac1565327f34193c5d2c7f6" + }, + { + "path": "extension-build/author_cuda_8b92086ce274b694/author_ext.o", + "bytes": 381024, + "sha256": "f9092f2ef8da90ee89cfb89075d1e0891456f4bcbf6d9d405c65696a92f8cc49" + }, + { + "path": "extension-build/author_cuda_8b92086ce274b694/build.ninja", + "bytes": 2104, + "sha256": "75c123c6847475e58245ed925446ae65ffcb58f336d6b4cb928e7f47e4de8a50" + }, + { + "path": "extension-build/author_cuda_8b92086ce274b694/lock", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "gpu/fanin_bursts-float32-r0/arrival-order.npz", + "bytes": 2311, + "sha256": "aeb40d155d36e3ade82c38f8ab304b003e78f16c7e6a79a9d8cefd2da3d4aa09" + }, + { + "path": "gpu/fanin_bursts-float32-r0/comparison.json", + "bytes": 1216, + "sha256": "12310d970a3122d98925e90a6ee852f93b89ac7c65740bce766fbdab104ae95e" + }, + { + "path": "gpu/fanin_bursts-float32-r0/metrics.json", + "bytes": 2153, + "sha256": "947e74fc7788cd190e804764757beb5f5ac56be1b2b55a4d415c171e33a71e36" + }, + { + "path": "gpu/fanin_bursts-float32-r0/state.npz", + "bytes": 15524, + "sha256": "0a4b40f8778f26fcd5afe342e7ebe8c1cd3fe1fccb72fcfebbc9b0000d48e9c3" + }, + { + "path": "gpu/fanin_bursts-float32-r1/arrival-order.npz", + "bytes": 2311, + "sha256": "aeb40d155d36e3ade82c38f8ab304b003e78f16c7e6a79a9d8cefd2da3d4aa09" + }, + { + "path": "gpu/fanin_bursts-float32-r1/comparison.json", + "bytes": 1216, + "sha256": "e5b955928b916af14e464a65207e1a3ce06e74b5b7a92fd7969d0a3f9a7fd18a" + }, + { + "path": "gpu/fanin_bursts-float32-r1/metrics.json", + "bytes": 2155, + "sha256": "452d8917e29a03cbd1d217c397dd9e8e085dc33c2ee27517cde6dd7d0c6694ed" + }, + { + "path": "gpu/fanin_bursts-float32-r1/state.npz", + "bytes": 15524, + "sha256": "0a4b40f8778f26fcd5afe342e7ebe8c1cd3fe1fccb72fcfebbc9b0000d48e9c3" + }, + { + "path": "gpu/fanin_bursts-float32-r2/arrival-order.npz", + "bytes": 2311, + "sha256": "aeb40d155d36e3ade82c38f8ab304b003e78f16c7e6a79a9d8cefd2da3d4aa09" + }, + { + "path": "gpu/fanin_bursts-float32-r2/comparison.json", + "bytes": 1216, + "sha256": "045405c14e0929e4875ad8be6cd617db29f2367f53b1db03cb80604c081b0857" + }, + { + "path": "gpu/fanin_bursts-float32-r2/metrics.json", + "bytes": 2153, + "sha256": "329b1be64ff13f3ef0fe4849ec9ef6bc5d4cf3cfe8bc731d82c8d12e07403f3f" + }, + { + "path": "gpu/fanin_bursts-float32-r2/state.npz", + "bytes": 15524, + "sha256": "0a4b40f8778f26fcd5afe342e7ebe8c1cd3fe1fccb72fcfebbc9b0000d48e9c3" + }, + { + "path": "gpu/fanin_bursts-float64-r0/arrival-order.npz", + "bytes": 2311, + "sha256": "aeb40d155d36e3ade82c38f8ab304b003e78f16c7e6a79a9d8cefd2da3d4aa09" + }, + { + "path": "gpu/fanin_bursts-float64-r0/comparison.json", + "bytes": 1216, + "sha256": "eeca2cf7cee7c8a2bb672cc2f9cb8ffe2fee5d7cebef5a7ac2168ce0d0c7bf55" + }, + { + "path": "gpu/fanin_bursts-float64-r0/metrics.json", + "bytes": 2121, + "sha256": "0427ff2e3ee46fd3a40a71bfb36af193fc4c30a17d209e288be4f4e21b8d13ef" + }, + { + "path": "gpu/fanin_bursts-float64-r0/state.npz", + "bytes": 22677, + "sha256": "c0534c8697387f44de4f465109bc8b1daf7b42ddb050549836d79f509209c312" + }, + { + "path": "gpu/fanin_bursts-float64-r1/arrival-order.npz", + "bytes": 2311, + "sha256": "aeb40d155d36e3ade82c38f8ab304b003e78f16c7e6a79a9d8cefd2da3d4aa09" + }, + { + "path": "gpu/fanin_bursts-float64-r1/comparison.json", + "bytes": 1216, + "sha256": "21795525db57f8890dda1d50b7c9dd8988f951127488c2a6da544501c7ed43c4" + }, + { + "path": "gpu/fanin_bursts-float64-r1/metrics.json", + "bytes": 2127, + "sha256": "45a9bcbe167e2ef3436060ffc2ea08b11670adc744a3e60db75ac0264de6db36" + }, + { + "path": "gpu/fanin_bursts-float64-r1/state.npz", + "bytes": 22677, + "sha256": "c0534c8697387f44de4f465109bc8b1daf7b42ddb050549836d79f509209c312" + }, + { + "path": "gpu/fanin_bursts-float64-r2/arrival-order.npz", + "bytes": 2311, + "sha256": "aeb40d155d36e3ade82c38f8ab304b003e78f16c7e6a79a9d8cefd2da3d4aa09" + }, + { + "path": "gpu/fanin_bursts-float64-r2/comparison.json", + "bytes": 1216, + "sha256": "486c36e6e182d820201fd18a1b38b7eedbbd8aa4295a92b3145265dad8f0a170" + }, + { + "path": "gpu/fanin_bursts-float64-r2/metrics.json", + "bytes": 2126, + "sha256": "b28d29cc60d80ddbd76c0bd309141e2eb44fcf00a0dd877ca92a4968530e8254" + }, + { + "path": "gpu/fanin_bursts-float64-r2/state.npz", + "bytes": 22677, + "sha256": "c0534c8697387f44de4f465109bc8b1daf7b42ddb050549836d79f509209c312" + }, + { + "path": "gpu/highest_indegree-float32-r0/arrival-order.npz", + "bytes": 2276, + "sha256": "c46a8697c4e5bdbb90e244c363976a1d41f79e8a04ce3e26b58be5de4d57b382" + }, + { + "path": "gpu/highest_indegree-float32-r0/comparison.json", + "bytes": 1212, + "sha256": "1f2def177229390bcde1b9a2c94819da9d68d4336f8dfc73b1be545e44ba9278" + }, + { + "path": "gpu/highest_indegree-float32-r0/metrics.json", + "bytes": 2144, + "sha256": "afff8582869eb807dc43a62d1ec84fd9c6300822afaa839f138cefface1b51ae" + }, + { + "path": "gpu/highest_indegree-float32-r0/state.npz", + "bytes": 228067, + "sha256": "0fb384c6fa07e434418650e7b6c0b00d64a899ecb50a5f433f6fa5a7b86c4db0" + }, + { + "path": "gpu/highest_indegree-float32-r1/arrival-order.npz", + "bytes": 2276, + "sha256": "c46a8697c4e5bdbb90e244c363976a1d41f79e8a04ce3e26b58be5de4d57b382" + }, + { + "path": "gpu/highest_indegree-float32-r1/comparison.json", + "bytes": 1212, + "sha256": "246c89aa41573e512506057ff3f3a827cc0747453515e084e4aff4cd9013d221" + }, + { + "path": "gpu/highest_indegree-float32-r1/metrics.json", + "bytes": 2146, + "sha256": "d5e3527c34e46cc7f46327fdfde3e894e8f10c07b69c9970a327b19a4d096c31" + }, + { + "path": "gpu/highest_indegree-float32-r1/state.npz", + "bytes": 228067, + "sha256": "0fb384c6fa07e434418650e7b6c0b00d64a899ecb50a5f433f6fa5a7b86c4db0" + }, + { + "path": "gpu/highest_indegree-float32-r2/arrival-order.npz", + "bytes": 2276, + "sha256": "c46a8697c4e5bdbb90e244c363976a1d41f79e8a04ce3e26b58be5de4d57b382" + }, + { + "path": "gpu/highest_indegree-float32-r2/comparison.json", + "bytes": 1212, + "sha256": "8ab5759412dda7e8cdba5692ed62e667873e647155ac86ba31e5f539388fd43c" + }, + { + "path": "gpu/highest_indegree-float32-r2/metrics.json", + "bytes": 2144, + "sha256": "c106130ad03b70bca3f31d0074d19ed2f50fe760b57359fec00f682050ff759a" + }, + { + "path": "gpu/highest_indegree-float32-r2/state.npz", + "bytes": 228067, + "sha256": "0fb384c6fa07e434418650e7b6c0b00d64a899ecb50a5f433f6fa5a7b86c4db0" + }, + { + "path": "gpu/highest_indegree-float64-r0/arrival-order.npz", + "bytes": 2276, + "sha256": "c46a8697c4e5bdbb90e244c363976a1d41f79e8a04ce3e26b58be5de4d57b382" + }, + { + "path": "gpu/highest_indegree-float64-r0/comparison.json", + "bytes": 1212, + "sha256": "9bf9fb86fef1ebc866de0e8152f34067cb68e3434d3b232bf02c5207f57ff885" + }, + { + "path": "gpu/highest_indegree-float64-r0/metrics.json", + "bytes": 2117, + "sha256": "a8b920d40fa3366874b08048c6b29dbfa1d1526e462cd3a444c40809e7ba37f2" + }, + { + "path": "gpu/highest_indegree-float64-r0/state.npz", + "bytes": 356077, + "sha256": "49a826f485c93abca8651447b15bf5afe65f319055b3f50a79f198a6dd981693" + }, + { + "path": "gpu/highest_indegree-float64-r1/arrival-order.npz", + "bytes": 2276, + "sha256": "c46a8697c4e5bdbb90e244c363976a1d41f79e8a04ce3e26b58be5de4d57b382" + }, + { + "path": "gpu/highest_indegree-float64-r1/comparison.json", + "bytes": 1212, + "sha256": "462d36b713564bd81ffe28a3707ce208ab1c413437e1fffc869c5c1054728e2f" + }, + { + "path": "gpu/highest_indegree-float64-r1/metrics.json", + "bytes": 2117, + "sha256": "e655f6d65f52678ecd4e5acce372a34c5ea8a52a222cb36496e85dcdb54f5e73" + }, + { + "path": "gpu/highest_indegree-float64-r1/state.npz", + "bytes": 356077, + "sha256": "49a826f485c93abca8651447b15bf5afe65f319055b3f50a79f198a6dd981693" + }, + { + "path": "gpu/highest_indegree-float64-r2/arrival-order.npz", + "bytes": 2276, + "sha256": "c46a8697c4e5bdbb90e244c363976a1d41f79e8a04ce3e26b58be5de4d57b382" + }, + { + "path": "gpu/highest_indegree-float64-r2/comparison.json", + "bytes": 1212, + "sha256": "e3fec806eb2608554720b0bd9667f1aee75c0ad269a613e36104ea4c4d95f82e" + }, + { + "path": "gpu/highest_indegree-float64-r2/metrics.json", + "bytes": 2117, + "sha256": "e1474af65ed69ce0707ca5c4f6fadf97e3606da14dad54664995646d57791012" + }, + { + "path": "gpu/highest_indegree-float64-r2/state.npz", + "bytes": 356077, + "sha256": "49a826f485c93abca8651447b15bf5afe65f319055b3f50a79f198a6dd981693" + }, + { + "path": "gpu/mixed_high_indegree-float32-r0/arrival-order.npz", + "bytes": 1981, + "sha256": "7ec4a257b6abfecb829c61463bdac87a7a509cdbce469c65858af29aba5c1946" + }, + { + "path": "gpu/mixed_high_indegree-float32-r0/comparison.json", + "bytes": 1215, + "sha256": "044aac9e7e4d3090c12050da10a3d9d229bf4b0ae1df0cd0535fe942af809d39" + }, + { + "path": "gpu/mixed_high_indegree-float32-r0/metrics.json", + "bytes": 2145, + "sha256": "f813da02775ee2a2afb9a746f296a73f37c9b3f075dafcca2bd3c0419eca633d" + }, + { + "path": "gpu/mixed_high_indegree-float32-r0/state.npz", + "bytes": 195621, + "sha256": "01236a09e7f4733d433735dba293ebf7257129abaa03e6dc106608840de92cb8" + }, + { + "path": "gpu/mixed_high_indegree-float32-r1/arrival-order.npz", + "bytes": 1981, + "sha256": "7ec4a257b6abfecb829c61463bdac87a7a509cdbce469c65858af29aba5c1946" + }, + { + "path": "gpu/mixed_high_indegree-float32-r1/comparison.json", + "bytes": 1215, + "sha256": "55f6b0bdb442a9acd960e192afac270ea94c2ca3e98025a6e3079062f7100f5a" + }, + { + "path": "gpu/mixed_high_indegree-float32-r1/metrics.json", + "bytes": 2145, + "sha256": "42a0a24721e7b82b2f4917772e31ef7b44b9e18c2425acf5cac70dbc17e94a76" + }, + { + "path": "gpu/mixed_high_indegree-float32-r1/state.npz", + "bytes": 195621, + "sha256": "01236a09e7f4733d433735dba293ebf7257129abaa03e6dc106608840de92cb8" + }, + { + "path": "gpu/mixed_high_indegree-float32-r2/arrival-order.npz", + "bytes": 1981, + "sha256": "7ec4a257b6abfecb829c61463bdac87a7a509cdbce469c65858af29aba5c1946" + }, + { + "path": "gpu/mixed_high_indegree-float32-r2/comparison.json", + "bytes": 1215, + "sha256": "62059fef31d576e96845b35ee83b6c28fab57377b63818fda89dd8ee151c5ebc" + }, + { + "path": "gpu/mixed_high_indegree-float32-r2/metrics.json", + "bytes": 2146, + "sha256": "132437c4c769a5b576b10c846355029af268c337ebfe19e1ae2b2a5ed37cc0c2" + }, + { + "path": "gpu/mixed_high_indegree-float32-r2/state.npz", + "bytes": 195621, + "sha256": "01236a09e7f4733d433735dba293ebf7257129abaa03e6dc106608840de92cb8" + }, + { + "path": "gpu/mixed_high_indegree-float64-r0/arrival-order.npz", + "bytes": 1981, + "sha256": "7ec4a257b6abfecb829c61463bdac87a7a509cdbce469c65858af29aba5c1946" + }, + { + "path": "gpu/mixed_high_indegree-float64-r0/comparison.json", + "bytes": 1215, + "sha256": "7a5187b10bdfa9e2af4db7d6597d8aa02faadf4901a233ced2ed0be2450f124d" + }, + { + "path": "gpu/mixed_high_indegree-float64-r0/metrics.json", + "bytes": 2118, + "sha256": "bcc2f3f5918c514523b959f691cde82c3c9f3000c45d17191cc1d77c85edc005" + }, + { + "path": "gpu/mixed_high_indegree-float64-r0/state.npz", + "bytes": 321646, + "sha256": "7e3c2772c827da3aa7a57a0b92a20574def7db5f091e0a3ee585dbdd16a91b89" + }, + { + "path": "gpu/mixed_high_indegree-float64-r1/arrival-order.npz", + "bytes": 1981, + "sha256": "7ec4a257b6abfecb829c61463bdac87a7a509cdbce469c65858af29aba5c1946" + }, + { + "path": "gpu/mixed_high_indegree-float64-r1/comparison.json", + "bytes": 1215, + "sha256": "73cc0c59195c1a2c3d4bc16da431aff42a885286679ca0cd809bc182c8e8d792" + }, + { + "path": "gpu/mixed_high_indegree-float64-r1/metrics.json", + "bytes": 2118, + "sha256": "f98a32f498450333889a7e486c4d5277b2746f2d206f61ec0b146c6124a0cdd9" + }, + { + "path": "gpu/mixed_high_indegree-float64-r1/state.npz", + "bytes": 321646, + "sha256": "7e3c2772c827da3aa7a57a0b92a20574def7db5f091e0a3ee585dbdd16a91b89" + }, + { + "path": "gpu/mixed_high_indegree-float64-r2/arrival-order.npz", + "bytes": 1981, + "sha256": "7ec4a257b6abfecb829c61463bdac87a7a509cdbce469c65858af29aba5c1946" + }, + { + "path": "gpu/mixed_high_indegree-float64-r2/comparison.json", + "bytes": 1215, + "sha256": "d5d6ad513373ccc7d48a795f51c7705427c1a92124f8cd75e173575aed40d5dc" + }, + { + "path": "gpu/mixed_high_indegree-float64-r2/metrics.json", + "bytes": 2117, + "sha256": "7f893e0fe56dcaa98d3748056c103a7eee7d10139ef8f970dc0f108d356bfeb2" + }, + { + "path": "gpu/mixed_high_indegree-float64-r2/state.npz", + "bytes": 321646, + "sha256": "7e3c2772c827da3aa7a57a0b92a20574def7db5f091e0a3ee585dbdd16a91b89" + }, + { + "path": "gpu/motif_feedforward-float32-r0/arrival-order.npz", + "bytes": 1004, + "sha256": "62be726e31f00cc312563cc76b1f2c66e377e25756f03c117e7f9e4f8c961fc9" + }, + { + "path": "gpu/motif_feedforward-float32-r0/comparison.json", + "bytes": 1203, + "sha256": "f722721c2ed148c0afa53ef49f5914a828b01b877972eb6b56134f7839fb1731" + }, + { + "path": "gpu/motif_feedforward-float32-r0/metrics.json", + "bytes": 2133, + "sha256": "31f5a7526d2d67c8d984c1527a274663c2c365da746132b210bccbf65ea94623" + }, + { + "path": "gpu/motif_feedforward-float32-r0/state.npz", + "bytes": 11052, + "sha256": "024acc8994c5f655712728217e20655853ef7c1b20bf3d4472a7cba7d4cd1188" + }, + { + "path": "gpu/motif_feedforward-float32-r1/arrival-order.npz", + "bytes": 1004, + "sha256": "62be726e31f00cc312563cc76b1f2c66e377e25756f03c117e7f9e4f8c961fc9" + }, + { + "path": "gpu/motif_feedforward-float32-r1/comparison.json", + "bytes": 1203, + "sha256": "450453289e7fb360414c8938478e1780bc935d8d408cc5c4b8bb280b35ec343f" + }, + { + "path": "gpu/motif_feedforward-float32-r1/metrics.json", + "bytes": 2132, + "sha256": "189d25ed00771d2c8d38e72ad63563324f5840c244fda0e7331b380a2fb072bf" + }, + { + "path": "gpu/motif_feedforward-float32-r1/state.npz", + "bytes": 11052, + "sha256": "024acc8994c5f655712728217e20655853ef7c1b20bf3d4472a7cba7d4cd1188" + }, + { + "path": "gpu/motif_feedforward-float32-r2/arrival-order.npz", + "bytes": 1004, + "sha256": "62be726e31f00cc312563cc76b1f2c66e377e25756f03c117e7f9e4f8c961fc9" + }, + { + "path": "gpu/motif_feedforward-float32-r2/comparison.json", + "bytes": 1203, + "sha256": "65471b4a94fde3168e213673053c36031c466c2ff072ffb2152486319fa01acd" + }, + { + "path": "gpu/motif_feedforward-float32-r2/metrics.json", + "bytes": 2131, + "sha256": "bd413aff41252ec4ee5ac7d4da2bc6afbd3a6841e42bccdbe7fc94db0ddaa12a" + }, + { + "path": "gpu/motif_feedforward-float32-r2/state.npz", + "bytes": 11052, + "sha256": "024acc8994c5f655712728217e20655853ef7c1b20bf3d4472a7cba7d4cd1188" + }, + { + "path": "gpu/motif_feedforward-float64-r0/arrival-order.npz", + "bytes": 1004, + "sha256": "62be726e31f00cc312563cc76b1f2c66e377e25756f03c117e7f9e4f8c961fc9" + }, + { + "path": "gpu/motif_feedforward-float64-r0/comparison.json", + "bytes": 1203, + "sha256": "81cab1ca080eeabb69b85affba0a9f14b0106d6eeee58ab7db612d989000a1f0" + }, + { + "path": "gpu/motif_feedforward-float64-r0/metrics.json", + "bytes": 2103, + "sha256": "3e8cde3092183a88c0b060af8db47b0e0f50231e7e36f7aa10c78e5317b7fd36" + }, + { + "path": "gpu/motif_feedforward-float64-r0/state.npz", + "bytes": 18686, + "sha256": "7c519ed44d9525561097841839a38009afb82fb3f697e29b9d51a53d37978913" + }, + { + "path": "gpu/motif_feedforward-float64-r1/arrival-order.npz", + "bytes": 1004, + "sha256": "62be726e31f00cc312563cc76b1f2c66e377e25756f03c117e7f9e4f8c961fc9" + }, + { + "path": "gpu/motif_feedforward-float64-r1/comparison.json", + "bytes": 1203, + "sha256": "3c0e6b05be5d9bb32fd4f38a2a32524dc8ce3193fe24a9b55fbffc63d37c1573" + }, + { + "path": "gpu/motif_feedforward-float64-r1/metrics.json", + "bytes": 2104, + "sha256": "ff0e89efa83ecc0f81ad09841d2d44de327ce6ede08615b563a7d81d9dc35795" + }, + { + "path": "gpu/motif_feedforward-float64-r1/state.npz", + "bytes": 18686, + "sha256": "7c519ed44d9525561097841839a38009afb82fb3f697e29b9d51a53d37978913" + }, + { + "path": "gpu/motif_feedforward-float64-r2/arrival-order.npz", + "bytes": 1004, + "sha256": "62be726e31f00cc312563cc76b1f2c66e377e25756f03c117e7f9e4f8c961fc9" + }, + { + "path": "gpu/motif_feedforward-float64-r2/comparison.json", + "bytes": 1203, + "sha256": "171023bfd3fe1fb454affa1f84064422b2b318aa84a28126ce6c2cfc8f99edbb" + }, + { + "path": "gpu/motif_feedforward-float64-r2/metrics.json", + "bytes": 2105, + "sha256": "a04dbd55eba875b163d0e63f8600bf7d12e54c4fd71df93c620982179da70e4c" + }, + { + "path": "gpu/motif_feedforward-float64-r2/state.npz", + "bytes": 18686, + "sha256": "7c519ed44d9525561097841839a38009afb82fb3f697e29b9d51a53d37978913" + }, + { + "path": "gpu/motif_five-float32-r0/arrival-order.npz", + "bytes": 1342, + "sha256": "8ece97e02478970cf56ad1192c6c31f1010893ca70732b4c56a12e4c46defb1f" + }, + { + "path": "gpu/motif_five-float32-r0/comparison.json", + "bytes": 1202, + "sha256": "8e7bf7c087c98d80068f16f8b18cba08e82be69c7c0fe7bd2175fbb1a3e1e127" + }, + { + "path": "gpu/motif_five-float32-r0/metrics.json", + "bytes": 2139, + "sha256": "1cde729f2b204cb2a0dd2aee5144d68df18d35b2964126cfedef6f276d7e735b" + }, + { + "path": "gpu/motif_five-float32-r0/state.npz", + "bytes": 20846, + "sha256": "97f03620e6639710769fa30b0b40553be6ebeee424de12e43604943cff723a06" + }, + { + "path": "gpu/motif_five-float32-r1/arrival-order.npz", + "bytes": 1342, + "sha256": "8ece97e02478970cf56ad1192c6c31f1010893ca70732b4c56a12e4c46defb1f" + }, + { + "path": "gpu/motif_five-float32-r1/comparison.json", + "bytes": 1202, + "sha256": "2ce1a054f63f1b70e9b517d4804bbce40846a2758a6f225edf8f2d92323097ed" + }, + { + "path": "gpu/motif_five-float32-r1/metrics.json", + "bytes": 2139, + "sha256": "c77ef2df1ebf63edc5bf05f2ff5dd0a25973b68a445e515cca47f67dc586e0ab" + }, + { + "path": "gpu/motif_five-float32-r1/state.npz", + "bytes": 20846, + "sha256": "97f03620e6639710769fa30b0b40553be6ebeee424de12e43604943cff723a06" + }, + { + "path": "gpu/motif_five-float32-r2/arrival-order.npz", + "bytes": 1342, + "sha256": "8ece97e02478970cf56ad1192c6c31f1010893ca70732b4c56a12e4c46defb1f" + }, + { + "path": "gpu/motif_five-float32-r2/comparison.json", + "bytes": 1202, + "sha256": "a9e790b00eef82de3d39dbc219bd5b893cc751e199dc4d6792488b4098cca0ca" + }, + { + "path": "gpu/motif_five-float32-r2/metrics.json", + "bytes": 2138, + "sha256": "be2a565f4b3100f4250815a71274723e491495abc561a6c4e477ac1e49946ed9" + }, + { + "path": "gpu/motif_five-float32-r2/state.npz", + "bytes": 20846, + "sha256": "97f03620e6639710769fa30b0b40553be6ebeee424de12e43604943cff723a06" + }, + { + "path": "gpu/motif_five-float64-r0/arrival-order.npz", + "bytes": 1342, + "sha256": "8ece97e02478970cf56ad1192c6c31f1010893ca70732b4c56a12e4c46defb1f" + }, + { + "path": "gpu/motif_five-float64-r0/comparison.json", + "bytes": 1202, + "sha256": "676f5af243f754f5e747f8d66e6308fe2246c119b250432897a6276351a576e8" + }, + { + "path": "gpu/motif_five-float64-r0/metrics.json", + "bytes": 2110, + "sha256": "b524fea4b29c5575610cbfbf282f7cd0f5e3400ce7b2feae54990eb42236db91" + }, + { + "path": "gpu/motif_five-float64-r0/state.npz", + "bytes": 32855, + "sha256": "efd2987fa121f8e9324329da620e2072e2ecc61d3c89fdec0e8f3de69b712477" + }, + { + "path": "gpu/motif_five-float64-r1/arrival-order.npz", + "bytes": 1342, + "sha256": "8ece97e02478970cf56ad1192c6c31f1010893ca70732b4c56a12e4c46defb1f" + }, + { + "path": "gpu/motif_five-float64-r1/comparison.json", + "bytes": 1202, + "sha256": "5c5fdee60d3131fd6454ec0af496d3f34630314c8b0dc6ba2d7cf6c24b20979d" + }, + { + "path": "gpu/motif_five-float64-r1/metrics.json", + "bytes": 2109, + "sha256": "91117647bac42fc9d3f234a3380641863fd6b4a51eab24221f2bb8fba852162a" + }, + { + "path": "gpu/motif_five-float64-r1/state.npz", + "bytes": 32855, + "sha256": "efd2987fa121f8e9324329da620e2072e2ecc61d3c89fdec0e8f3de69b712477" + }, + { + "path": "gpu/motif_five-float64-r2/arrival-order.npz", + "bytes": 1342, + "sha256": "8ece97e02478970cf56ad1192c6c31f1010893ca70732b4c56a12e4c46defb1f" + }, + { + "path": "gpu/motif_five-float64-r2/comparison.json", + "bytes": 1202, + "sha256": "a412787c057a232b2d1274cadfa010b5029836a0a6599c0539186c9671f08691" + }, + { + "path": "gpu/motif_five-float64-r2/metrics.json", + "bytes": 2111, + "sha256": "6901ec19e9c344c62d9248d707391e5e4fdeec68ab59669049b8aadde35e81be" + }, + { + "path": "gpu/motif_five-float64-r2/state.npz", + "bytes": 32855, + "sha256": "efd2987fa121f8e9324329da620e2072e2ecc61d3c89fdec0e8f3de69b712477" + }, + { + "path": "gpu/motif_no_input-float32-r0/arrival-order.npz", + "bytes": 964, + "sha256": "b64e6a697db766a6b54d24d3d01959986e8d5f303feaa10e9b55160ca71788ed" + }, + { + "path": "gpu/motif_no_input-float32-r0/comparison.json", + "bytes": 1200, + "sha256": "069cc644ac74aba235f5de81f8d425b6730fd02111e5fd916dc4a20e5d50f547" + }, + { + "path": "gpu/motif_no_input-float32-r0/metrics.json", + "bytes": 2134, + "sha256": "e76b9edb18ad6665b7eb2e737ac910fdb4e841b8fa5fb474c1263715898c0f24" + }, + { + "path": "gpu/motif_no_input-float32-r0/state.npz", + "bytes": 3302, + "sha256": "8017dd6abcffcd39d6a9156f726d8df53d4c14a17b45bb8c9c45bb55d26e48e3" + }, + { + "path": "gpu/motif_no_input-float32-r1/arrival-order.npz", + "bytes": 964, + "sha256": "b64e6a697db766a6b54d24d3d01959986e8d5f303feaa10e9b55160ca71788ed" + }, + { + "path": "gpu/motif_no_input-float32-r1/comparison.json", + "bytes": 1200, + "sha256": "0cc735ae6f634ea4427e04f6591b808f057ca44ab33170f5d8e1e7a988fc9e8b" + }, + { + "path": "gpu/motif_no_input-float32-r1/metrics.json", + "bytes": 2134, + "sha256": "4d01c6d9616275aa788a6a485f2278b07e46c114d0c1d7bbf1399f71fc8fe59f" + }, + { + "path": "gpu/motif_no_input-float32-r1/state.npz", + "bytes": 3302, + "sha256": "8017dd6abcffcd39d6a9156f726d8df53d4c14a17b45bb8c9c45bb55d26e48e3" + }, + { + "path": "gpu/motif_no_input-float32-r2/arrival-order.npz", + "bytes": 964, + "sha256": "b64e6a697db766a6b54d24d3d01959986e8d5f303feaa10e9b55160ca71788ed" + }, + { + "path": "gpu/motif_no_input-float32-r2/comparison.json", + "bytes": 1200, + "sha256": "6696d8a5168715a985464d7893d0261813bacb3eff85b4a3edadd9b781fe5d84" + }, + { + "path": "gpu/motif_no_input-float32-r2/metrics.json", + "bytes": 2133, + "sha256": "4cc9848437df51ac61fc9c9734070f0c09ee87c6fadc48009dd6d8d9fc0610e9" + }, + { + "path": "gpu/motif_no_input-float32-r2/state.npz", + "bytes": 3302, + "sha256": "8017dd6abcffcd39d6a9156f726d8df53d4c14a17b45bb8c9c45bb55d26e48e3" + }, + { + "path": "gpu/motif_no_input-float64-r0/arrival-order.npz", + "bytes": 964, + "sha256": "b64e6a697db766a6b54d24d3d01959986e8d5f303feaa10e9b55160ca71788ed" + }, + { + "path": "gpu/motif_no_input-float64-r0/comparison.json", + "bytes": 1200, + "sha256": "b9f97cc5134b6506c8ca1bbfcc0e1b5542c7c26051053446128fd29e67eca866" + }, + { + "path": "gpu/motif_no_input-float64-r0/metrics.json", + "bytes": 2105, + "sha256": "e064174f4fc484ea2b6efa3246dd85cb2c8b3113cf9bd199ac25387ecda23e16" + }, + { + "path": "gpu/motif_no_input-float64-r0/state.npz", + "bytes": 3603, + "sha256": "b3820b4dabe9c5a3243a270d4fcb52f13a3b7925b795948e0152ed3d0185e6a2" + }, + { + "path": "gpu/motif_no_input-float64-r1/arrival-order.npz", + "bytes": 964, + "sha256": "b64e6a697db766a6b54d24d3d01959986e8d5f303feaa10e9b55160ca71788ed" + }, + { + "path": "gpu/motif_no_input-float64-r1/comparison.json", + "bytes": 1200, + "sha256": "60f034535db6d3d897805cb82c33a702e4d87eeededae8e8af95d7cbcd600ee5" + }, + { + "path": "gpu/motif_no_input-float64-r1/metrics.json", + "bytes": 2107, + "sha256": "7c16b3e776a8ebc161114a76899097c7fe41c94618bc6b21aa1c06e5dcdc6ec8" + }, + { + "path": "gpu/motif_no_input-float64-r1/state.npz", + "bytes": 3603, + "sha256": "b3820b4dabe9c5a3243a270d4fcb52f13a3b7925b795948e0152ed3d0185e6a2" + }, + { + "path": "gpu/motif_no_input-float64-r2/arrival-order.npz", + "bytes": 964, + "sha256": "b64e6a697db766a6b54d24d3d01959986e8d5f303feaa10e9b55160ca71788ed" + }, + { + "path": "gpu/motif_no_input-float64-r2/comparison.json", + "bytes": 1200, + "sha256": "aea6fd5b29d1d2b301fad4dcd45baca49d2e68a1b8e236f44d41847565eee984" + }, + { + "path": "gpu/motif_no_input-float64-r2/metrics.json", + "bytes": 2104, + "sha256": "993b0d94f5f35149c25c304f19d453707e21335901fd60affdc2f8e54950f8a5" + }, + { + "path": "gpu/motif_no_input-float64-r2/state.npz", + "bytes": 3603, + "sha256": "b3820b4dabe9c5a3243a270d4fcb52f13a3b7925b795948e0152ed3d0185e6a2" + }, + { + "path": "gpu/motif_pair-float32-r0/arrival-order.npz", + "bytes": 1060, + "sha256": "2bead61b9fc1384019bb1842008ba86f752ffec242fff21bb7560a2f28b4a2d4" + }, + { + "path": "gpu/motif_pair-float32-r0/comparison.json", + "bytes": 1200, + "sha256": "e19afca3976bf288cff894efc55e7bd8c12f671544031c4c4ea85c0e29c7a095" + }, + { + "path": "gpu/motif_pair-float32-r0/metrics.json", + "bytes": 2135, + "sha256": "f4059a737e317bd31a4fc5444a088c5d16fb8e6ab3dff1a50c97f36229c9737b" + }, + { + "path": "gpu/motif_pair-float32-r0/state.npz", + "bytes": 4041, + "sha256": "8df39e860cedb0b321938c9ae5d36959237c452f4cbdb354730ab6c2311bca20" + }, + { + "path": "gpu/motif_pair-float32-r1/arrival-order.npz", + "bytes": 1060, + "sha256": "2bead61b9fc1384019bb1842008ba86f752ffec242fff21bb7560a2f28b4a2d4" + }, + { + "path": "gpu/motif_pair-float32-r1/comparison.json", + "bytes": 1200, + "sha256": "79dd0b8acd03a41c9218986b6389bf4361dd61efc219a128310532318532dac5" + }, + { + "path": "gpu/motif_pair-float32-r1/metrics.json", + "bytes": 2135, + "sha256": "58383925af6d7de1043600e27a5be51da709ce00caccaf824883a115715fb671" + }, + { + "path": "gpu/motif_pair-float32-r1/state.npz", + "bytes": 4041, + "sha256": "8df39e860cedb0b321938c9ae5d36959237c452f4cbdb354730ab6c2311bca20" + }, + { + "path": "gpu/motif_pair-float32-r2/arrival-order.npz", + "bytes": 1060, + "sha256": "2bead61b9fc1384019bb1842008ba86f752ffec242fff21bb7560a2f28b4a2d4" + }, + { + "path": "gpu/motif_pair-float32-r2/comparison.json", + "bytes": 1200, + "sha256": "5bd76b86940c87422c7a45c123943503fb796fc32746e6da9a167378286359fa" + }, + { + "path": "gpu/motif_pair-float32-r2/metrics.json", + "bytes": 2136, + "sha256": "68c7c486c42eea81dcd1f6af2236c422154edfaa21761efec4ccd3a12cc3cd30" + }, + { + "path": "gpu/motif_pair-float32-r2/state.npz", + "bytes": 4041, + "sha256": "8df39e860cedb0b321938c9ae5d36959237c452f4cbdb354730ab6c2311bca20" + }, + { + "path": "gpu/motif_pair-float64-r0/arrival-order.npz", + "bytes": 1060, + "sha256": "2bead61b9fc1384019bb1842008ba86f752ffec242fff21bb7560a2f28b4a2d4" + }, + { + "path": "gpu/motif_pair-float64-r0/comparison.json", + "bytes": 1200, + "sha256": "9d8c54acd5ae46ebef18e28d0284f9dc5dccfc5548690bb40b463348f7e434da" + }, + { + "path": "gpu/motif_pair-float64-r0/metrics.json", + "bytes": 2106, + "sha256": "4dda6a7c1efb337de1d4045001c34c8c753be1a9f6a2e8b7dd554d2bcaea26c1" + }, + { + "path": "gpu/motif_pair-float64-r0/state.npz", + "bytes": 4747, + "sha256": "5b8eaa6f9a010760b0fee803dace2ca0ebb3fb279281938596b704bece440933" + }, + { + "path": "gpu/motif_pair-float64-r1/arrival-order.npz", + "bytes": 1060, + "sha256": "2bead61b9fc1384019bb1842008ba86f752ffec242fff21bb7560a2f28b4a2d4" + }, + { + "path": "gpu/motif_pair-float64-r1/comparison.json", + "bytes": 1200, + "sha256": "7447ab06a506aa0ca2a69c64fedd79973c8249ec120c67e0e882f7f8773b77d8" + }, + { + "path": "gpu/motif_pair-float64-r1/metrics.json", + "bytes": 2105, + "sha256": "3605b358e707431fb11428ff58ded32c0a2a1b580a8a3b30960a361c3092e1eb" + }, + { + "path": "gpu/motif_pair-float64-r1/state.npz", + "bytes": 4747, + "sha256": "5b8eaa6f9a010760b0fee803dace2ca0ebb3fb279281938596b704bece440933" + }, + { + "path": "gpu/motif_pair-float64-r2/arrival-order.npz", + "bytes": 1060, + "sha256": "2bead61b9fc1384019bb1842008ba86f752ffec242fff21bb7560a2f28b4a2d4" + }, + { + "path": "gpu/motif_pair-float64-r2/comparison.json", + "bytes": 1200, + "sha256": "ed5ed460d0f71c371f053e0bef2e1434db9733461715075b45135ab51821b896" + }, + { + "path": "gpu/motif_pair-float64-r2/metrics.json", + "bytes": 2105, + "sha256": "1bd7c6284304465170973724b3892c3c5fdf7710a4b7bdc1022cd95148385abd" + }, + { + "path": "gpu/motif_pair-float64-r2/state.npz", + "bytes": 4747, + "sha256": "5b8eaa6f9a010760b0fee803dace2ca0ebb3fb279281938596b704bece440933" + }, + { + "path": "gpu/motif_trio-float32-r0/arrival-order.npz", + "bytes": 1148, + "sha256": "b65eac2120376c86013611c6a7f73d460f8276089c4a7099ce3a0d6c89694469" + }, + { + "path": "gpu/motif_trio-float32-r0/comparison.json", + "bytes": 1200, + "sha256": "06070c6028ab04a0ff1062021a30aa9916c3d57be951373cd9c5cf85b435e83a" + }, + { + "path": "gpu/motif_trio-float32-r0/metrics.json", + "bytes": 2135, + "sha256": "fdd59ec33881edc9d8e8b7523cd01167da730aa4b4a095cabaf520ba488c623d" + }, + { + "path": "gpu/motif_trio-float32-r0/state.npz", + "bytes": 5831, + "sha256": "d7e0d15bc95c54a389a6f2df8986273d493e61e76cd60b4a8c3a5a2a62f441d3" + }, + { + "path": "gpu/motif_trio-float32-r1/arrival-order.npz", + "bytes": 1148, + "sha256": "b65eac2120376c86013611c6a7f73d460f8276089c4a7099ce3a0d6c89694469" + }, + { + "path": "gpu/motif_trio-float32-r1/comparison.json", + "bytes": 1200, + "sha256": "2ab4f0357307ec6137eb80bf0e3194d67227fb7bc256b68076effe8e25868db7" + }, + { + "path": "gpu/motif_trio-float32-r1/metrics.json", + "bytes": 2136, + "sha256": "6fb4a69f6963b2541254f0051e9df99a3f32472b9d90cfc775fbe857c50a16f6" + }, + { + "path": "gpu/motif_trio-float32-r1/state.npz", + "bytes": 5831, + "sha256": "d7e0d15bc95c54a389a6f2df8986273d493e61e76cd60b4a8c3a5a2a62f441d3" + }, + { + "path": "gpu/motif_trio-float32-r2/arrival-order.npz", + "bytes": 1148, + "sha256": "b65eac2120376c86013611c6a7f73d460f8276089c4a7099ce3a0d6c89694469" + }, + { + "path": "gpu/motif_trio-float32-r2/comparison.json", + "bytes": 1200, + "sha256": "c433bb2c1f27208ab7a92577fe5421a0dce9422ad8009251e006d147e94068db" + }, + { + "path": "gpu/motif_trio-float32-r2/metrics.json", + "bytes": 2135, + "sha256": "3e8ccdd69164d8efb32d6c57dca3f9654eed7d7a2251331b1bd3623ef820964b" + }, + { + "path": "gpu/motif_trio-float32-r2/state.npz", + "bytes": 5831, + "sha256": "d7e0d15bc95c54a389a6f2df8986273d493e61e76cd60b4a8c3a5a2a62f441d3" + }, + { + "path": "gpu/motif_trio-float64-r0/arrival-order.npz", + "bytes": 1148, + "sha256": "b65eac2120376c86013611c6a7f73d460f8276089c4a7099ce3a0d6c89694469" + }, + { + "path": "gpu/motif_trio-float64-r0/comparison.json", + "bytes": 1200, + "sha256": "67dfe0b913635f72363d85a720a93ed95c90f5b554319676ef5d86e366d6d454" + }, + { + "path": "gpu/motif_trio-float64-r0/metrics.json", + "bytes": 2108, + "sha256": "9c7a3e46de47a43265fbc6a0fc3b7fff2dcf638edd1584c78a4af57f9d58ce31" + }, + { + "path": "gpu/motif_trio-float64-r0/state.npz", + "bytes": 7621, + "sha256": "6769bad069a1523a1dba9c696f0412189421012b55dd38b65177a060b9a256e6" + }, + { + "path": "gpu/motif_trio-float64-r1/arrival-order.npz", + "bytes": 1148, + "sha256": "b65eac2120376c86013611c6a7f73d460f8276089c4a7099ce3a0d6c89694469" + }, + { + "path": "gpu/motif_trio-float64-r1/comparison.json", + "bytes": 1200, + "sha256": "4925f8501521d159702d6b701d815499c9369bb148003afd7a5d3987f913f218" + }, + { + "path": "gpu/motif_trio-float64-r1/metrics.json", + "bytes": 2108, + "sha256": "31fbb95cceb1da812335ca8b9dd7717f65a930359d83bc7a863bd9f25d660220" + }, + { + "path": "gpu/motif_trio-float64-r1/state.npz", + "bytes": 7621, + "sha256": "6769bad069a1523a1dba9c696f0412189421012b55dd38b65177a060b9a256e6" + }, + { + "path": "gpu/motif_trio-float64-r2/arrival-order.npz", + "bytes": 1148, + "sha256": "b65eac2120376c86013611c6a7f73d460f8276089c4a7099ce3a0d6c89694469" + }, + { + "path": "gpu/motif_trio-float64-r2/comparison.json", + "bytes": 1200, + "sha256": "75734d45ab6bc68268ab2bfa8d1c978e74289f1733f12c3e093e25b0e62c2412" + }, + { + "path": "gpu/motif_trio-float64-r2/metrics.json", + "bytes": 2109, + "sha256": "6b4701ce099dcdb7847a106437b6a227cc1c7f48e7b943bfd1112b388381e4d8" + }, + { + "path": "gpu/motif_trio-float64-r2/state.npz", + "bytes": 7621, + "sha256": "6769bad069a1523a1dba9c696f0412189421012b55dd38b65177a060b9a256e6" + }, + { + "path": "gpu/ordered_cancellation-float32-r0/arrival-order.npz", + "bytes": 1132, + "sha256": "382a48347757d1b56bca51ff93f38273d36ad2a0b856d45b11d9c54bd697ad48" + }, + { + "path": "gpu/ordered_cancellation-float32-r0/comparison.json", + "bytes": 1212, + "sha256": "97e70b9338f2bd351f477de44423eaf23dfc096f3763267d6b36ac82f879fd1f" + }, + { + "path": "gpu/ordered_cancellation-float32-r0/metrics.json", + "bytes": 2141, + "sha256": "e1c51742ddab9b387935ce91750317ba78ce46384420263fcf7398551c062f6e" + }, + { + "path": "gpu/ordered_cancellation-float32-r0/state.npz", + "bytes": 5097, + "sha256": "8ae98291cfde67cd7c9a353b1e66c0a7141a053fd52df9aff7b78cff9fbb53bd" + }, + { + "path": "gpu/ordered_cancellation-float32-r1/arrival-order.npz", + "bytes": 1132, + "sha256": "382a48347757d1b56bca51ff93f38273d36ad2a0b856d45b11d9c54bd697ad48" + }, + { + "path": "gpu/ordered_cancellation-float32-r1/comparison.json", + "bytes": 1212, + "sha256": "e08c95274102540fe4201f6d708388853fe87f39a0c1cc54035cccc1f819fc79" + }, + { + "path": "gpu/ordered_cancellation-float32-r1/metrics.json", + "bytes": 2141, + "sha256": "d4e1ea55b64bd29dd691c3b61ec51c53d2407190cc3260a6288d86ecc6c5ee0a" + }, + { + "path": "gpu/ordered_cancellation-float32-r1/state.npz", + "bytes": 5097, + "sha256": "8ae98291cfde67cd7c9a353b1e66c0a7141a053fd52df9aff7b78cff9fbb53bd" + }, + { + "path": "gpu/ordered_cancellation-float32-r2/arrival-order.npz", + "bytes": 1132, + "sha256": "382a48347757d1b56bca51ff93f38273d36ad2a0b856d45b11d9c54bd697ad48" + }, + { + "path": "gpu/ordered_cancellation-float32-r2/comparison.json", + "bytes": 1212, + "sha256": "863173342d260b41f003ea3cf231460390ce62266b4c87bad99940811355f946" + }, + { + "path": "gpu/ordered_cancellation-float32-r2/metrics.json", + "bytes": 2141, + "sha256": "3f7e854fe53979703c4641a4be9b22ad91d063885aac8f18bc4883bcfa4aaa6e" + }, + { + "path": "gpu/ordered_cancellation-float32-r2/state.npz", + "bytes": 5097, + "sha256": "8ae98291cfde67cd7c9a353b1e66c0a7141a053fd52df9aff7b78cff9fbb53bd" + }, + { + "path": "gpu/ordered_cancellation-float64-r0/arrival-order.npz", + "bytes": 1132, + "sha256": "382a48347757d1b56bca51ff93f38273d36ad2a0b856d45b11d9c54bd697ad48" + }, + { + "path": "gpu/ordered_cancellation-float64-r0/comparison.json", + "bytes": 1212, + "sha256": "ce34e9cb3dd179e507d258f6c1dada410890dc609510d2baa1cba2034d7819b7" + }, + { + "path": "gpu/ordered_cancellation-float64-r0/metrics.json", + "bytes": 2111, + "sha256": "c783ddcb8f98072d3aeb3d5008cefa52a7df093c1e21c01168ec0d94ad494848" + }, + { + "path": "gpu/ordered_cancellation-float64-r0/state.npz", + "bytes": 6972, + "sha256": "bba48e6dd9cba9cec4b16a68488dc0dc2d23e9281081e1b1105a1a6135182ebc" + }, + { + "path": "gpu/ordered_cancellation-float64-r1/arrival-order.npz", + "bytes": 1132, + "sha256": "382a48347757d1b56bca51ff93f38273d36ad2a0b856d45b11d9c54bd697ad48" + }, + { + "path": "gpu/ordered_cancellation-float64-r1/comparison.json", + "bytes": 1212, + "sha256": "f4198ff2aa762a34bf811def8a89f521deea5d348fb6d83c689f6e2e9f7503b6" + }, + { + "path": "gpu/ordered_cancellation-float64-r1/metrics.json", + "bytes": 2112, + "sha256": "fe5ab94117a5e9db792fc4b1cd2dcb832d70d3f3f3ca99ed78dae7b05fd4b783" + }, + { + "path": "gpu/ordered_cancellation-float64-r1/state.npz", + "bytes": 6972, + "sha256": "bba48e6dd9cba9cec4b16a68488dc0dc2d23e9281081e1b1105a1a6135182ebc" + }, + { + "path": "gpu/ordered_cancellation-float64-r2/arrival-order.npz", + "bytes": 1132, + "sha256": "382a48347757d1b56bca51ff93f38273d36ad2a0b856d45b11d9c54bd697ad48" + }, + { + "path": "gpu/ordered_cancellation-float64-r2/comparison.json", + "bytes": 1212, + "sha256": "62cfbc2eb26389d75968fa6d5e65dfc59293484a947c94a49656e03192953142" + }, + { + "path": "gpu/ordered_cancellation-float64-r2/metrics.json", + "bytes": 2112, + "sha256": "170294aa0b4eb36d5be2e9bf1e2c8fac999a751263a56e351c07066acfa2e800" + }, + { + "path": "gpu/ordered_cancellation-float64-r2/state.npz", + "bytes": 6972, + "sha256": "bba48e6dd9cba9cec4b16a68488dc0dc2d23e9281081e1b1105a1a6135182ebc" + }, + { + "path": "gpu/release_selfloop-float32-r0/arrival-order.npz", + "bytes": 1037, + "sha256": "4caaa7c58fcc40dbf9fff220ac032d11817f015d014f3442c86614fcc29ffd9a" + }, + { + "path": "gpu/release_selfloop-float32-r0/comparison.json", + "bytes": 1203, + "sha256": "9096f1e0b7bd2f0636f982c7e9d336b335630de1475988507f42570ee5ec8fbc" + }, + { + "path": "gpu/release_selfloop-float32-r0/metrics.json", + "bytes": 2135, + "sha256": "943c2eb1ebb59d266ed472d5ed765f594a7d726d0b0abd36fda0120617d02246" + }, + { + "path": "gpu/release_selfloop-float32-r0/state.npz", + "bytes": 4256, + "sha256": "a02198bd9adfe81bb52deed7719ed0cba660f24c609f1cd436950450bc70bc02" + }, + { + "path": "gpu/release_selfloop-float32-r1/arrival-order.npz", + "bytes": 1037, + "sha256": "4caaa7c58fcc40dbf9fff220ac032d11817f015d014f3442c86614fcc29ffd9a" + }, + { + "path": "gpu/release_selfloop-float32-r1/comparison.json", + "bytes": 1203, + "sha256": "93d69eba07971c0bdd620b2bf036ffae73c6e2cdba0297ac9c6fa62c58a3f70c" + }, + { + "path": "gpu/release_selfloop-float32-r1/metrics.json", + "bytes": 2134, + "sha256": "a7873bb08820fc2bc1700259cefea2e144d150dee2d63bf9612a066d0a87c7c5" + }, + { + "path": "gpu/release_selfloop-float32-r1/state.npz", + "bytes": 4256, + "sha256": "a02198bd9adfe81bb52deed7719ed0cba660f24c609f1cd436950450bc70bc02" + }, + { + "path": "gpu/release_selfloop-float32-r2/arrival-order.npz", + "bytes": 1037, + "sha256": "4caaa7c58fcc40dbf9fff220ac032d11817f015d014f3442c86614fcc29ffd9a" + }, + { + "path": "gpu/release_selfloop-float32-r2/comparison.json", + "bytes": 1203, + "sha256": "4dc94196990f8acaa09c656a216d72d2c5da008262da634221466faaed129914" + }, + { + "path": "gpu/release_selfloop-float32-r2/metrics.json", + "bytes": 2134, + "sha256": "762363b9400578440025f92904222bcb5f8d43f9449618c55755d89bf2e60bf2" + }, + { + "path": "gpu/release_selfloop-float32-r2/state.npz", + "bytes": 4256, + "sha256": "a02198bd9adfe81bb52deed7719ed0cba660f24c609f1cd436950450bc70bc02" + }, + { + "path": "gpu/release_selfloop-float64-r0/arrival-order.npz", + "bytes": 1037, + "sha256": "4caaa7c58fcc40dbf9fff220ac032d11817f015d014f3442c86614fcc29ffd9a" + }, + { + "path": "gpu/release_selfloop-float64-r0/comparison.json", + "bytes": 1203, + "sha256": "0b1d71d2572f4aee6f0860cb7c942007e86385d4b89d86c8bed4781b9a18f693" + }, + { + "path": "gpu/release_selfloop-float64-r0/metrics.json", + "bytes": 2105, + "sha256": "b81cc105366bd6cb500d4a30447250eef46d6c4f4ecfba56476a12a2604cee4a" + }, + { + "path": "gpu/release_selfloop-float64-r0/state.npz", + "bytes": 5052, + "sha256": "352dbf73a16a8c04faf5d7ab77f7490a85ad95be709e7a6214da02d05a187ca9" + }, + { + "path": "gpu/release_selfloop-float64-r1/arrival-order.npz", + "bytes": 1037, + "sha256": "4caaa7c58fcc40dbf9fff220ac032d11817f015d014f3442c86614fcc29ffd9a" + }, + { + "path": "gpu/release_selfloop-float64-r1/comparison.json", + "bytes": 1203, + "sha256": "31c9f680ff76a56c66aa1c9e931dc5cd20a98466982ba198af898d9a5303b41e" + }, + { + "path": "gpu/release_selfloop-float64-r1/metrics.json", + "bytes": 2106, + "sha256": "3799bdeaef2d1243500774ca38b33e188b9a684e887fb742583e1ea3df19a0b1" + }, + { + "path": "gpu/release_selfloop-float64-r1/state.npz", + "bytes": 5052, + "sha256": "352dbf73a16a8c04faf5d7ab77f7490a85ad95be709e7a6214da02d05a187ca9" + }, + { + "path": "gpu/release_selfloop-float64-r2/arrival-order.npz", + "bytes": 1037, + "sha256": "4caaa7c58fcc40dbf9fff220ac032d11817f015d014f3442c86614fcc29ffd9a" + }, + { + "path": "gpu/release_selfloop-float64-r2/comparison.json", + "bytes": 1203, + "sha256": "5b8436161d014ac5e8182363dabe071d2fad9c3941773fa850b45dfe6ccafcb6" + }, + { + "path": "gpu/release_selfloop-float64-r2/metrics.json", + "bytes": 2106, + "sha256": "786ff8d1e2203fe101596ad802bf3f3aa2fbb75a93c973647d224864ff3d68e9" + }, + { + "path": "gpu/release_selfloop-float64-r2/state.npz", + "bytes": 5052, + "sha256": "352dbf73a16a8c04faf5d7ab77f7490a85ad95be709e7a6214da02d05a187ca9" + }, + { + "path": "gpu/signed_random-float32-r0/arrival-order.npz", + "bytes": 14090, + "sha256": "f01cc11d373062be750def8db397521205986b6dfd60ebc2089ec9c4377056ad" + }, + { + "path": "gpu/signed_random-float32-r0/comparison.json", + "bytes": 1211, + "sha256": "a1ace6d4c542a2bf257f09424dd564caf5f13f876833baf0d213bc301f564740" + }, + { + "path": "gpu/signed_random-float32-r0/metrics.json", + "bytes": 2147, + "sha256": "ac2c60aed61a50d169d0f30974c7d609cf05c39604ad10c36807129f05044296" + }, + { + "path": "gpu/signed_random-float32-r0/state.npz", + "bytes": 346906, + "sha256": "4e422db27ba6622b0ef6f76b160baa26416f81c3e5421bdae561bf29a4c71c86" + }, + { + "path": "gpu/signed_random-float32-r1/arrival-order.npz", + "bytes": 14090, + "sha256": "f01cc11d373062be750def8db397521205986b6dfd60ebc2089ec9c4377056ad" + }, + { + "path": "gpu/signed_random-float32-r1/comparison.json", + "bytes": 1211, + "sha256": "293390081bb82b98456e07efb2be5ac2ea75ca61e583c47df3e2893df624eae5" + }, + { + "path": "gpu/signed_random-float32-r1/metrics.json", + "bytes": 2145, + "sha256": "42b06a42e3821a6b042b775bd9120a5cd5cd9ae49fc90f233e9f15972390bbc7" + }, + { + "path": "gpu/signed_random-float32-r1/state.npz", + "bytes": 346906, + "sha256": "4e422db27ba6622b0ef6f76b160baa26416f81c3e5421bdae561bf29a4c71c86" + }, + { + "path": "gpu/signed_random-float32-r2/arrival-order.npz", + "bytes": 14090, + "sha256": "f01cc11d373062be750def8db397521205986b6dfd60ebc2089ec9c4377056ad" + }, + { + "path": "gpu/signed_random-float32-r2/comparison.json", + "bytes": 1211, + "sha256": "ab194323647dc23c0f79b310146c4ed63f01634147b41c286337ba4c995747b1" + }, + { + "path": "gpu/signed_random-float32-r2/metrics.json", + "bytes": 2148, + "sha256": "4f177d07d8f8510414aba5d75e6de7d9b61a856bae5f2c84ae1484f3275d7b06" + }, + { + "path": "gpu/signed_random-float32-r2/state.npz", + "bytes": 346906, + "sha256": "4e422db27ba6622b0ef6f76b160baa26416f81c3e5421bdae561bf29a4c71c86" + }, + { + "path": "gpu/signed_random-float64-r0/arrival-order.npz", + "bytes": 14090, + "sha256": "f01cc11d373062be750def8db397521205986b6dfd60ebc2089ec9c4377056ad" + }, + { + "path": "gpu/signed_random-float64-r0/comparison.json", + "bytes": 1211, + "sha256": "dcbc03b01b1bab61256546c12bacdabb1067d0cf862198333b56158331d50285" + }, + { + "path": "gpu/signed_random-float64-r0/metrics.json", + "bytes": 2121, + "sha256": "2067336a1093ecb37540c92b4d52ba5988a3631b72cc0a41fafbc5f3347ac4be" + }, + { + "path": "gpu/signed_random-float64-r0/state.npz", + "bytes": 663719, + "sha256": "844194cf8d237bef1827f9209fb61832e9677d0407262dc0cd56dcdd691131b6" + }, + { + "path": "gpu/signed_random-float64-r1/arrival-order.npz", + "bytes": 14090, + "sha256": "f01cc11d373062be750def8db397521205986b6dfd60ebc2089ec9c4377056ad" + }, + { + "path": "gpu/signed_random-float64-r1/comparison.json", + "bytes": 1211, + "sha256": "57b6a2e47242160623c0fd85467e0c49987f8c94bb46484047effbebc676c872" + }, + { + "path": "gpu/signed_random-float64-r1/metrics.json", + "bytes": 2121, + "sha256": "b22191dccd7f29e70fc5af69a4ef1cbee82054fa47e15155b13871d52a60687f" + }, + { + "path": "gpu/signed_random-float64-r1/state.npz", + "bytes": 663719, + "sha256": "844194cf8d237bef1827f9209fb61832e9677d0407262dc0cd56dcdd691131b6" + }, + { + "path": "gpu/signed_random-float64-r2/arrival-order.npz", + "bytes": 14090, + "sha256": "f01cc11d373062be750def8db397521205986b6dfd60ebc2089ec9c4377056ad" + }, + { + "path": "gpu/signed_random-float64-r2/comparison.json", + "bytes": 1211, + "sha256": "e3a1de9283170ef928d9f9178f8620f5ae251819c8d28b15e567d54d506210c0" + }, + { + "path": "gpu/signed_random-float64-r2/metrics.json", + "bytes": 2120, + "sha256": "a0d5d7816d48e15f19c8343f0c2e7cf9205334c3255baa70c625546dbbcd7ecf" + }, + { + "path": "gpu/signed_random-float64-r2/state.npz", + "bytes": 663719, + "sha256": "844194cf8d237bef1827f9209fb61832e9677d0407262dc0cd56dcdd691131b6" + }, + { + "path": "gpu/threshold_rounding-float32-r0/arrival-order.npz", + "bytes": 964, + "sha256": "b64e6a697db766a6b54d24d3d01959986e8d5f303feaa10e9b55160ca71788ed" + }, + { + "path": "gpu/threshold_rounding-float32-r0/comparison.json", + "bytes": 1204, + "sha256": "8739225c90857ab6c2b9e8e486c224e12ec65466e10129f71ce288fab6266c7d" + }, + { + "path": "gpu/threshold_rounding-float32-r0/metrics.json", + "bytes": 2135, + "sha256": "ae27ea25d3c1e39716bc1ec6c81897efc528398ce45fa39e0e49bdaecac3ca2b" + }, + { + "path": "gpu/threshold_rounding-float32-r0/state.npz", + "bytes": 4304, + "sha256": "a77e88223658f1ad8346e714e1aeac304e33889ca4c37cf378149f19c414a33d" + }, + { + "path": "gpu/threshold_rounding-float32-r1/arrival-order.npz", + "bytes": 964, + "sha256": "b64e6a697db766a6b54d24d3d01959986e8d5f303feaa10e9b55160ca71788ed" + }, + { + "path": "gpu/threshold_rounding-float32-r1/comparison.json", + "bytes": 1204, + "sha256": "a10bb1a007ef61c4cb33ff5e0f640ce9a396d7b32b3c80ca6de48bff4f0491ed" + }, + { + "path": "gpu/threshold_rounding-float32-r1/metrics.json", + "bytes": 2135, + "sha256": "58858c943191b48a6defe7dc9e5171997f06a4cb70b7244d511cf287ba12bf88" + }, + { + "path": "gpu/threshold_rounding-float32-r1/state.npz", + "bytes": 4304, + "sha256": "a77e88223658f1ad8346e714e1aeac304e33889ca4c37cf378149f19c414a33d" + }, + { + "path": "gpu/threshold_rounding-float32-r2/arrival-order.npz", + "bytes": 964, + "sha256": "b64e6a697db766a6b54d24d3d01959986e8d5f303feaa10e9b55160ca71788ed" + }, + { + "path": "gpu/threshold_rounding-float32-r2/comparison.json", + "bytes": 1204, + "sha256": "96bdc33ff14f50247dd4a4224ce0bb3d734c80a437147c0baed69588ea3b48f2" + }, + { + "path": "gpu/threshold_rounding-float32-r2/metrics.json", + "bytes": 2134, + "sha256": "86a77aec3230eea856d5b81f12ad7737807ffbaa9e23e78553208dd3a4f2cb93" + }, + { + "path": "gpu/threshold_rounding-float32-r2/state.npz", + "bytes": 4304, + "sha256": "a77e88223658f1ad8346e714e1aeac304e33889ca4c37cf378149f19c414a33d" + }, + { + "path": "gpu/threshold_rounding-float64-r0/arrival-order.npz", + "bytes": 964, + "sha256": "b64e6a697db766a6b54d24d3d01959986e8d5f303feaa10e9b55160ca71788ed" + }, + { + "path": "gpu/threshold_rounding-float64-r0/comparison.json", + "bytes": 1204, + "sha256": "61fede1ddcd6e65c014a6310189521df46f437e711ac7659cf7b1bda068edf41" + }, + { + "path": "gpu/threshold_rounding-float64-r0/metrics.json", + "bytes": 2107, + "sha256": "ebee8abadabeae92dca41ba2afe81d68d919bf3652320c02d241d3c75834ff4e" + }, + { + "path": "gpu/threshold_rounding-float64-r0/state.npz", + "bytes": 6811, + "sha256": "0d621a52620987dc588522ba43b9a2823769b80b2f11ad9a71ad5940fb27f893" + }, + { + "path": "gpu/threshold_rounding-float64-r1/arrival-order.npz", + "bytes": 964, + "sha256": "b64e6a697db766a6b54d24d3d01959986e8d5f303feaa10e9b55160ca71788ed" + }, + { + "path": "gpu/threshold_rounding-float64-r1/comparison.json", + "bytes": 1204, + "sha256": "04edfac5ddd74456202aa89df3d3062fd07abe42445b17a038921667715c6a6b" + }, + { + "path": "gpu/threshold_rounding-float64-r1/metrics.json", + "bytes": 2106, + "sha256": "89324a2e788074ea518da354f93396643ecf16ff16c1ce4fddffa86b4c3323af" + }, + { + "path": "gpu/threshold_rounding-float64-r1/state.npz", + "bytes": 6811, + "sha256": "0d621a52620987dc588522ba43b9a2823769b80b2f11ad9a71ad5940fb27f893" + }, + { + "path": "gpu/threshold_rounding-float64-r2/arrival-order.npz", + "bytes": 964, + "sha256": "b64e6a697db766a6b54d24d3d01959986e8d5f303feaa10e9b55160ca71788ed" + }, + { + "path": "gpu/threshold_rounding-float64-r2/comparison.json", + "bytes": 1204, + "sha256": "c7c9b6572f20a1478827ce792c139bc49461dc113bd3cacc6be9f508b8b14201" + }, + { + "path": "gpu/threshold_rounding-float64-r2/metrics.json", + "bytes": 2103, + "sha256": "c129a9cc8dd60ac96152d5651edc7731851a7812ad48b89441139fdcb87e3aeb" + }, + { + "path": "gpu/threshold_rounding-float64-r2/state.npz", + "bytes": 6811, + "sha256": "0d621a52620987dc588522ba43b9a2823769b80b2f11ad9a71ad5940fb27f893" + }, + { + "path": "gpu-reference/extension-build/.ninja_deps", + "bytes": 723996, + "sha256": "16862647377b64a27506b9bbb608bbccd3b13f62fc0285acccf6461f4b772f2f" + }, + { + "path": "gpu-reference/extension-build/.ninja_log", + "bytes": 224, + "sha256": "c788a52dce4cffce62d069603fd5f121fad489f6e9176af87ff51020f982f56a" + }, + { + "path": "gpu-reference/extension-build/build.ninja", + "bytes": 2109, + "sha256": "c570f72b9a2f486e104ed3bf5b1b9f2ccc729ecab02046cd62389d629fb4f48f" + }, + { + "path": "gpu-reference/extension-build/lock", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "gpu-reference/extension-build/male_cns_lif_deterministic_v2_ext.so", + "bytes": 291280, + "sha256": "2b5d56ae5b40051b5b2cdaa51cdc39bed86d03bb804594f82b5855c14ec3889c" + }, + { + "path": "gpu-reference/extension-build/phase4p_ext.cuda.o", + "bytes": 101992, + "sha256": "443ab3fb57a26245a7f95ecac415d6b8ed7634cd0ad08a36f73f7a7b1a923c48" + }, + { + "path": "gpu-reference/extension-build/phase4p_ext.o", + "bytes": 377136, + "sha256": "27d284f6a369221a931251b5a03ce133cc8231a97942567d4efafbfb45483811" + }, + { + "path": "gpu-reference/extension.json", + "bytes": 442, + "sha256": "fa7fb04108f2688fed47132c0af29c283727a999161c11e219ed010c15d6147c" + }, + { + "path": "oracle/fanin_bursts-float32/case.json", + "bytes": 1265, + "sha256": "859d9f55df89add3344e082081644fd81520756118e9106ecec181d3ba0268f2" + }, + { + "path": "oracle/fanin_bursts-float32/coefficients.json", + "bytes": 2329, + "sha256": "934af1eecfdadd2a5cca6313b602b9bbba115e87793a68cc36f7352bc38fca65" + }, + { + "path": "oracle/fanin_bursts-float32/environment.json", + "bytes": 352, + "sha256": "8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6" + }, + { + "path": "oracle/fanin_bursts-float32/instrumented/coefficients.json", + "bytes": 2329, + "sha256": "934af1eecfdadd2a5cca6313b602b9bbba115e87793a68cc36f7352bc38fca65" + }, + { + "path": "oracle/fanin_bursts-float32/instrumented/compiled-code.json", + "bytes": 14949, + "sha256": "dfbcf815d17465e4c83a54320687e77c3035c5064f6a81a11bffc5ce35ec0dd1" + }, + { + "path": "oracle/fanin_bursts-float32/instrumented/completeness.csv", + "bytes": 2125, + "sha256": "d8163907696aec1bf853ecccbe301c50efb4abd5b1c76b9a3dfa34f0e9e36c20" + }, + { + "path": "oracle/fanin_bursts-float32/instrumented/connectivity.parquet", + "bytes": 9041, + "sha256": "87dfbd207929725101477715d0684af71971d93cb279c3e195704b2b939b3f86" + }, + { + "path": "oracle/fanin_bursts-float32/instrumented/generated-code.json", + "bytes": 14965, + "sha256": "20705f7f0f81917eb9630b91808b5121c36345e87a7bc9fc026aaf59dcb6cf41" + }, + { + "path": "oracle/fanin_bursts-float32/instrumented/input-audit.json", + "bytes": 1236, + "sha256": "33a8b070a595bbd95b4d1db7db92b73fa3f1b2e07a2065485f2114b9b73e4f56" + }, + { + "path": "oracle/fanin_bursts-float32/instrumented/queue-audit.json", + "bytes": 462, + "sha256": "65d8941a3f1ffaa814d17fb334abe65d9ceb851dd3f35e6861bad6aacfe764c8" + }, + { + "path": "oracle/fanin_bursts-float32/instrumented/schedule.json", + "bytes": 1984, + "sha256": "8d5492b7968694e913d3321b10d5779137045d4689fe50ec50b1ef7637d8fc04" + }, + { + "path": "oracle/fanin_bursts-float32/instrumented/state.npz", + "bytes": 20655, + "sha256": "660c10c905097d76d91bea09c67ca861534196fc720d0e12102bac074a8525f5" + }, + { + "path": "oracle/fanin_bursts-float32/proxy-validation.json", + "bytes": 774, + "sha256": "87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09" + }, + { + "path": "oracle/fanin_bursts-float32/state.npz", + "bytes": 20655, + "sha256": "660c10c905097d76d91bea09c67ca861534196fc720d0e12102bac074a8525f5" + }, + { + "path": "oracle/fanin_bursts-float32/summary.json", + "bytes": 586, + "sha256": "16fddc439b2ab0090f17f66231b5e2f293f5e9d1d29bcb608434bca256a81cb7" + }, + { + "path": "oracle/fanin_bursts-float32/unwrapped-audit/coefficients.json", + "bytes": 2329, + "sha256": "2caa1990718d199f371dbf5e685543bc61df67e08a5ad9a2c8bb1e2834a153a4" + }, + { + "path": "oracle/fanin_bursts-float32/unwrapped-audit/compiled-code.json", + "bytes": 14785, + "sha256": "82868f03604ec2a12efea07718960e3bfb1c8152950c3b6bc4fd8e1b1d46cf8d" + }, + { + "path": "oracle/fanin_bursts-float32/unwrapped-audit/completeness.csv", + "bytes": 2125, + "sha256": "d8163907696aec1bf853ecccbe301c50efb4abd5b1c76b9a3dfa34f0e9e36c20" + }, + { + "path": "oracle/fanin_bursts-float32/unwrapped-audit/connectivity.parquet", + "bytes": 9041, + "sha256": "87dfbd207929725101477715d0684af71971d93cb279c3e195704b2b939b3f86" + }, + { + "path": "oracle/fanin_bursts-float32/unwrapped-audit/generated-code.json", + "bytes": 14801, + "sha256": "d0a06d99f840cee691987410486bf9537202d3b57177bbd1a9ae8602232b89a4" + }, + { + "path": "oracle/fanin_bursts-float32/unwrapped-audit/input-audit.json", + "bytes": 1237, + "sha256": "aa47b175208838c2cc1f99a3d4b7317c4f5e3158901c11a86b957aa64a23ac5e" + }, + { + "path": "oracle/fanin_bursts-float32/unwrapped-audit/queue-audit.json", + "bytes": 371, + "sha256": "33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7" + }, + { + "path": "oracle/fanin_bursts-float32/unwrapped-audit/schedule.json", + "bytes": 1807, + "sha256": "42679bfcc102a0ec20fafe7fdf9cc82b02a0b8809931a49502ac6efd669fc9cd" + }, + { + "path": "oracle/fanin_bursts-float32/unwrapped-audit/state.npz", + "bytes": 19956, + "sha256": "b3882b11df437fbc3294af5986bb92c82c3f674ff98e23bcf9fe292a58738793" + }, + { + "path": "oracle/fanin_bursts-float64/case.json", + "bytes": 1265, + "sha256": "c5403a077e0a8ab4836f49de38fec39080b73b4571ec55d2440995b5aae48218" + }, + { + "path": "oracle/fanin_bursts-float64/coefficients.json", + "bytes": 2329, + "sha256": "bde79d95ef0097b827d5faf4d5658eafc009d8e9fcef1fddd645c953823e3f64" + }, + { + "path": "oracle/fanin_bursts-float64/environment.json", + "bytes": 352, + "sha256": "8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6" + }, + { + "path": "oracle/fanin_bursts-float64/instrumented/coefficients.json", + "bytes": 2329, + "sha256": "bde79d95ef0097b827d5faf4d5658eafc009d8e9fcef1fddd645c953823e3f64" + }, + { + "path": "oracle/fanin_bursts-float64/instrumented/compiled-code.json", + "bytes": 14949, + "sha256": "dfbcf815d17465e4c83a54320687e77c3035c5064f6a81a11bffc5ce35ec0dd1" + }, + { + "path": "oracle/fanin_bursts-float64/instrumented/completeness.csv", + "bytes": 2125, + "sha256": "d8163907696aec1bf853ecccbe301c50efb4abd5b1c76b9a3dfa34f0e9e36c20" + }, + { + "path": "oracle/fanin_bursts-float64/instrumented/connectivity.parquet", + "bytes": 9041, + "sha256": "87dfbd207929725101477715d0684af71971d93cb279c3e195704b2b939b3f86" + }, + { + "path": "oracle/fanin_bursts-float64/instrumented/generated-code.json", + "bytes": 14965, + "sha256": "c2767fee958084c4c7b6ebd99e8863ac01cdf8da2c315e77124480853ba4aa3e" + }, + { + "path": "oracle/fanin_bursts-float64/instrumented/input-audit.json", + "bytes": 1236, + "sha256": "81ae40f8b9d83c115b2cbfcdbd1f11f0e00856dea3f0c7b8aab81f7079449cec" + }, + { + "path": "oracle/fanin_bursts-float64/instrumented/queue-audit.json", + "bytes": 462, + "sha256": "7aa923702ed6527afc381ed6c13c94faea41dbf81f75fd9b596265eb3c31588a" + }, + { + "path": "oracle/fanin_bursts-float64/instrumented/schedule.json", + "bytes": 1984, + "sha256": "8d5492b7968694e913d3321b10d5779137045d4689fe50ec50b1ef7637d8fc04" + }, + { + "path": "oracle/fanin_bursts-float64/instrumented/state.npz", + "bytes": 27831, + "sha256": "48d4cf57a0fd4cd83dfad8497042063022a3a6b2214106080da69deaaaf5fa9e" + }, + { + "path": "oracle/fanin_bursts-float64/proxy-validation.json", + "bytes": 774, + "sha256": "87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09" + }, + { + "path": "oracle/fanin_bursts-float64/state.npz", + "bytes": 27831, + "sha256": "48d4cf57a0fd4cd83dfad8497042063022a3a6b2214106080da69deaaaf5fa9e" + }, + { + "path": "oracle/fanin_bursts-float64/summary.json", + "bytes": 586, + "sha256": "d8fc44ae9ed135ef63ae84b5901282c987bfb6daa7a1d912402a940f74a2c179" + }, + { + "path": "oracle/fanin_bursts-float64/unwrapped-audit/coefficients.json", + "bytes": 2329, + "sha256": "934af1eecfdadd2a5cca6313b602b9bbba115e87793a68cc36f7352bc38fca65" + }, + { + "path": "oracle/fanin_bursts-float64/unwrapped-audit/compiled-code.json", + "bytes": 14785, + "sha256": "82868f03604ec2a12efea07718960e3bfb1c8152950c3b6bc4fd8e1b1d46cf8d" + }, + { + "path": "oracle/fanin_bursts-float64/unwrapped-audit/completeness.csv", + "bytes": 2125, + "sha256": "d8163907696aec1bf853ecccbe301c50efb4abd5b1c76b9a3dfa34f0e9e36c20" + }, + { + "path": "oracle/fanin_bursts-float64/unwrapped-audit/connectivity.parquet", + "bytes": 9041, + "sha256": "87dfbd207929725101477715d0684af71971d93cb279c3e195704b2b939b3f86" + }, + { + "path": "oracle/fanin_bursts-float64/unwrapped-audit/generated-code.json", + "bytes": 14801, + "sha256": "f131e05fd1393703981f20a4efb5330eb1ec59a6d35688e5a1f2cdc7805e2d74" + }, + { + "path": "oracle/fanin_bursts-float64/unwrapped-audit/input-audit.json", + "bytes": 1237, + "sha256": "32eb33dcf7559fd63fc25806236b5e5328ab6ebb4fd7602b0cd4786bbde28822" + }, + { + "path": "oracle/fanin_bursts-float64/unwrapped-audit/queue-audit.json", + "bytes": 371, + "sha256": "33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7" + }, + { + "path": "oracle/fanin_bursts-float64/unwrapped-audit/schedule.json", + "bytes": 1807, + "sha256": "42679bfcc102a0ec20fafe7fdf9cc82b02a0b8809931a49502ac6efd669fc9cd" + }, + { + "path": "oracle/fanin_bursts-float64/unwrapped-audit/state.npz", + "bytes": 27132, + "sha256": "9f70b316dd4dd445ec083b2a46c06ca2a0900a49a2243c90d7958ff55ea2bdc0" + }, + { + "path": "oracle/highest_indegree-float32/case.json", + "bytes": 1708, + "sha256": "69211934e3e3f935bc3425652d6c38eeb6513353a88383973a7182078dd26abc" + }, + { + "path": "oracle/highest_indegree-float32/coefficients.json", + "bytes": 2329, + "sha256": "75bd398fd03ade662c9ca5fd3be0f0e745fd0e8deb87354bd3c0c116386a9f3a" + }, + { + "path": "oracle/highest_indegree-float32/environment.json", + "bytes": 352, + "sha256": "8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6" + }, + { + "path": "oracle/highest_indegree-float32/instrumented/coefficients.json", + "bytes": 2329, + "sha256": "75bd398fd03ade662c9ca5fd3be0f0e745fd0e8deb87354bd3c0c116386a9f3a" + }, + { + "path": "oracle/highest_indegree-float32/instrumented/compiled-code.json", + "bytes": 11202, + "sha256": "d37bbac320791543bdc13106f71c8aab50c345ca93aeee06d49ce26131e5e198" + }, + { + "path": "oracle/highest_indegree-float32/instrumented/completeness.csv", + "bytes": 1196, + "sha256": "e90a4d12741fbd0bd0b5fdcf447c2664f7dfcdba7930f4e9e7f05811f0b530f4" + }, + { + "path": "oracle/highest_indegree-float32/instrumented/connectivity.parquet", + "bytes": 9948, + "sha256": "1228ee73ad73051748dd1db62b5063c005471667fd8baacd6a9e76b134024800" + }, + { + "path": "oracle/highest_indegree-float32/instrumented/generated-code.json", + "bytes": 11214, + "sha256": "d75ed5f1158d321ceadcdad048ba8a5e65a38d62bfa99f04d50c25bfca6b98c9" + }, + { + "path": "oracle/highest_indegree-float32/instrumented/input-audit.json", + "bytes": 1236, + "sha256": "d60cc4f72357f4669296c0e49c7f9ae387a044fd2d5faf53868566775c919359" + }, + { + "path": "oracle/highest_indegree-float32/instrumented/queue-audit.json", + "bytes": 460, + "sha256": "fe89d26cc141038c4741f890ac07043d24dfc0bc9101a05c2bddbd1d0cd5411e" + }, + { + "path": "oracle/highest_indegree-float32/instrumented/schedule.json", + "bytes": 1574, + "sha256": "0db2d5f73709934bf7a91db2908a8dc3301614d09490769bf369aad96ee4f0fb" + }, + { + "path": "oracle/highest_indegree-float32/instrumented/state.npz", + "bytes": 233227, + "sha256": "11de500da330704334d9ce2d128aa2bba32decef851c75bc720a59f91fe534d2" + }, + { + "path": "oracle/highest_indegree-float32/proxy-validation.json", + "bytes": 774, + "sha256": "87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09" + }, + { + "path": "oracle/highest_indegree-float32/state.npz", + "bytes": 233227, + "sha256": "11de500da330704334d9ce2d128aa2bba32decef851c75bc720a59f91fe534d2" + }, + { + "path": "oracle/highest_indegree-float32/summary.json", + "bytes": 590, + "sha256": "d5b91ade99a1407bfa464c75af655c36fb8329ba252967de13ed4829560a788d" + }, + { + "path": "oracle/highest_indegree-float32/unwrapped-audit/coefficients.json", + "bytes": 2329, + "sha256": "7cfc3cd553fcac4fe52bfa455c5f440a8e98a1a621a135500e9a4b16551f6297" + }, + { + "path": "oracle/highest_indegree-float32/unwrapped-audit/compiled-code.json", + "bytes": 11038, + "sha256": "9ef07e82240727c9761386ecdd054475050156677e9b0a3a6bc37b845c1f602c" + }, + { + "path": "oracle/highest_indegree-float32/unwrapped-audit/completeness.csv", + "bytes": 1196, + "sha256": "e90a4d12741fbd0bd0b5fdcf447c2664f7dfcdba7930f4e9e7f05811f0b530f4" + }, + { + "path": "oracle/highest_indegree-float32/unwrapped-audit/connectivity.parquet", + "bytes": 9948, + "sha256": "1228ee73ad73051748dd1db62b5063c005471667fd8baacd6a9e76b134024800" + }, + { + "path": "oracle/highest_indegree-float32/unwrapped-audit/generated-code.json", + "bytes": 11050, + "sha256": "1d622ac2f0e046e2edde7dfb62b3fb7b2ce247c3324410782300eeabb1db4253" + }, + { + "path": "oracle/highest_indegree-float32/unwrapped-audit/input-audit.json", + "bytes": 1237, + "sha256": "38747cbcc998615df238c4b2497b88b85bc706e4e95ecde3ef0ed5029a104a39" + }, + { + "path": "oracle/highest_indegree-float32/unwrapped-audit/queue-audit.json", + "bytes": 371, + "sha256": "33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7" + }, + { + "path": "oracle/highest_indegree-float32/unwrapped-audit/schedule.json", + "bytes": 1411, + "sha256": "af9f8f7b182f3c780b23e1448888728ad89be2bbaf7ebe5631d6bff7c7ae77db" + }, + { + "path": "oracle/highest_indegree-float32/unwrapped-audit/state.npz", + "bytes": 232725, + "sha256": "b357f85d5670a0553719b59d1980d2d9231427e3cf439e9cb21f87927f501bdd" + }, + { + "path": "oracle/highest_indegree-float64/case.json", + "bytes": 1708, + "sha256": "f838e4bdc1ed3b3641c4da1414bf0d83f788c7f91a5dc18caef9851685a8ca5e" + }, + { + "path": "oracle/highest_indegree-float64/coefficients.json", + "bytes": 2329, + "sha256": "2caa1990718d199f371dbf5e685543bc61df67e08a5ad9a2c8bb1e2834a153a4" + }, + { + "path": "oracle/highest_indegree-float64/environment.json", + "bytes": 352, + "sha256": "8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6" + }, + { + "path": "oracle/highest_indegree-float64/instrumented/coefficients.json", + "bytes": 2329, + "sha256": "2caa1990718d199f371dbf5e685543bc61df67e08a5ad9a2c8bb1e2834a153a4" + }, + { + "path": "oracle/highest_indegree-float64/instrumented/compiled-code.json", + "bytes": 11202, + "sha256": "d37bbac320791543bdc13106f71c8aab50c345ca93aeee06d49ce26131e5e198" + }, + { + "path": "oracle/highest_indegree-float64/instrumented/completeness.csv", + "bytes": 1196, + "sha256": "e90a4d12741fbd0bd0b5fdcf447c2664f7dfcdba7930f4e9e7f05811f0b530f4" + }, + { + "path": "oracle/highest_indegree-float64/instrumented/connectivity.parquet", + "bytes": 9948, + "sha256": "1228ee73ad73051748dd1db62b5063c005471667fd8baacd6a9e76b134024800" + }, + { + "path": "oracle/highest_indegree-float64/instrumented/generated-code.json", + "bytes": 11214, + "sha256": "4d9691fc82adf6450724f20815681730f7103910537d43c0255fc617cc9d3ef1" + }, + { + "path": "oracle/highest_indegree-float64/instrumented/input-audit.json", + "bytes": 1236, + "sha256": "ee66710153714e771bc38056901694ecf0eeb56c302fa2ef83f8ba43ca4ef432" + }, + { + "path": "oracle/highest_indegree-float64/instrumented/queue-audit.json", + "bytes": 460, + "sha256": "05e668a0b1691bc44d4a2a363a5511afe4d8c930b70e7c24642316eb74226b97" + }, + { + "path": "oracle/highest_indegree-float64/instrumented/schedule.json", + "bytes": 1574, + "sha256": "0db2d5f73709934bf7a91db2908a8dc3301614d09490769bf369aad96ee4f0fb" + }, + { + "path": "oracle/highest_indegree-float64/instrumented/state.npz", + "bytes": 361249, + "sha256": "768d39cdeaa17a8b0fa7a64be5ffbe771e4d00c8db2709c4c5cdb0749f6c3455" + }, + { + "path": "oracle/highest_indegree-float64/proxy-validation.json", + "bytes": 774, + "sha256": "87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09" + }, + { + "path": "oracle/highest_indegree-float64/state.npz", + "bytes": 361249, + "sha256": "768d39cdeaa17a8b0fa7a64be5ffbe771e4d00c8db2709c4c5cdb0749f6c3455" + }, + { + "path": "oracle/highest_indegree-float64/summary.json", + "bytes": 590, + "sha256": "42ce5d10de1b489f5bd17201b7123fe2361f63f0d82ef9cac3c7250461f47b57" + }, + { + "path": "oracle/highest_indegree-float64/unwrapped-audit/coefficients.json", + "bytes": 2329, + "sha256": "75bd398fd03ade662c9ca5fd3be0f0e745fd0e8deb87354bd3c0c116386a9f3a" + }, + { + "path": "oracle/highest_indegree-float64/unwrapped-audit/compiled-code.json", + "bytes": 11038, + "sha256": "9ef07e82240727c9761386ecdd054475050156677e9b0a3a6bc37b845c1f602c" + }, + { + "path": "oracle/highest_indegree-float64/unwrapped-audit/completeness.csv", + "bytes": 1196, + "sha256": "e90a4d12741fbd0bd0b5fdcf447c2664f7dfcdba7930f4e9e7f05811f0b530f4" + }, + { + "path": "oracle/highest_indegree-float64/unwrapped-audit/connectivity.parquet", + "bytes": 9948, + "sha256": "1228ee73ad73051748dd1db62b5063c005471667fd8baacd6a9e76b134024800" + }, + { + "path": "oracle/highest_indegree-float64/unwrapped-audit/generated-code.json", + "bytes": 11050, + "sha256": "1cc7dd07015c0edd32145475c9d07b106b43b029636a1b33ba9df39a079c26a3" + }, + { + "path": "oracle/highest_indegree-float64/unwrapped-audit/input-audit.json", + "bytes": 1237, + "sha256": "f051b4f6988c9f27e955d416e38fb077d8172e80605e0c306cfdc6d9a4006791" + }, + { + "path": "oracle/highest_indegree-float64/unwrapped-audit/queue-audit.json", + "bytes": 371, + "sha256": "33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7" + }, + { + "path": "oracle/highest_indegree-float64/unwrapped-audit/schedule.json", + "bytes": 1411, + "sha256": "af9f8f7b182f3c780b23e1448888728ad89be2bbaf7ebe5631d6bff7c7ae77db" + }, + { + "path": "oracle/highest_indegree-float64/unwrapped-audit/state.npz", + "bytes": 360747, + "sha256": "59f64a289f8c81c2cca1f50d920b959ee13e4f928ede30d8814a43c1e650fa52" + }, + { + "path": "oracle/mixed_high_indegree-float32/case.json", + "bytes": 1711, + "sha256": "ff8f69144e361d8e27616e8755a01cace95850383bc337025639f24abd7b31c5" + }, + { + "path": "oracle/mixed_high_indegree-float32/coefficients.json", + "bytes": 2329, + "sha256": "74615669642e49f242e93e6a9c42d22c21438cbcbc0143d6ddca294465e543da" + }, + { + "path": "oracle/mixed_high_indegree-float32/environment.json", + "bytes": 352, + "sha256": "8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6" + }, + { + "path": "oracle/mixed_high_indegree-float32/instrumented/coefficients.json", + "bytes": 2329, + "sha256": "74615669642e49f242e93e6a9c42d22c21438cbcbc0143d6ddca294465e543da" + }, + { + "path": "oracle/mixed_high_indegree-float32/instrumented/compiled-code.json", + "bytes": 11202, + "sha256": "d37bbac320791543bdc13106f71c8aab50c345ca93aeee06d49ce26131e5e198" + }, + { + "path": "oracle/mixed_high_indegree-float32/instrumented/completeness.csv", + "bytes": 1188, + "sha256": "1f01bd89fa27a1fc11336336d420c1100171017febe074713369fcf51db27363" + }, + { + "path": "oracle/mixed_high_indegree-float32/instrumented/connectivity.parquet", + "bytes": 9264, + "sha256": "21e51e4ecca6476d5116cfbf140b1fdd5a4a0a8ee976158f801dee8003f91ae2" + }, + { + "path": "oracle/mixed_high_indegree-float32/instrumented/generated-code.json", + "bytes": 11214, + "sha256": "200ebe53ec57bdf2edf72a520a4a32468d99dc813b1a3720cc72bb3c973dec5a" + }, + { + "path": "oracle/mixed_high_indegree-float32/instrumented/input-audit.json", + "bytes": 1236, + "sha256": "45d8d642b41dd122cb262e54654784511353488320cce35add03becabc059912" + }, + { + "path": "oracle/mixed_high_indegree-float32/instrumented/queue-audit.json", + "bytes": 460, + "sha256": "e6b73b067ea95c9bd09c21dd9c83da230b7923edabc41a9a7c0ff00d8c1e5ca4" + }, + { + "path": "oracle/mixed_high_indegree-float32/instrumented/schedule.json", + "bytes": 1574, + "sha256": "0db2d5f73709934bf7a91db2908a8dc3301614d09490769bf369aad96ee4f0fb" + }, + { + "path": "oracle/mixed_high_indegree-float32/instrumented/state.npz", + "bytes": 200700, + "sha256": "5df4b542b303e747bbbfbdb057da15e522465e54d6617349ee99f7192e1603f9" + }, + { + "path": "oracle/mixed_high_indegree-float32/proxy-validation.json", + "bytes": 774, + "sha256": "87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09" + }, + { + "path": "oracle/mixed_high_indegree-float32/state.npz", + "bytes": 200700, + "sha256": "5df4b542b303e747bbbfbdb057da15e522465e54d6617349ee99f7192e1603f9" + }, + { + "path": "oracle/mixed_high_indegree-float32/summary.json", + "bytes": 599, + "sha256": "2984b25862d977a9158164931e10f987fc6eb9364e2ab714df1c3c3fe45af415" + }, + { + "path": "oracle/mixed_high_indegree-float32/unwrapped-audit/coefficients.json", + "bytes": 2329, + "sha256": "ec5e4c7e313291d044a1447c276582cbb16ade5cc052675bd83c1016a924942e" + }, + { + "path": "oracle/mixed_high_indegree-float32/unwrapped-audit/compiled-code.json", + "bytes": 11038, + "sha256": "9ef07e82240727c9761386ecdd054475050156677e9b0a3a6bc37b845c1f602c" + }, + { + "path": "oracle/mixed_high_indegree-float32/unwrapped-audit/completeness.csv", + "bytes": 1188, + "sha256": "1f01bd89fa27a1fc11336336d420c1100171017febe074713369fcf51db27363" + }, + { + "path": "oracle/mixed_high_indegree-float32/unwrapped-audit/connectivity.parquet", + "bytes": 9264, + "sha256": "21e51e4ecca6476d5116cfbf140b1fdd5a4a0a8ee976158f801dee8003f91ae2" + }, + { + "path": "oracle/mixed_high_indegree-float32/unwrapped-audit/generated-code.json", + "bytes": 11050, + "sha256": "0711324a1fd18d75f5b243deba0dae9dd992aa54ecd12d5727b91331c1d7faf0" + }, + { + "path": "oracle/mixed_high_indegree-float32/unwrapped-audit/input-audit.json", + "bytes": 1237, + "sha256": "ce31b2c18c0c434c9d09ad8428945de9db815145d7cd97ac6cf64c8319830ddd" + }, + { + "path": "oracle/mixed_high_indegree-float32/unwrapped-audit/queue-audit.json", + "bytes": 371, + "sha256": "33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7" + }, + { + "path": "oracle/mixed_high_indegree-float32/unwrapped-audit/schedule.json", + "bytes": 1411, + "sha256": "af9f8f7b182f3c780b23e1448888728ad89be2bbaf7ebe5631d6bff7c7ae77db" + }, + { + "path": "oracle/mixed_high_indegree-float32/unwrapped-audit/state.npz", + "bytes": 200294, + "sha256": "1c75ca2a973cb569e5c65984e277c3f5feddbc99643ef50d7fcb844fe00780d4" + }, + { + "path": "oracle/mixed_high_indegree-float64/case.json", + "bytes": 1711, + "sha256": "73216eb4215f0caa690415f883ee1d1edafbab28701a1c0b2dfa0efc6202c622" + }, + { + "path": "oracle/mixed_high_indegree-float64/coefficients.json", + "bytes": 2329, + "sha256": "5e605becd694eac6bfd450c8590626dce715dc0de442c3e98272567a81503e12" + }, + { + "path": "oracle/mixed_high_indegree-float64/environment.json", + "bytes": 352, + "sha256": "8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6" + }, + { + "path": "oracle/mixed_high_indegree-float64/instrumented/coefficients.json", + "bytes": 2329, + "sha256": "5e605becd694eac6bfd450c8590626dce715dc0de442c3e98272567a81503e12" + }, + { + "path": "oracle/mixed_high_indegree-float64/instrumented/compiled-code.json", + "bytes": 11202, + "sha256": "d37bbac320791543bdc13106f71c8aab50c345ca93aeee06d49ce26131e5e198" + }, + { + "path": "oracle/mixed_high_indegree-float64/instrumented/completeness.csv", + "bytes": 1188, + "sha256": "1f01bd89fa27a1fc11336336d420c1100171017febe074713369fcf51db27363" + }, + { + "path": "oracle/mixed_high_indegree-float64/instrumented/connectivity.parquet", + "bytes": 9264, + "sha256": "21e51e4ecca6476d5116cfbf140b1fdd5a4a0a8ee976158f801dee8003f91ae2" + }, + { + "path": "oracle/mixed_high_indegree-float64/instrumented/generated-code.json", + "bytes": 11214, + "sha256": "c342dd96ec558d76650bc92d6e3905b2dca5f984757a65e7313eb7b5fc879d8e" + }, + { + "path": "oracle/mixed_high_indegree-float64/instrumented/input-audit.json", + "bytes": 1236, + "sha256": "2ede5c192bca9326d35a9d24ec98eb460e120684d8d25f37223afdfdcd010f2e" + }, + { + "path": "oracle/mixed_high_indegree-float64/instrumented/queue-audit.json", + "bytes": 460, + "sha256": "7dbd83f1582516800c4fa4fc7f4a843bf72cff4666556177a42aea474dd0f720" + }, + { + "path": "oracle/mixed_high_indegree-float64/instrumented/schedule.json", + "bytes": 1574, + "sha256": "0db2d5f73709934bf7a91db2908a8dc3301614d09490769bf369aad96ee4f0fb" + }, + { + "path": "oracle/mixed_high_indegree-float64/instrumented/state.npz", + "bytes": 326737, + "sha256": "c267e765682525fce86a72d5a86eb921c2d1cef4200172cdc48d1fb41634d727" + }, + { + "path": "oracle/mixed_high_indegree-float64/proxy-validation.json", + "bytes": 774, + "sha256": "87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09" + }, + { + "path": "oracle/mixed_high_indegree-float64/state.npz", + "bytes": 326737, + "sha256": "c267e765682525fce86a72d5a86eb921c2d1cef4200172cdc48d1fb41634d727" + }, + { + "path": "oracle/mixed_high_indegree-float64/summary.json", + "bytes": 599, + "sha256": "d7e89190cf331bd4624b12e4863a72abe6c330ba205f72e3a1adba6976d2b1e1" + }, + { + "path": "oracle/mixed_high_indegree-float64/unwrapped-audit/coefficients.json", + "bytes": 2329, + "sha256": "7cfc3cd553fcac4fe52bfa455c5f440a8e98a1a621a135500e9a4b16551f6297" + }, + { + "path": "oracle/mixed_high_indegree-float64/unwrapped-audit/compiled-code.json", + "bytes": 11038, + "sha256": "9ef07e82240727c9761386ecdd054475050156677e9b0a3a6bc37b845c1f602c" + }, + { + "path": "oracle/mixed_high_indegree-float64/unwrapped-audit/completeness.csv", + "bytes": 1188, + "sha256": "1f01bd89fa27a1fc11336336d420c1100171017febe074713369fcf51db27363" + }, + { + "path": "oracle/mixed_high_indegree-float64/unwrapped-audit/connectivity.parquet", + "bytes": 9264, + "sha256": "21e51e4ecca6476d5116cfbf140b1fdd5a4a0a8ee976158f801dee8003f91ae2" + }, + { + "path": "oracle/mixed_high_indegree-float64/unwrapped-audit/generated-code.json", + "bytes": 11050, + "sha256": "1d622ac2f0e046e2edde7dfb62b3fb7b2ce247c3324410782300eeabb1db4253" + }, + { + "path": "oracle/mixed_high_indegree-float64/unwrapped-audit/input-audit.json", + "bytes": 1237, + "sha256": "a4324de251964451d25ce4cd4bbe1a3383de9a9930108d22959ac1303655be6f" + }, + { + "path": "oracle/mixed_high_indegree-float64/unwrapped-audit/queue-audit.json", + "bytes": 371, + "sha256": "33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7" + }, + { + "path": "oracle/mixed_high_indegree-float64/unwrapped-audit/schedule.json", + "bytes": 1411, + "sha256": "af9f8f7b182f3c780b23e1448888728ad89be2bbaf7ebe5631d6bff7c7ae77db" + }, + { + "path": "oracle/mixed_high_indegree-float64/unwrapped-audit/state.npz", + "bytes": 326331, + "sha256": "a97120abc081f9adae3c66518c5375ce3831f891672204bca5707a505077359d" + }, + { + "path": "oracle/motif_feedforward-float32/case.json", + "bytes": 1244, + "sha256": "514451ef42e4a1eef22998de3fe9263d84cdc45e83771194d855859b05057eef" + }, + { + "path": "oracle/motif_feedforward-float32/coefficients.json", + "bytes": 2329, + "sha256": "ec5e4c7e313291d044a1447c276582cbb16ade5cc052675bd83c1016a924942e" + }, + { + "path": "oracle/motif_feedforward-float32/environment.json", + "bytes": 352, + "sha256": "8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6" + }, + { + "path": "oracle/motif_feedforward-float32/instrumented/coefficients.json", + "bytes": 2329, + "sha256": "ec5e4c7e313291d044a1447c276582cbb16ade5cc052675bd83c1016a924942e" + }, + { + "path": "oracle/motif_feedforward-float32/instrumented/compiled-code.json", + "bytes": 11202, + "sha256": "d37bbac320791543bdc13106f71c8aab50c345ca93aeee06d49ce26131e5e198" + }, + { + "path": "oracle/motif_feedforward-float32/instrumented/completeness.csv", + "bytes": 68, + "sha256": "301ae4572c658aa307fc998e009377e9c82467d97d66aa1ac4b3f518385ec5a5" + }, + { + "path": "oracle/motif_feedforward-float32/instrumented/connectivity.parquet", + "bytes": 4885, + "sha256": "627406997fa994afffa6c4df18cc584c43f4161b389a6669c2ceb64e5ae9dcd1" + }, + { + "path": "oracle/motif_feedforward-float32/instrumented/generated-code.json", + "bytes": 11214, + "sha256": "9587d16853d78dac3cc8193142de3210c1b2bd3eddd076e0da070cb8544ebd6a" + }, + { + "path": "oracle/motif_feedforward-float32/instrumented/input-audit.json", + "bytes": 1237, + "sha256": "7198a08c9241603eb8f0c5c89272ff19c0b8bb4ed7ecc44f3fcdd25a37224287" + }, + { + "path": "oracle/motif_feedforward-float32/instrumented/queue-audit.json", + "bytes": 458, + "sha256": "b4a57dfcb794a3168dbcc76688e07696769def8bada0bd896ddba7355a3a2fdd" + }, + { + "path": "oracle/motif_feedforward-float32/instrumented/schedule.json", + "bytes": 1574, + "sha256": "0db2d5f73709934bf7a91db2908a8dc3301614d09490769bf369aad96ee4f0fb" + }, + { + "path": "oracle/motif_feedforward-float32/instrumented/state.npz", + "bytes": 13938, + "sha256": "e24ef4caddd186832c767df704c0073253735a6bbfa4381d76a23614ef7c0f8f" + }, + { + "path": "oracle/motif_feedforward-float32/proxy-validation.json", + "bytes": 774, + "sha256": "87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09" + }, + { + "path": "oracle/motif_feedforward-float32/state.npz", + "bytes": 13938, + "sha256": "e24ef4caddd186832c767df704c0073253735a6bbfa4381d76a23614ef7c0f8f" + }, + { + "path": "oracle/motif_feedforward-float32/summary.json", + "bytes": 584, + "sha256": "ebb76b8c5795e16816072f00049b59182e6dc8b2dad826d76e65f5fbd4711f4b" + }, + { + "path": "oracle/motif_feedforward-float32/unwrapped-audit/coefficients.json", + "bytes": 2329, + "sha256": "0bf9991cf8a66dc9eed742d7e613b3f1e3ee89bf59e37080324c8f84cbd34a2d" + }, + { + "path": "oracle/motif_feedforward-float32/unwrapped-audit/compiled-code.json", + "bytes": 11038, + "sha256": "9ef07e82240727c9761386ecdd054475050156677e9b0a3a6bc37b845c1f602c" + }, + { + "path": "oracle/motif_feedforward-float32/unwrapped-audit/completeness.csv", + "bytes": 68, + "sha256": "301ae4572c658aa307fc998e009377e9c82467d97d66aa1ac4b3f518385ec5a5" + }, + { + "path": "oracle/motif_feedforward-float32/unwrapped-audit/connectivity.parquet", + "bytes": 4885, + "sha256": "627406997fa994afffa6c4df18cc584c43f4161b389a6669c2ceb64e5ae9dcd1" + }, + { + "path": "oracle/motif_feedforward-float32/unwrapped-audit/generated-code.json", + "bytes": 11050, + "sha256": "aa9a755267ea52baca9275599baef199f7a12023b030e9727821fc4ba34cfa89" + }, + { + "path": "oracle/motif_feedforward-float32/unwrapped-audit/input-audit.json", + "bytes": 1238, + "sha256": "85af6959aad3022a8db686ab9b6b295c231d88c85a3b5eeb7cde56bc09438014" + }, + { + "path": "oracle/motif_feedforward-float32/unwrapped-audit/queue-audit.json", + "bytes": 371, + "sha256": "33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7" + }, + { + "path": "oracle/motif_feedforward-float32/unwrapped-audit/schedule.json", + "bytes": 1411, + "sha256": "af9f8f7b182f3c780b23e1448888728ad89be2bbaf7ebe5631d6bff7c7ae77db" + }, + { + "path": "oracle/motif_feedforward-float32/unwrapped-audit/state.npz", + "bytes": 13919, + "sha256": "a8e37466c4d915ef75426afb21fb3ba5f373f5ba042ee25b17820da92f0fc0d3" + }, + { + "path": "oracle/motif_feedforward-float64/case.json", + "bytes": 1244, + "sha256": "9cee3048169b8298e2510b1578a762939cff01f14ff213de17e1a862b6a2362c" + }, + { + "path": "oracle/motif_feedforward-float64/coefficients.json", + "bytes": 2329, + "sha256": "7cfc3cd553fcac4fe52bfa455c5f440a8e98a1a621a135500e9a4b16551f6297" + }, + { + "path": "oracle/motif_feedforward-float64/environment.json", + "bytes": 352, + "sha256": "8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6" + }, + { + "path": "oracle/motif_feedforward-float64/instrumented/coefficients.json", + "bytes": 2329, + "sha256": "7cfc3cd553fcac4fe52bfa455c5f440a8e98a1a621a135500e9a4b16551f6297" + }, + { + "path": "oracle/motif_feedforward-float64/instrumented/compiled-code.json", + "bytes": 11202, + "sha256": "d37bbac320791543bdc13106f71c8aab50c345ca93aeee06d49ce26131e5e198" + }, + { + "path": "oracle/motif_feedforward-float64/instrumented/completeness.csv", + "bytes": 68, + "sha256": "301ae4572c658aa307fc998e009377e9c82467d97d66aa1ac4b3f518385ec5a5" + }, + { + "path": "oracle/motif_feedforward-float64/instrumented/connectivity.parquet", + "bytes": 4885, + "sha256": "627406997fa994afffa6c4df18cc584c43f4161b389a6669c2ceb64e5ae9dcd1" + }, + { + "path": "oracle/motif_feedforward-float64/instrumented/generated-code.json", + "bytes": 11214, + "sha256": "f0e4d7b069925eb0132b7ef2e8779d64cfa4eb2fabed7664222944d7338fbff6" + }, + { + "path": "oracle/motif_feedforward-float64/instrumented/input-audit.json", + "bytes": 1237, + "sha256": "df729fbad17510beab496ddd2801ecfc3aa0c17e5e3034bbdd2011a544c174c3" + }, + { + "path": "oracle/motif_feedforward-float64/instrumented/queue-audit.json", + "bytes": 458, + "sha256": "9cb637d33e2e387f22516c317c6e07f622f03b077af0dc2023e14138f0d900d1" + }, + { + "path": "oracle/motif_feedforward-float64/instrumented/schedule.json", + "bytes": 1574, + "sha256": "0db2d5f73709934bf7a91db2908a8dc3301614d09490769bf369aad96ee4f0fb" + }, + { + "path": "oracle/motif_feedforward-float64/instrumented/state.npz", + "bytes": 21577, + "sha256": "21f5487f461f02c60c8b23be2f7def85c52d54f95fd00dbcd9b5f1d16d933c3a" + }, + { + "path": "oracle/motif_feedforward-float64/proxy-validation.json", + "bytes": 774, + "sha256": "87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09" + }, + { + "path": "oracle/motif_feedforward-float64/state.npz", + "bytes": 21577, + "sha256": "21f5487f461f02c60c8b23be2f7def85c52d54f95fd00dbcd9b5f1d16d933c3a" + }, + { + "path": "oracle/motif_feedforward-float64/summary.json", + "bytes": 584, + "sha256": "6b600b1c3aca917738398e5ed03b0cc7dc4793df7c03b5a2dbdd07747e331b1f" + }, + { + "path": "oracle/motif_feedforward-float64/unwrapped-audit/coefficients.json", + "bytes": 2329, + "sha256": "ec5e4c7e313291d044a1447c276582cbb16ade5cc052675bd83c1016a924942e" + }, + { + "path": "oracle/motif_feedforward-float64/unwrapped-audit/compiled-code.json", + "bytes": 11038, + "sha256": "9ef07e82240727c9761386ecdd054475050156677e9b0a3a6bc37b845c1f602c" + }, + { + "path": "oracle/motif_feedforward-float64/unwrapped-audit/completeness.csv", + "bytes": 68, + "sha256": "301ae4572c658aa307fc998e009377e9c82467d97d66aa1ac4b3f518385ec5a5" + }, + { + "path": "oracle/motif_feedforward-float64/unwrapped-audit/connectivity.parquet", + "bytes": 4885, + "sha256": "627406997fa994afffa6c4df18cc584c43f4161b389a6669c2ceb64e5ae9dcd1" + }, + { + "path": "oracle/motif_feedforward-float64/unwrapped-audit/generated-code.json", + "bytes": 11050, + "sha256": "0711324a1fd18d75f5b243deba0dae9dd992aa54ecd12d5727b91331c1d7faf0" + }, + { + "path": "oracle/motif_feedforward-float64/unwrapped-audit/input-audit.json", + "bytes": 1238, + "sha256": "da721733ca6e25552066d11eab447b8ca7f5494fd9780f98b1a10f43d705ffef" + }, + { + "path": "oracle/motif_feedforward-float64/unwrapped-audit/queue-audit.json", + "bytes": 371, + "sha256": "33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7" + }, + { + "path": "oracle/motif_feedforward-float64/unwrapped-audit/schedule.json", + "bytes": 1411, + "sha256": "af9f8f7b182f3c780b23e1448888728ad89be2bbaf7ebe5631d6bff7c7ae77db" + }, + { + "path": "oracle/motif_feedforward-float64/unwrapped-audit/state.npz", + "bytes": 21558, + "sha256": "8afa811b03d3a51cc0a188511b0eec8d98d5d33e6e9019b44fc598bf91bb5e4b" + }, + { + "path": "oracle/motif_five-float32/case.json", + "bytes": 1237, + "sha256": "0ba654448ad73f8a7d93d026822d4847d107ebdd887e689c3d73b29355ea46b2" + }, + { + "path": "oracle/motif_five-float32/coefficients.json", + "bytes": 2335, + "sha256": "d98eee7b93f944578eebb05b33e94c2515ee82b5753af1eec756a596e7201ac6" + }, + { + "path": "oracle/motif_five-float32/environment.json", + "bytes": 352, + "sha256": "8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6" + }, + { + "path": "oracle/motif_five-float32/instrumented/coefficients.json", + "bytes": 2335, + "sha256": "d98eee7b93f944578eebb05b33e94c2515ee82b5753af1eec756a596e7201ac6" + }, + { + "path": "oracle/motif_five-float32/instrumented/compiled-code.json", + "bytes": 11202, + "sha256": "d37bbac320791543bdc13106f71c8aab50c345ca93aeee06d49ce26131e5e198" + }, + { + "path": "oracle/motif_five-float32/instrumented/completeness.csv", + "bytes": 68, + "sha256": "301ae4572c658aa307fc998e009377e9c82467d97d66aa1ac4b3f518385ec5a5" + }, + { + "path": "oracle/motif_five-float32/instrumented/connectivity.parquet", + "bytes": 5003, + "sha256": "43ea5a3c6c53315e9265863a6f05b3e6d8e9b9f299aef665e8bbe9c46f9eb2ce" + }, + { + "path": "oracle/motif_five-float32/instrumented/generated-code.json", + "bytes": 11218, + "sha256": "b5bff1e1272f13317e217bebe95a6f8b85713a59d2fcc3c81cfbdf316f56a839" + }, + { + "path": "oracle/motif_five-float32/instrumented/input-audit.json", + "bytes": 1237, + "sha256": "3ae9c6d4d215251c5f6b0386e853230174156167bcf5c684e9ff0884af12c632" + }, + { + "path": "oracle/motif_five-float32/instrumented/queue-audit.json", + "bytes": 463, + "sha256": "649034e2f1ad4fbdcbc7bc671166e16d5d742629ca65fececf8929a8c2c52e01" + }, + { + "path": "oracle/motif_five-float32/instrumented/schedule.json", + "bytes": 1574, + "sha256": "0db2d5f73709934bf7a91db2908a8dc3301614d09490769bf369aad96ee4f0fb" + }, + { + "path": "oracle/motif_five-float32/instrumented/state.npz", + "bytes": 24768, + "sha256": "3463e35fa10471d5abfd8090db1967fd5c2046364ef4e6b7974b710eb225fff2" + }, + { + "path": "oracle/motif_five-float32/proxy-validation.json", + "bytes": 774, + "sha256": "87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09" + }, + { + "path": "oracle/motif_five-float32/state.npz", + "bytes": 24768, + "sha256": "3463e35fa10471d5abfd8090db1967fd5c2046364ef4e6b7974b710eb225fff2" + }, + { + "path": "oracle/motif_five-float32/summary.json", + "bytes": 567, + "sha256": "9b650e977f4858b37ffc0884920d4143f6f9704921dd6fc1f42ec71f981eef89" + }, + { + "path": "oracle/motif_five-float32/unwrapped-audit/coefficients.json", + "bytes": 2335, + "sha256": "d01a405ef9b9be1675c66875d972578ff4c506a468388d8e980f8d449e6dc333" + }, + { + "path": "oracle/motif_five-float32/unwrapped-audit/compiled-code.json", + "bytes": 11038, + "sha256": "9ef07e82240727c9761386ecdd054475050156677e9b0a3a6bc37b845c1f602c" + }, + { + "path": "oracle/motif_five-float32/unwrapped-audit/completeness.csv", + "bytes": 68, + "sha256": "301ae4572c658aa307fc998e009377e9c82467d97d66aa1ac4b3f518385ec5a5" + }, + { + "path": "oracle/motif_five-float32/unwrapped-audit/connectivity.parquet", + "bytes": 5003, + "sha256": "43ea5a3c6c53315e9265863a6f05b3e6d8e9b9f299aef665e8bbe9c46f9eb2ce" + }, + { + "path": "oracle/motif_five-float32/unwrapped-audit/generated-code.json", + "bytes": 11054, + "sha256": "e7486df9bef2f372e8d69062750e92ff5e458d772e3b634443b3d9b66d68eccd" + }, + { + "path": "oracle/motif_five-float32/unwrapped-audit/input-audit.json", + "bytes": 1238, + "sha256": "7ef4d06198b0ce68e84e6e4c793839ead0d9d3d4e4fe573ed1b4f66e7f828a76" + }, + { + "path": "oracle/motif_five-float32/unwrapped-audit/queue-audit.json", + "bytes": 371, + "sha256": "33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7" + }, + { + "path": "oracle/motif_five-float32/unwrapped-audit/schedule.json", + "bytes": 1411, + "sha256": "af9f8f7b182f3c780b23e1448888728ad89be2bbaf7ebe5631d6bff7c7ae77db" + }, + { + "path": "oracle/motif_five-float32/unwrapped-audit/state.npz", + "bytes": 24512, + "sha256": "622ddbd3757da831e87ad713d0735c1c3a2132ccea9fa1ef62ebe09ad22a7f75" + }, + { + "path": "oracle/motif_five-float64/case.json", + "bytes": 1237, + "sha256": "02428504cba1b7275e6fab9e521d4f417b3d6125996836714347534b567afa66" + }, + { + "path": "oracle/motif_five-float64/coefficients.json", + "bytes": 2335, + "sha256": "a75717c29fc1ccf7beb7496183952821a4990365eab5b3c97c7339981903aad4" + }, + { + "path": "oracle/motif_five-float64/environment.json", + "bytes": 352, + "sha256": "8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6" + }, + { + "path": "oracle/motif_five-float64/instrumented/coefficients.json", + "bytes": 2335, + "sha256": "a75717c29fc1ccf7beb7496183952821a4990365eab5b3c97c7339981903aad4" + }, + { + "path": "oracle/motif_five-float64/instrumented/compiled-code.json", + "bytes": 11202, + "sha256": "d37bbac320791543bdc13106f71c8aab50c345ca93aeee06d49ce26131e5e198" + }, + { + "path": "oracle/motif_five-float64/instrumented/completeness.csv", + "bytes": 68, + "sha256": "301ae4572c658aa307fc998e009377e9c82467d97d66aa1ac4b3f518385ec5a5" + }, + { + "path": "oracle/motif_five-float64/instrumented/connectivity.parquet", + "bytes": 5003, + "sha256": "43ea5a3c6c53315e9265863a6f05b3e6d8e9b9f299aef665e8bbe9c46f9eb2ce" + }, + { + "path": "oracle/motif_five-float64/instrumented/generated-code.json", + "bytes": 11218, + "sha256": "c8ff56101e28a5c44128e24bef4f2b9fdb133c2f934c3c359b841dd9f309607e" + }, + { + "path": "oracle/motif_five-float64/instrumented/input-audit.json", + "bytes": 1237, + "sha256": "570ddf1c205c30f84634851ba251525855538d1b3ec9ca95227474960076d62a" + }, + { + "path": "oracle/motif_five-float64/instrumented/queue-audit.json", + "bytes": 463, + "sha256": "405762068db98becc1843db0bf506cfcfb9b3d33353ac9e4e168c0f52d9b49e7" + }, + { + "path": "oracle/motif_five-float64/instrumented/schedule.json", + "bytes": 1574, + "sha256": "0db2d5f73709934bf7a91db2908a8dc3301614d09490769bf369aad96ee4f0fb" + }, + { + "path": "oracle/motif_five-float64/instrumented/state.npz", + "bytes": 36782, + "sha256": "cf6ac75da0a75ccdd5ab6ac1b282fae8b8a07128f3e0a3f0106739348f75dfbb" + }, + { + "path": "oracle/motif_five-float64/proxy-validation.json", + "bytes": 774, + "sha256": "87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09" + }, + { + "path": "oracle/motif_five-float64/state.npz", + "bytes": 36782, + "sha256": "cf6ac75da0a75ccdd5ab6ac1b282fae8b8a07128f3e0a3f0106739348f75dfbb" + }, + { + "path": "oracle/motif_five-float64/summary.json", + "bytes": 567, + "sha256": "df9c6c8221fdaf65ea5117c650378bcf1b9d53c80c6f4b1b05481d3aa582fef9" + }, + { + "path": "oracle/motif_five-float64/unwrapped-audit/coefficients.json", + "bytes": 2329, + "sha256": "0bf9991cf8a66dc9eed742d7e613b3f1e3ee89bf59e37080324c8f84cbd34a2d" + }, + { + "path": "oracle/motif_five-float64/unwrapped-audit/compiled-code.json", + "bytes": 11038, + "sha256": "9ef07e82240727c9761386ecdd054475050156677e9b0a3a6bc37b845c1f602c" + }, + { + "path": "oracle/motif_five-float64/unwrapped-audit/completeness.csv", + "bytes": 68, + "sha256": "301ae4572c658aa307fc998e009377e9c82467d97d66aa1ac4b3f518385ec5a5" + }, + { + "path": "oracle/motif_five-float64/unwrapped-audit/connectivity.parquet", + "bytes": 5003, + "sha256": "43ea5a3c6c53315e9265863a6f05b3e6d8e9b9f299aef665e8bbe9c46f9eb2ce" + }, + { + "path": "oracle/motif_five-float64/unwrapped-audit/generated-code.json", + "bytes": 11050, + "sha256": "aa9a755267ea52baca9275599baef199f7a12023b030e9727821fc4ba34cfa89" + }, + { + "path": "oracle/motif_five-float64/unwrapped-audit/input-audit.json", + "bytes": 1238, + "sha256": "f1ca7891f879fd508bd42f8bdc919deea0c204dbaf694b3e5d7117f7a263c3d9" + }, + { + "path": "oracle/motif_five-float64/unwrapped-audit/queue-audit.json", + "bytes": 371, + "sha256": "33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7" + }, + { + "path": "oracle/motif_five-float64/unwrapped-audit/schedule.json", + "bytes": 1411, + "sha256": "af9f8f7b182f3c780b23e1448888728ad89be2bbaf7ebe5631d6bff7c7ae77db" + }, + { + "path": "oracle/motif_five-float64/unwrapped-audit/state.npz", + "bytes": 36526, + "sha256": "550f7324c5a1384084be04f24a90f9107d4452b379252b6cb7a48f9cdc393eaf" + }, + { + "path": "oracle/motif_no_input-float32/case.json", + "bytes": 1241, + "sha256": "9d179420654413ca1abfb05f22dee6cfb7d51ad2cd6eef69dffc4005c16f0fd6" + }, + { + "path": "oracle/motif_no_input-float32/coefficients.json", + "bytes": 2335, + "sha256": "de979150b8c18ea8a46a876778327a49353eb5a87e5c1d7d9cafb11c9f6d8483" + }, + { + "path": "oracle/motif_no_input-float32/environment.json", + "bytes": 352, + "sha256": "8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6" + }, + { + "path": "oracle/motif_no_input-float32/instrumented/coefficients.json", + "bytes": 2335, + "sha256": "de979150b8c18ea8a46a876778327a49353eb5a87e5c1d7d9cafb11c9f6d8483" + }, + { + "path": "oracle/motif_no_input-float32/instrumented/compiled-code.json", + "bytes": 11202, + "sha256": "d37bbac320791543bdc13106f71c8aab50c345ca93aeee06d49ce26131e5e198" + }, + { + "path": "oracle/motif_no_input-float32/instrumented/completeness.csv", + "bytes": 68, + "sha256": "301ae4572c658aa307fc998e009377e9c82467d97d66aa1ac4b3f518385ec5a5" + }, + { + "path": "oracle/motif_no_input-float32/instrumented/connectivity.parquet", + "bytes": 5003, + "sha256": "43ea5a3c6c53315e9265863a6f05b3e6d8e9b9f299aef665e8bbe9c46f9eb2ce" + }, + { + "path": "oracle/motif_no_input-float32/instrumented/generated-code.json", + "bytes": 11218, + "sha256": "e5aa1ab2a7909ec49496dbef2284053c3e1e879b11a18e0fc77e864f12501818" + }, + { + "path": "oracle/motif_no_input-float32/instrumented/input-audit.json", + "bytes": 1237, + "sha256": "3ae9c6d4d215251c5f6b0386e853230174156167bcf5c684e9ff0884af12c632" + }, + { + "path": "oracle/motif_no_input-float32/instrumented/queue-audit.json", + "bytes": 459, + "sha256": "cee965022108973f9b9da6aeb880f6eb1dfb3d75bd613658f7164784da3adb00" + }, + { + "path": "oracle/motif_no_input-float32/instrumented/schedule.json", + "bytes": 1574, + "sha256": "0db2d5f73709934bf7a91db2908a8dc3301614d09490769bf369aad96ee4f0fb" + }, + { + "path": "oracle/motif_no_input-float32/instrumented/state.npz", + "bytes": 6088, + "sha256": "fbf19ad2fa292ecfcfbf893047ed0ee1dc411fd7825f728b21147349085177ad" + }, + { + "path": "oracle/motif_no_input-float32/proxy-validation.json", + "bytes": 774, + "sha256": "87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09" + }, + { + "path": "oracle/motif_no_input-float32/state.npz", + "bytes": 6088, + "sha256": "fbf19ad2fa292ecfcfbf893047ed0ee1dc411fd7825f728b21147349085177ad" + }, + { + "path": "oracle/motif_no_input-float32/summary.json", + "bytes": 576, + "sha256": "f6714c8b34ba46595deb08f2b87623d8ffb94dbbea423d8319136948e1b2dea1" + }, + { + "path": "oracle/motif_no_input-float32/unwrapped-audit/coefficients.json", + "bytes": 2335, + "sha256": "a45521c8cc13306fa535adf1cbf9f476b88061351774660f680abf04ee65899d" + }, + { + "path": "oracle/motif_no_input-float32/unwrapped-audit/compiled-code.json", + "bytes": 11038, + "sha256": "9ef07e82240727c9761386ecdd054475050156677e9b0a3a6bc37b845c1f602c" + }, + { + "path": "oracle/motif_no_input-float32/unwrapped-audit/completeness.csv", + "bytes": 68, + "sha256": "301ae4572c658aa307fc998e009377e9c82467d97d66aa1ac4b3f518385ec5a5" + }, + { + "path": "oracle/motif_no_input-float32/unwrapped-audit/connectivity.parquet", + "bytes": 5003, + "sha256": "43ea5a3c6c53315e9265863a6f05b3e6d8e9b9f299aef665e8bbe9c46f9eb2ce" + }, + { + "path": "oracle/motif_no_input-float32/unwrapped-audit/generated-code.json", + "bytes": 11054, + "sha256": "27e213d76a91871c492e28be66c7a093fd4e1ba5920b7fd87a59f3b5ccca1b05" + }, + { + "path": "oracle/motif_no_input-float32/unwrapped-audit/input-audit.json", + "bytes": 1238, + "sha256": "7ef4d06198b0ce68e84e6e4c793839ead0d9d3d4e4fe573ed1b4f66e7f828a76" + }, + { + "path": "oracle/motif_no_input-float32/unwrapped-audit/queue-audit.json", + "bytes": 371, + "sha256": "33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7" + }, + { + "path": "oracle/motif_no_input-float32/unwrapped-audit/schedule.json", + "bytes": 1411, + "sha256": "af9f8f7b182f3c780b23e1448888728ad89be2bbaf7ebe5631d6bff7c7ae77db" + }, + { + "path": "oracle/motif_no_input-float32/unwrapped-audit/state.npz", + "bytes": 6088, + "sha256": "fbf19ad2fa292ecfcfbf893047ed0ee1dc411fd7825f728b21147349085177ad" + }, + { + "path": "oracle/motif_no_input-float64/case.json", + "bytes": 1241, + "sha256": "e09512d3a290d1b67017d8041beee4445dff7338d25ee5a419662ce0fa1e0294" + }, + { + "path": "oracle/motif_no_input-float64/coefficients.json", + "bytes": 2329, + "sha256": "0bf9991cf8a66dc9eed742d7e613b3f1e3ee89bf59e37080324c8f84cbd34a2d" + }, + { + "path": "oracle/motif_no_input-float64/environment.json", + "bytes": 352, + "sha256": "8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6" + }, + { + "path": "oracle/motif_no_input-float64/instrumented/coefficients.json", + "bytes": 2329, + "sha256": "0bf9991cf8a66dc9eed742d7e613b3f1e3ee89bf59e37080324c8f84cbd34a2d" + }, + { + "path": "oracle/motif_no_input-float64/instrumented/compiled-code.json", + "bytes": 11202, + "sha256": "d37bbac320791543bdc13106f71c8aab50c345ca93aeee06d49ce26131e5e198" + }, + { + "path": "oracle/motif_no_input-float64/instrumented/completeness.csv", + "bytes": 68, + "sha256": "301ae4572c658aa307fc998e009377e9c82467d97d66aa1ac4b3f518385ec5a5" + }, + { + "path": "oracle/motif_no_input-float64/instrumented/connectivity.parquet", + "bytes": 5003, + "sha256": "43ea5a3c6c53315e9265863a6f05b3e6d8e9b9f299aef665e8bbe9c46f9eb2ce" + }, + { + "path": "oracle/motif_no_input-float64/instrumented/generated-code.json", + "bytes": 11214, + "sha256": "e2863283352ed45e14e825141be421dc603061254dd7676cd5db972b676990a9" + }, + { + "path": "oracle/motif_no_input-float64/instrumented/input-audit.json", + "bytes": 1237, + "sha256": "570ddf1c205c30f84634851ba251525855538d1b3ec9ca95227474960076d62a" + }, + { + "path": "oracle/motif_no_input-float64/instrumented/queue-audit.json", + "bytes": 458, + "sha256": "d7d8e6eba191b4fb6a8876896c9b932e2a908e66cf6e419065d6b7f1cbeda73e" + }, + { + "path": "oracle/motif_no_input-float64/instrumented/schedule.json", + "bytes": 1574, + "sha256": "0db2d5f73709934bf7a91db2908a8dc3301614d09490769bf369aad96ee4f0fb" + }, + { + "path": "oracle/motif_no_input-float64/instrumented/state.npz", + "bytes": 6394, + "sha256": "4f8b98d81b6b91aeccdf59788e7cfa6a770fe1ac59753fa8c4777776e559fbe1" + }, + { + "path": "oracle/motif_no_input-float64/proxy-validation.json", + "bytes": 774, + "sha256": "87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09" + }, + { + "path": "oracle/motif_no_input-float64/state.npz", + "bytes": 6394, + "sha256": "4f8b98d81b6b91aeccdf59788e7cfa6a770fe1ac59753fa8c4777776e559fbe1" + }, + { + "path": "oracle/motif_no_input-float64/summary.json", + "bytes": 576, + "sha256": "5f27219565e45f42327bdf33e08d0c38373d6719f932d88454ab0bc5be7c9f7d" + }, + { + "path": "oracle/motif_no_input-float64/unwrapped-audit/coefficients.json", + "bytes": 2335, + "sha256": "d01a405ef9b9be1675c66875d972578ff4c506a468388d8e980f8d449e6dc333" + }, + { + "path": "oracle/motif_no_input-float64/unwrapped-audit/compiled-code.json", + "bytes": 11038, + "sha256": "9ef07e82240727c9761386ecdd054475050156677e9b0a3a6bc37b845c1f602c" + }, + { + "path": "oracle/motif_no_input-float64/unwrapped-audit/completeness.csv", + "bytes": 68, + "sha256": "301ae4572c658aa307fc998e009377e9c82467d97d66aa1ac4b3f518385ec5a5" + }, + { + "path": "oracle/motif_no_input-float64/unwrapped-audit/connectivity.parquet", + "bytes": 5003, + "sha256": "43ea5a3c6c53315e9265863a6f05b3e6d8e9b9f299aef665e8bbe9c46f9eb2ce" + }, + { + "path": "oracle/motif_no_input-float64/unwrapped-audit/generated-code.json", + "bytes": 11054, + "sha256": "e7486df9bef2f372e8d69062750e92ff5e458d772e3b634443b3d9b66d68eccd" + }, + { + "path": "oracle/motif_no_input-float64/unwrapped-audit/input-audit.json", + "bytes": 1238, + "sha256": "f1ca7891f879fd508bd42f8bdc919deea0c204dbaf694b3e5d7117f7a263c3d9" + }, + { + "path": "oracle/motif_no_input-float64/unwrapped-audit/queue-audit.json", + "bytes": 371, + "sha256": "33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7" + }, + { + "path": "oracle/motif_no_input-float64/unwrapped-audit/schedule.json", + "bytes": 1411, + "sha256": "af9f8f7b182f3c780b23e1448888728ad89be2bbaf7ebe5631d6bff7c7ae77db" + }, + { + "path": "oracle/motif_no_input-float64/unwrapped-audit/state.npz", + "bytes": 6394, + "sha256": "4f8b98d81b6b91aeccdf59788e7cfa6a770fe1ac59753fa8c4777776e559fbe1" + }, + { + "path": "oracle/motif_pair-float32/case.json", + "bytes": 1237, + "sha256": "7c2e51163cc02ade1ad547b0f80b72e3a2ce41e9ddbc8488c0963ae8cb8b25fd" + }, + { + "path": "oracle/motif_pair-float32/coefficients.json", + "bytes": 2335, + "sha256": "a96c603914560bec97c4da88bdc22a77ba3feaf49c83226793b258c67c856b91" + }, + { + "path": "oracle/motif_pair-float32/environment.json", + "bytes": 352, + "sha256": "8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6" + }, + { + "path": "oracle/motif_pair-float32/instrumented/coefficients.json", + "bytes": 2335, + "sha256": "a96c603914560bec97c4da88bdc22a77ba3feaf49c83226793b258c67c856b91" + }, + { + "path": "oracle/motif_pair-float32/instrumented/compiled-code.json", + "bytes": 11202, + "sha256": "d37bbac320791543bdc13106f71c8aab50c345ca93aeee06d49ce26131e5e198" + }, + { + "path": "oracle/motif_pair-float32/instrumented/completeness.csv", + "bytes": 44, + "sha256": "5af02939034e66e7a8e7c361555203906d69bbba0042b1ab549041db1626f02b" + }, + { + "path": "oracle/motif_pair-float32/instrumented/connectivity.parquet", + "bytes": 4823, + "sha256": "1072f50d478d1890de7602c48f6a7f1b89e11a665a173e7a705a5fab3b3f8771" + }, + { + "path": "oracle/motif_pair-float32/instrumented/generated-code.json", + "bytes": 11218, + "sha256": "04dd8561cbfca6932ddc94ffbf3228449a7ab8676b153db775cf1514af9f61cb" + }, + { + "path": "oracle/motif_pair-float32/instrumented/input-audit.json", + "bytes": 1237, + "sha256": "c6618376a52844263736e9dd031ff5745543d4db39d51072381d2230a9c61076" + }, + { + "path": "oracle/motif_pair-float32/instrumented/queue-audit.json", + "bytes": 461, + "sha256": "e7aade6f0cedd94c4c07fbe6eb69dbfb345cb2793bf819cc7fd995d708df83e5" + }, + { + "path": "oracle/motif_pair-float32/instrumented/schedule.json", + "bytes": 1574, + "sha256": "0db2d5f73709934bf7a91db2908a8dc3301614d09490769bf369aad96ee4f0fb" + }, + { + "path": "oracle/motif_pair-float32/instrumented/state.npz", + "bytes": 6916, + "sha256": "016d9e6cd2e38e3ac4bf5dcd4526771f30885a7152b77e703bfa6debbed047f1" + }, + { + "path": "oracle/motif_pair-float32/proxy-validation.json", + "bytes": 774, + "sha256": "87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09" + }, + { + "path": "oracle/motif_pair-float32/state.npz", + "bytes": 6916, + "sha256": "016d9e6cd2e38e3ac4bf5dcd4526771f30885a7152b77e703bfa6debbed047f1" + }, + { + "path": "oracle/motif_pair-float32/summary.json", + "bytes": 565, + "sha256": "c282c963d6a2e7c80a70aa20d339f57ea46cdb9a4c296ae1017f37c42f71a66b" + }, + { + "path": "oracle/motif_pair-float32/unwrapped-audit/coefficients.json", + "bytes": 2335, + "sha256": "7de7395618cc75c739c64aa06e9b5111270a04f6e38e4fead6f42bc9838b24d9" + }, + { + "path": "oracle/motif_pair-float32/unwrapped-audit/compiled-code.json", + "bytes": 11038, + "sha256": "9ef07e82240727c9761386ecdd054475050156677e9b0a3a6bc37b845c1f602c" + }, + { + "path": "oracle/motif_pair-float32/unwrapped-audit/completeness.csv", + "bytes": 44, + "sha256": "5af02939034e66e7a8e7c361555203906d69bbba0042b1ab549041db1626f02b" + }, + { + "path": "oracle/motif_pair-float32/unwrapped-audit/connectivity.parquet", + "bytes": 4823, + "sha256": "1072f50d478d1890de7602c48f6a7f1b89e11a665a173e7a705a5fab3b3f8771" + }, + { + "path": "oracle/motif_pair-float32/unwrapped-audit/generated-code.json", + "bytes": 11054, + "sha256": "6285bf3f565631bb13f61df1de231f6431e9dbba62c9390a770a481fecf434d4" + }, + { + "path": "oracle/motif_pair-float32/unwrapped-audit/input-audit.json", + "bytes": 1238, + "sha256": "38494b8726f5685faae5116251a91c775d036f984a7d6685d5512b8cc4730197" + }, + { + "path": "oracle/motif_pair-float32/unwrapped-audit/queue-audit.json", + "bytes": 371, + "sha256": "33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7" + }, + { + "path": "oracle/motif_pair-float32/unwrapped-audit/schedule.json", + "bytes": 1411, + "sha256": "af9f8f7b182f3c780b23e1448888728ad89be2bbaf7ebe5631d6bff7c7ae77db" + }, + { + "path": "oracle/motif_pair-float32/unwrapped-audit/state.npz", + "bytes": 6841, + "sha256": "4e4306501322819a9124639ca42a8563deb5e6b8d4a32bd076e50304b3ac890f" + }, + { + "path": "oracle/motif_pair-float64/case.json", + "bytes": 1237, + "sha256": "2c3139962eace310ec0592d1e507efc799658ea0fcdde723c5238e5af214915f" + }, + { + "path": "oracle/motif_pair-float64/coefficients.json", + "bytes": 2335, + "sha256": "d01a405ef9b9be1675c66875d972578ff4c506a468388d8e980f8d449e6dc333" + }, + { + "path": "oracle/motif_pair-float64/environment.json", + "bytes": 352, + "sha256": "8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6" + }, + { + "path": "oracle/motif_pair-float64/instrumented/coefficients.json", + "bytes": 2335, + "sha256": "d01a405ef9b9be1675c66875d972578ff4c506a468388d8e980f8d449e6dc333" + }, + { + "path": "oracle/motif_pair-float64/instrumented/compiled-code.json", + "bytes": 11202, + "sha256": "d37bbac320791543bdc13106f71c8aab50c345ca93aeee06d49ce26131e5e198" + }, + { + "path": "oracle/motif_pair-float64/instrumented/completeness.csv", + "bytes": 44, + "sha256": "5af02939034e66e7a8e7c361555203906d69bbba0042b1ab549041db1626f02b" + }, + { + "path": "oracle/motif_pair-float64/instrumented/connectivity.parquet", + "bytes": 4823, + "sha256": "1072f50d478d1890de7602c48f6a7f1b89e11a665a173e7a705a5fab3b3f8771" + }, + { + "path": "oracle/motif_pair-float64/instrumented/generated-code.json", + "bytes": 11218, + "sha256": "6218cb7a5561987d8a5f4b50df6b8ab178f97d9c8a3b0c2281592030323d19ad" + }, + { + "path": "oracle/motif_pair-float64/instrumented/input-audit.json", + "bytes": 1237, + "sha256": "05822e9cca61f7cf9b21e6eb6334e39c783e94d260cb526ac42fd17da4a55bae" + }, + { + "path": "oracle/motif_pair-float64/instrumented/queue-audit.json", + "bytes": 461, + "sha256": "f20253a8c675f99d0b51612f0faa6ffe968e63f6059b7e0f865d4730de411d75" + }, + { + "path": "oracle/motif_pair-float64/instrumented/schedule.json", + "bytes": 1574, + "sha256": "0db2d5f73709934bf7a91db2908a8dc3301614d09490769bf369aad96ee4f0fb" + }, + { + "path": "oracle/motif_pair-float64/instrumented/state.npz", + "bytes": 7627, + "sha256": "236fcb984139a2e376b026fe33e5fb079a1c3a9a4f1090925fbe2643c92fa31b" + }, + { + "path": "oracle/motif_pair-float64/proxy-validation.json", + "bytes": 774, + "sha256": "87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09" + }, + { + "path": "oracle/motif_pair-float64/state.npz", + "bytes": 7627, + "sha256": "236fcb984139a2e376b026fe33e5fb079a1c3a9a4f1090925fbe2643c92fa31b" + }, + { + "path": "oracle/motif_pair-float64/summary.json", + "bytes": 565, + "sha256": "d31801b7409b61b11c039dcedb57695447c170d280ff6bae80836a70710eb9d9" + }, + { + "path": "oracle/motif_pair-float64/unwrapped-audit/coefficients.json", + "bytes": 2335, + "sha256": "a45521c8cc13306fa535adf1cbf9f476b88061351774660f680abf04ee65899d" + }, + { + "path": "oracle/motif_pair-float64/unwrapped-audit/compiled-code.json", + "bytes": 11038, + "sha256": "9ef07e82240727c9761386ecdd054475050156677e9b0a3a6bc37b845c1f602c" + }, + { + "path": "oracle/motif_pair-float64/unwrapped-audit/completeness.csv", + "bytes": 44, + "sha256": "5af02939034e66e7a8e7c361555203906d69bbba0042b1ab549041db1626f02b" + }, + { + "path": "oracle/motif_pair-float64/unwrapped-audit/connectivity.parquet", + "bytes": 4823, + "sha256": "1072f50d478d1890de7602c48f6a7f1b89e11a665a173e7a705a5fab3b3f8771" + }, + { + "path": "oracle/motif_pair-float64/unwrapped-audit/generated-code.json", + "bytes": 11054, + "sha256": "27e213d76a91871c492e28be66c7a093fd4e1ba5920b7fd87a59f3b5ccca1b05" + }, + { + "path": "oracle/motif_pair-float64/unwrapped-audit/input-audit.json", + "bytes": 1238, + "sha256": "5ad9da04ebc86c451a2dc3ee1ae515048da3d0517a2772766e948be58a87cf9e" + }, + { + "path": "oracle/motif_pair-float64/unwrapped-audit/queue-audit.json", + "bytes": 371, + "sha256": "33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7" + }, + { + "path": "oracle/motif_pair-float64/unwrapped-audit/schedule.json", + "bytes": 1411, + "sha256": "af9f8f7b182f3c780b23e1448888728ad89be2bbaf7ebe5631d6bff7c7ae77db" + }, + { + "path": "oracle/motif_pair-float64/unwrapped-audit/state.npz", + "bytes": 7552, + "sha256": "beb3ee5242eacc3f92c611b02bd9a987f83c130305e97a2af8d0ea9a6e4d546f" + }, + { + "path": "oracle/motif_trio-float32/case.json", + "bytes": 1237, + "sha256": "a8cfb8d4d18e0619d6da058dae7e8488e22eaf1c78d79e30b7950cef9805392e" + }, + { + "path": "oracle/motif_trio-float32/coefficients.json", + "bytes": 2335, + "sha256": "7c1b1089b738c3acbca361d026af0818c2bedd1058226a4b1613107835f7e063" + }, + { + "path": "oracle/motif_trio-float32/environment.json", + "bytes": 352, + "sha256": "8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6" + }, + { + "path": "oracle/motif_trio-float32/instrumented/coefficients.json", + "bytes": 2335, + "sha256": "7c1b1089b738c3acbca361d026af0818c2bedd1058226a4b1613107835f7e063" + }, + { + "path": "oracle/motif_trio-float32/instrumented/compiled-code.json", + "bytes": 11202, + "sha256": "d37bbac320791543bdc13106f71c8aab50c345ca93aeee06d49ce26131e5e198" + }, + { + "path": "oracle/motif_trio-float32/instrumented/completeness.csv", + "bytes": 51, + "sha256": "e8795d5efb2eebefaae419c6df6d18d3cea3c390d9df7987f55823f5a860169e" + }, + { + "path": "oracle/motif_trio-float32/instrumented/connectivity.parquet", + "bytes": 4889, + "sha256": "22570cdceb09128d4bde46fd75897af776f7d91d89b8581d13133f55779f1e91" + }, + { + "path": "oracle/motif_trio-float32/instrumented/generated-code.json", + "bytes": 11218, + "sha256": "8c8e0ef283417f030223be90143fe431a2e55c00e197ccfb42a603bcb8e0ac6d" + }, + { + "path": "oracle/motif_trio-float32/instrumented/input-audit.json", + "bytes": 1237, + "sha256": "aeb9de630a338539ef77e631d6fad439b8c8bac45f72c9b1ea5a746762f1478e" + }, + { + "path": "oracle/motif_trio-float32/instrumented/queue-audit.json", + "bytes": 461, + "sha256": "b4e878392aba4af8d5f54a972a0345a1e5ae61f02d3cecd84c66ee16e1c14070" + }, + { + "path": "oracle/motif_trio-float32/instrumented/schedule.json", + "bytes": 1574, + "sha256": "0db2d5f73709934bf7a91db2908a8dc3301614d09490769bf369aad96ee4f0fb" + }, + { + "path": "oracle/motif_trio-float32/instrumented/state.npz", + "bytes": 8917, + "sha256": "ce04a18d25df422285be6ee80d36c949da506ebc885a87d31e109ee3d31f292b" + }, + { + "path": "oracle/motif_trio-float32/proxy-validation.json", + "bytes": 774, + "sha256": "87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09" + }, + { + "path": "oracle/motif_trio-float32/state.npz", + "bytes": 8917, + "sha256": "ce04a18d25df422285be6ee80d36c949da506ebc885a87d31e109ee3d31f292b" + }, + { + "path": "oracle/motif_trio-float32/summary.json", + "bytes": 565, + "sha256": "d854013887eb352536cebd66f3060cb0b7d7048f170a415e56e58641d27c8be7" + }, + { + "path": "oracle/motif_trio-float32/unwrapped-audit/coefficients.json", + "bytes": 2335, + "sha256": "e93700e27b476c87d3bd9631847df5930580d588188f2d6356f8fd4278640c62" + }, + { + "path": "oracle/motif_trio-float32/unwrapped-audit/compiled-code.json", + "bytes": 11038, + "sha256": "9ef07e82240727c9761386ecdd054475050156677e9b0a3a6bc37b845c1f602c" + }, + { + "path": "oracle/motif_trio-float32/unwrapped-audit/completeness.csv", + "bytes": 51, + "sha256": "e8795d5efb2eebefaae419c6df6d18d3cea3c390d9df7987f55823f5a860169e" + }, + { + "path": "oracle/motif_trio-float32/unwrapped-audit/connectivity.parquet", + "bytes": 4889, + "sha256": "22570cdceb09128d4bde46fd75897af776f7d91d89b8581d13133f55779f1e91" + }, + { + "path": "oracle/motif_trio-float32/unwrapped-audit/generated-code.json", + "bytes": 11054, + "sha256": "9f4389a017bd872ea48ce57dce09ff7feddc58e4d3e3de3e91a485d8e4efe661" + }, + { + "path": "oracle/motif_trio-float32/unwrapped-audit/input-audit.json", + "bytes": 1238, + "sha256": "b66ee25f7bb8b96360c9c0c3b919cca442eaf90f83644e6ec7ad42f0a5644691" + }, + { + "path": "oracle/motif_trio-float32/unwrapped-audit/queue-audit.json", + "bytes": 371, + "sha256": "33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7" + }, + { + "path": "oracle/motif_trio-float32/unwrapped-audit/schedule.json", + "bytes": 1411, + "sha256": "af9f8f7b182f3c780b23e1448888728ad89be2bbaf7ebe5631d6bff7c7ae77db" + }, + { + "path": "oracle/motif_trio-float32/unwrapped-audit/state.npz", + "bytes": 8780, + "sha256": "f700680def60fd4c63c322d7cbb69b0c42083401f303510f6ea07bd3b78ada8d" + }, + { + "path": "oracle/motif_trio-float64/case.json", + "bytes": 1237, + "sha256": "a72c3e1c5887c5174e5bc1bdd488e21652c2d40e1a64c17bec055d1c33ad8163" + }, + { + "path": "oracle/motif_trio-float64/coefficients.json", + "bytes": 2335, + "sha256": "7de7395618cc75c739c64aa06e9b5111270a04f6e38e4fead6f42bc9838b24d9" + }, + { + "path": "oracle/motif_trio-float64/environment.json", + "bytes": 352, + "sha256": "8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6" + }, + { + "path": "oracle/motif_trio-float64/instrumented/coefficients.json", + "bytes": 2335, + "sha256": "7de7395618cc75c739c64aa06e9b5111270a04f6e38e4fead6f42bc9838b24d9" + }, + { + "path": "oracle/motif_trio-float64/instrumented/compiled-code.json", + "bytes": 11202, + "sha256": "d37bbac320791543bdc13106f71c8aab50c345ca93aeee06d49ce26131e5e198" + }, + { + "path": "oracle/motif_trio-float64/instrumented/completeness.csv", + "bytes": 51, + "sha256": "e8795d5efb2eebefaae419c6df6d18d3cea3c390d9df7987f55823f5a860169e" + }, + { + "path": "oracle/motif_trio-float64/instrumented/connectivity.parquet", + "bytes": 4889, + "sha256": "22570cdceb09128d4bde46fd75897af776f7d91d89b8581d13133f55779f1e91" + }, + { + "path": "oracle/motif_trio-float64/instrumented/generated-code.json", + "bytes": 11218, + "sha256": "6219a02ab212b7391b8686191afcdf1189aa04c3eb60c3d6faffe54f2130c232" + }, + { + "path": "oracle/motif_trio-float64/instrumented/input-audit.json", + "bytes": 1237, + "sha256": "dca8d6b6f6e544292d87ece37af55ea38f48e26265132984c82293a83d3a5126" + }, + { + "path": "oracle/motif_trio-float64/instrumented/queue-audit.json", + "bytes": 461, + "sha256": "29957621c31b54a95a988fe4a82363c02c7726b27778870b80dc9d63c1741c7f" + }, + { + "path": "oracle/motif_trio-float64/instrumented/schedule.json", + "bytes": 1574, + "sha256": "0db2d5f73709934bf7a91db2908a8dc3301614d09490769bf369aad96ee4f0fb" + }, + { + "path": "oracle/motif_trio-float64/instrumented/state.npz", + "bytes": 10712, + "sha256": "bf670c8bc344163408fb96baf2df5d0fab9804f134fdd9011205ff6873d2084a" + }, + { + "path": "oracle/motif_trio-float64/proxy-validation.json", + "bytes": 774, + "sha256": "87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09" + }, + { + "path": "oracle/motif_trio-float64/state.npz", + "bytes": 10712, + "sha256": "bf670c8bc344163408fb96baf2df5d0fab9804f134fdd9011205ff6873d2084a" + }, + { + "path": "oracle/motif_trio-float64/summary.json", + "bytes": 565, + "sha256": "96f65fd87b834a3b4e79be2017c42f7e28aea8588393f3ba64ef92d2c9d5e4f7" + }, + { + "path": "oracle/motif_trio-float64/unwrapped-audit/coefficients.json", + "bytes": 2335, + "sha256": "7c1b1089b738c3acbca361d026af0818c2bedd1058226a4b1613107835f7e063" + }, + { + "path": "oracle/motif_trio-float64/unwrapped-audit/compiled-code.json", + "bytes": 11038, + "sha256": "9ef07e82240727c9761386ecdd054475050156677e9b0a3a6bc37b845c1f602c" + }, + { + "path": "oracle/motif_trio-float64/unwrapped-audit/completeness.csv", + "bytes": 51, + "sha256": "e8795d5efb2eebefaae419c6df6d18d3cea3c390d9df7987f55823f5a860169e" + }, + { + "path": "oracle/motif_trio-float64/unwrapped-audit/connectivity.parquet", + "bytes": 4889, + "sha256": "22570cdceb09128d4bde46fd75897af776f7d91d89b8581d13133f55779f1e91" + }, + { + "path": "oracle/motif_trio-float64/unwrapped-audit/generated-code.json", + "bytes": 11054, + "sha256": "3dfe75cb3a716d21a5c93328ca9afebf1540f68bf873af5005720b8b41a81231" + }, + { + "path": "oracle/motif_trio-float64/unwrapped-audit/input-audit.json", + "bytes": 1238, + "sha256": "eca8ca955d53b8e6e0568c3f0020bcfd40b8b536f64f74040623dd50235c62ef" + }, + { + "path": "oracle/motif_trio-float64/unwrapped-audit/queue-audit.json", + "bytes": 371, + "sha256": "33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7" + }, + { + "path": "oracle/motif_trio-float64/unwrapped-audit/schedule.json", + "bytes": 1411, + "sha256": "af9f8f7b182f3c780b23e1448888728ad89be2bbaf7ebe5631d6bff7c7ae77db" + }, + { + "path": "oracle/motif_trio-float64/unwrapped-audit/state.npz", + "bytes": 10575, + "sha256": "40522d4509583dcad23412e017f76b76c5acc8c35069fd98ce2a20e90d85964c" + }, + { + "path": "oracle/ordered_cancellation-float32/case.json", + "bytes": 1273, + "sha256": "83987a7bbeb3dde14fac3de2f73ce9270b0be4d0d1a444212e0a42fea8099df9" + }, + { + "path": "oracle/ordered_cancellation-float32/coefficients.json", + "bytes": 2335, + "sha256": "25028e6abaf2d0674eff984499f9b03e540ea7ec39006e1792242a71a662654c" + }, + { + "path": "oracle/ordered_cancellation-float32/environment.json", + "bytes": 352, + "sha256": "8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6" + }, + { + "path": "oracle/ordered_cancellation-float32/instrumented/coefficients.json", + "bytes": 2335, + "sha256": "25028e6abaf2d0674eff984499f9b03e540ea7ec39006e1792242a71a662654c" + }, + { + "path": "oracle/ordered_cancellation-float32/instrumented/compiled-code.json", + "bytes": 11202, + "sha256": "d37bbac320791543bdc13106f71c8aab50c345ca93aeee06d49ce26131e5e198" + }, + { + "path": "oracle/ordered_cancellation-float32/instrumented/completeness.csv", + "bytes": 242, + "sha256": "d861bdcdccde99f4c49e489f5f22e274a3e810fa365d0858513d91092f6ddeed" + }, + { + "path": "oracle/ordered_cancellation-float32/instrumented/connectivity.parquet", + "bytes": 5388, + "sha256": "5fd8201a0e8f908045308387d8b87bff1efc86f643b0ab2808623110949b7923" + }, + { + "path": "oracle/ordered_cancellation-float32/instrumented/generated-code.json", + "bytes": 11218, + "sha256": "7f4e8f22ed3dcdf089914e79c574bbbb404f4eb6bb3fecca4a680e3f9d3c0857" + }, + { + "path": "oracle/ordered_cancellation-float32/instrumented/input-audit.json", + "bytes": 1236, + "sha256": "6375f3b8727a3b9023eb16a811cb2ab95ca75f0d039190faa015801f0fa472ce" + }, + { + "path": "oracle/ordered_cancellation-float32/instrumented/queue-audit.json", + "bytes": 459, + "sha256": "215e1d7357f2adbd81c2dc4e71948d1341cda30ec05ea55adc46e546c3952780" + }, + { + "path": "oracle/ordered_cancellation-float32/instrumented/schedule.json", + "bytes": 1574, + "sha256": "0db2d5f73709934bf7a91db2908a8dc3301614d09490769bf369aad96ee4f0fb" + }, + { + "path": "oracle/ordered_cancellation-float32/instrumented/state.npz", + "bytes": 7986, + "sha256": "c937b1ec1e1ec63d1f0aedd3ab91b506f745849f3b66d8223d0d831bd9a689b0" + }, + { + "path": "oracle/ordered_cancellation-float32/proxy-validation.json", + "bytes": 774, + "sha256": "87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09" + }, + { + "path": "oracle/ordered_cancellation-float32/state.npz", + "bytes": 7986, + "sha256": "c937b1ec1e1ec63d1f0aedd3ab91b506f745849f3b66d8223d0d831bd9a689b0" + }, + { + "path": "oracle/ordered_cancellation-float32/summary.json", + "bytes": 598, + "sha256": "5fde5e19bb7f3ea8bace360458c67652575827fd2f8f493cafade16537c7efcf" + }, + { + "path": "oracle/ordered_cancellation-float32/unwrapped-audit/coefficients.json", + "bytes": 2335, + "sha256": "5c7757cd44e4f994f9d1496a3533ffc3ae993d3f9327764e57183e4167a02ef6" + }, + { + "path": "oracle/ordered_cancellation-float32/unwrapped-audit/compiled-code.json", + "bytes": 11038, + "sha256": "9ef07e82240727c9761386ecdd054475050156677e9b0a3a6bc37b845c1f602c" + }, + { + "path": "oracle/ordered_cancellation-float32/unwrapped-audit/completeness.csv", + "bytes": 242, + "sha256": "d861bdcdccde99f4c49e489f5f22e274a3e810fa365d0858513d91092f6ddeed" + }, + { + "path": "oracle/ordered_cancellation-float32/unwrapped-audit/connectivity.parquet", + "bytes": 5388, + "sha256": "5fd8201a0e8f908045308387d8b87bff1efc86f643b0ab2808623110949b7923" + }, + { + "path": "oracle/ordered_cancellation-float32/unwrapped-audit/generated-code.json", + "bytes": 11054, + "sha256": "78041f723fdc221809a9202f586abfb828114e0c60101e72b8f82dbb7b349b4e" + }, + { + "path": "oracle/ordered_cancellation-float32/unwrapped-audit/input-audit.json", + "bytes": 1237, + "sha256": "853eb8557130dd59256f4d8b53ba1f104aea43f6e6d2aab68e12f2d3fced8e90" + }, + { + "path": "oracle/ordered_cancellation-float32/unwrapped-audit/queue-audit.json", + "bytes": 371, + "sha256": "33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7" + }, + { + "path": "oracle/ordered_cancellation-float32/unwrapped-audit/schedule.json", + "bytes": 1411, + "sha256": "af9f8f7b182f3c780b23e1448888728ad89be2bbaf7ebe5631d6bff7c7ae77db" + }, + { + "path": "oracle/ordered_cancellation-float32/unwrapped-audit/state.npz", + "bytes": 7900, + "sha256": "527d40df651506784cab1224749b43a68d7faf08addd6ed0d621f72bc614bc5b" + }, + { + "path": "oracle/ordered_cancellation-float64/case.json", + "bytes": 1273, + "sha256": "42a5b1bd97192138c1aa231a7cc200fb4cd50e2eaf71ca79ba50005444272761" + }, + { + "path": "oracle/ordered_cancellation-float64/coefficients.json", + "bytes": 2335, + "sha256": "e93700e27b476c87d3bd9631847df5930580d588188f2d6356f8fd4278640c62" + }, + { + "path": "oracle/ordered_cancellation-float64/environment.json", + "bytes": 352, + "sha256": "8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6" + }, + { + "path": "oracle/ordered_cancellation-float64/instrumented/coefficients.json", + "bytes": 2335, + "sha256": "e93700e27b476c87d3bd9631847df5930580d588188f2d6356f8fd4278640c62" + }, + { + "path": "oracle/ordered_cancellation-float64/instrumented/compiled-code.json", + "bytes": 11202, + "sha256": "d37bbac320791543bdc13106f71c8aab50c345ca93aeee06d49ce26131e5e198" + }, + { + "path": "oracle/ordered_cancellation-float64/instrumented/completeness.csv", + "bytes": 242, + "sha256": "d861bdcdccde99f4c49e489f5f22e274a3e810fa365d0858513d91092f6ddeed" + }, + { + "path": "oracle/ordered_cancellation-float64/instrumented/connectivity.parquet", + "bytes": 5388, + "sha256": "5fd8201a0e8f908045308387d8b87bff1efc86f643b0ab2808623110949b7923" + }, + { + "path": "oracle/ordered_cancellation-float64/instrumented/generated-code.json", + "bytes": 11218, + "sha256": "ce982dd6dd2bf6f81d608e820add84fbe611d51a6157fbae6fb2b9e1e30dd571" + }, + { + "path": "oracle/ordered_cancellation-float64/instrumented/input-audit.json", + "bytes": 1236, + "sha256": "4969d3f0ae5857d3eca879568c757e6d4b631d4fb0f90212eb5951836b41d1f3" + }, + { + "path": "oracle/ordered_cancellation-float64/instrumented/queue-audit.json", + "bytes": 459, + "sha256": "0de23642c9438c99c3c1f93efb4ee282ba55e2ebb9d04b77ae93d4a10fd92fa4" + }, + { + "path": "oracle/ordered_cancellation-float64/instrumented/schedule.json", + "bytes": 1574, + "sha256": "0db2d5f73709934bf7a91db2908a8dc3301614d09490769bf369aad96ee4f0fb" + }, + { + "path": "oracle/ordered_cancellation-float64/instrumented/state.npz", + "bytes": 9869, + "sha256": "1ad4991463a440d466ec28bc32bb35572f84b351716a8150ed6360d90d36942b" + }, + { + "path": "oracle/ordered_cancellation-float64/proxy-validation.json", + "bytes": 774, + "sha256": "87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09" + }, + { + "path": "oracle/ordered_cancellation-float64/state.npz", + "bytes": 9869, + "sha256": "1ad4991463a440d466ec28bc32bb35572f84b351716a8150ed6360d90d36942b" + }, + { + "path": "oracle/ordered_cancellation-float64/summary.json", + "bytes": 598, + "sha256": "538d114715e29bfe83252cd5ce86bdc69e416f643422d7d66bc3b9cc634a2382" + }, + { + "path": "oracle/ordered_cancellation-float64/unwrapped-audit/coefficients.json", + "bytes": 2335, + "sha256": "25028e6abaf2d0674eff984499f9b03e540ea7ec39006e1792242a71a662654c" + }, + { + "path": "oracle/ordered_cancellation-float64/unwrapped-audit/compiled-code.json", + "bytes": 11038, + "sha256": "9ef07e82240727c9761386ecdd054475050156677e9b0a3a6bc37b845c1f602c" + }, + { + "path": "oracle/ordered_cancellation-float64/unwrapped-audit/completeness.csv", + "bytes": 242, + "sha256": "d861bdcdccde99f4c49e489f5f22e274a3e810fa365d0858513d91092f6ddeed" + }, + { + "path": "oracle/ordered_cancellation-float64/unwrapped-audit/connectivity.parquet", + "bytes": 5388, + "sha256": "5fd8201a0e8f908045308387d8b87bff1efc86f643b0ab2808623110949b7923" + }, + { + "path": "oracle/ordered_cancellation-float64/unwrapped-audit/generated-code.json", + "bytes": 11054, + "sha256": "2e921b0a8d0b8be1bc83ece8d54edc08bc8e5c746c765b917f88cd3517ffea92" + }, + { + "path": "oracle/ordered_cancellation-float64/unwrapped-audit/input-audit.json", + "bytes": 1237, + "sha256": "859874145af010d744d285cf471ae9cb7f410e02666dedd15abb189ced0dd22d" + }, + { + "path": "oracle/ordered_cancellation-float64/unwrapped-audit/queue-audit.json", + "bytes": 371, + "sha256": "33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7" + }, + { + "path": "oracle/ordered_cancellation-float64/unwrapped-audit/schedule.json", + "bytes": 1411, + "sha256": "af9f8f7b182f3c780b23e1448888728ad89be2bbaf7ebe5631d6bff7c7ae77db" + }, + { + "path": "oracle/ordered_cancellation-float64/unwrapped-audit/state.npz", + "bytes": 9783, + "sha256": "eace764d5bb58f882457ddde9409230b65e99e97c52b56028cf9497d17f5a1ff" + }, + { + "path": "oracle/release_selfloop-float32/case.json", + "bytes": 1242, + "sha256": "fd295fc5ccc133bfa70d2e9f7b4d9ca839b23beb337b5fdd4183be00987c6dd4" + }, + { + "path": "oracle/release_selfloop-float32/coefficients.json", + "bytes": 2335, + "sha256": "641e4016edb1690746a62aab09485c91852d5862d25fe85dab390121fb21779f" + }, + { + "path": "oracle/release_selfloop-float32/environment.json", + "bytes": 352, + "sha256": "8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6" + }, + { + "path": "oracle/release_selfloop-float32/instrumented/coefficients.json", + "bytes": 2335, + "sha256": "641e4016edb1690746a62aab09485c91852d5862d25fe85dab390121fb21779f" + }, + { + "path": "oracle/release_selfloop-float32/instrumented/compiled-code.json", + "bytes": 14949, + "sha256": "dfbcf815d17465e4c83a54320687e77c3035c5064f6a81a11bffc5ce35ec0dd1" + }, + { + "path": "oracle/release_selfloop-float32/instrumented/completeness.csv", + "bytes": 50, + "sha256": "c79ddcee44e7786a8805ed8bd4685d8107764e5dff4952b204e5163f8630ce80" + }, + { + "path": "oracle/release_selfloop-float32/instrumented/connectivity.parquet", + "bytes": 4871, + "sha256": "7dbc19bebd51061ac3272c69fe12a7a0a0d179ab21ff6d35193070c64db310f4" + }, + { + "path": "oracle/release_selfloop-float32/instrumented/generated-code.json", + "bytes": 14969, + "sha256": "94ba0cc5f884ff7e332d1859286ba39e4bc7fa684546db29088e22a5fb96a14b" + }, + { + "path": "oracle/release_selfloop-float32/instrumented/input-audit.json", + "bytes": 1236, + "sha256": "4047c46214a2c9d06289ed7db728e2f1afa23cb1e1e9437634d4c4f56540d3a2" + }, + { + "path": "oracle/release_selfloop-float32/instrumented/queue-audit.json", + "bytes": 458, + "sha256": "40bf803d062804b7bb6ce070743fc805423f873311d8bb453d2cc5db2ea62bb3" + }, + { + "path": "oracle/release_selfloop-float32/instrumented/schedule.json", + "bytes": 1984, + "sha256": "8d5492b7968694e913d3321b10d5779137045d4689fe50ec50b1ef7637d8fc04" + }, + { + "path": "oracle/release_selfloop-float32/instrumented/state.npz", + "bytes": 7235, + "sha256": "dd8c3ac01e4d8035d94d0772efbb81948ba427f5ef66caf8d104f4819845a3cc" + }, + { + "path": "oracle/release_selfloop-float32/proxy-validation.json", + "bytes": 774, + "sha256": "87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09" + }, + { + "path": "oracle/release_selfloop-float32/state.npz", + "bytes": 7235, + "sha256": "dd8c3ac01e4d8035d94d0772efbb81948ba427f5ef66caf8d104f4819845a3cc" + }, + { + "path": "oracle/release_selfloop-float32/summary.json", + "bytes": 581, + "sha256": "979d2a0d15f9d6f746e930fa5c0eb8def666713669026b69140c65687630401e" + }, + { + "path": "oracle/release_selfloop-float32/unwrapped-audit/coefficients.json", + "bytes": 2335, + "sha256": "b31b081bcc455e5a3e29ab3c7094c020e9a4f56f47cbd108bfa12c23abb4f83a" + }, + { + "path": "oracle/release_selfloop-float32/unwrapped-audit/compiled-code.json", + "bytes": 14785, + "sha256": "82868f03604ec2a12efea07718960e3bfb1c8152950c3b6bc4fd8e1b1d46cf8d" + }, + { + "path": "oracle/release_selfloop-float32/unwrapped-audit/completeness.csv", + "bytes": 50, + "sha256": "c79ddcee44e7786a8805ed8bd4685d8107764e5dff4952b204e5163f8630ce80" + }, + { + "path": "oracle/release_selfloop-float32/unwrapped-audit/connectivity.parquet", + "bytes": 4871, + "sha256": "7dbc19bebd51061ac3272c69fe12a7a0a0d179ab21ff6d35193070c64db310f4" + }, + { + "path": "oracle/release_selfloop-float32/unwrapped-audit/generated-code.json", + "bytes": 14805, + "sha256": "7fb472acf561ca1c043f0fc3a46941cdb7846d1ca8df820a15b725ad1f144ed9" + }, + { + "path": "oracle/release_selfloop-float32/unwrapped-audit/input-audit.json", + "bytes": 1237, + "sha256": "35a01e501ae88e4350583ba961a0e67e3be2c486c2fc9c2c49905924e2bc004f" + }, + { + "path": "oracle/release_selfloop-float32/unwrapped-audit/queue-audit.json", + "bytes": 371, + "sha256": "33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7" + }, + { + "path": "oracle/release_selfloop-float32/unwrapped-audit/schedule.json", + "bytes": 1807, + "sha256": "42679bfcc102a0ec20fafe7fdf9cc82b02a0b8809931a49502ac6efd669fc9cd" + }, + { + "path": "oracle/release_selfloop-float32/unwrapped-audit/state.npz", + "bytes": 7190, + "sha256": "30310b802cec33bc1f8a2f7b01e73cc4a040714279cf7406123a896397077ad6" + }, + { + "path": "oracle/release_selfloop-float64/case.json", + "bytes": 1242, + "sha256": "6a7d03115b6dbff20bcca4708f5ffea8de006e9f091bac804e8f1d2db168220c" + }, + { + "path": "oracle/release_selfloop-float64/coefficients.json", + "bytes": 2335, + "sha256": "5c7757cd44e4f994f9d1496a3533ffc3ae993d3f9327764e57183e4167a02ef6" + }, + { + "path": "oracle/release_selfloop-float64/environment.json", + "bytes": 352, + "sha256": "8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6" + }, + { + "path": "oracle/release_selfloop-float64/instrumented/coefficients.json", + "bytes": 2335, + "sha256": "5c7757cd44e4f994f9d1496a3533ffc3ae993d3f9327764e57183e4167a02ef6" + }, + { + "path": "oracle/release_selfloop-float64/instrumented/compiled-code.json", + "bytes": 14949, + "sha256": "dfbcf815d17465e4c83a54320687e77c3035c5064f6a81a11bffc5ce35ec0dd1" + }, + { + "path": "oracle/release_selfloop-float64/instrumented/completeness.csv", + "bytes": 50, + "sha256": "c79ddcee44e7786a8805ed8bd4685d8107764e5dff4952b204e5163f8630ce80" + }, + { + "path": "oracle/release_selfloop-float64/instrumented/connectivity.parquet", + "bytes": 4871, + "sha256": "7dbc19bebd51061ac3272c69fe12a7a0a0d179ab21ff6d35193070c64db310f4" + }, + { + "path": "oracle/release_selfloop-float64/instrumented/generated-code.json", + "bytes": 14969, + "sha256": "0d51e9ee6cad7494f92e4f90c362be175b66388d4bed51c1ef14a7aba6822eee" + }, + { + "path": "oracle/release_selfloop-float64/instrumented/input-audit.json", + "bytes": 1236, + "sha256": "adcc4735605e955cc3f82c52e078c3aa0ed6a5f6134a536431efa5595af0b553" + }, + { + "path": "oracle/release_selfloop-float64/instrumented/queue-audit.json", + "bytes": 458, + "sha256": "d1b7304bec0a1b2ffd069cc04b16aa05c19aff71104ccd1fa6324ac80683c6c6" + }, + { + "path": "oracle/release_selfloop-float64/instrumented/schedule.json", + "bytes": 1984, + "sha256": "8d5492b7968694e913d3321b10d5779137045d4689fe50ec50b1ef7637d8fc04" + }, + { + "path": "oracle/release_selfloop-float64/instrumented/state.npz", + "bytes": 8041, + "sha256": "2615645c5ae1bea1d9ba279c6639e35209907e4e103db6d10c05ad23dc11919d" + }, + { + "path": "oracle/release_selfloop-float64/proxy-validation.json", + "bytes": 774, + "sha256": "87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09" + }, + { + "path": "oracle/release_selfloop-float64/state.npz", + "bytes": 8041, + "sha256": "2615645c5ae1bea1d9ba279c6639e35209907e4e103db6d10c05ad23dc11919d" + }, + { + "path": "oracle/release_selfloop-float64/summary.json", + "bytes": 581, + "sha256": "4312b4466d22b9ea9d4e797dee7ffece32356d0483a12e6886df48a4b68a83a9" + }, + { + "path": "oracle/release_selfloop-float64/unwrapped-audit/coefficients.json", + "bytes": 2335, + "sha256": "641e4016edb1690746a62aab09485c91852d5862d25fe85dab390121fb21779f" + }, + { + "path": "oracle/release_selfloop-float64/unwrapped-audit/compiled-code.json", + "bytes": 14785, + "sha256": "82868f03604ec2a12efea07718960e3bfb1c8152950c3b6bc4fd8e1b1d46cf8d" + }, + { + "path": "oracle/release_selfloop-float64/unwrapped-audit/completeness.csv", + "bytes": 50, + "sha256": "c79ddcee44e7786a8805ed8bd4685d8107764e5dff4952b204e5163f8630ce80" + }, + { + "path": "oracle/release_selfloop-float64/unwrapped-audit/connectivity.parquet", + "bytes": 4871, + "sha256": "7dbc19bebd51061ac3272c69fe12a7a0a0d179ab21ff6d35193070c64db310f4" + }, + { + "path": "oracle/release_selfloop-float64/unwrapped-audit/generated-code.json", + "bytes": 14805, + "sha256": "59f811addd08ca9edd87e10f52560ea5c7fffcfcb3fe809b2a35222b73788586" + }, + { + "path": "oracle/release_selfloop-float64/unwrapped-audit/input-audit.json", + "bytes": 1237, + "sha256": "149bcf4eccdde513b08be26169d1fb502a65436ec56b8bdabb0c36be4bab1949" + }, + { + "path": "oracle/release_selfloop-float64/unwrapped-audit/queue-audit.json", + "bytes": 371, + "sha256": "33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7" + }, + { + "path": "oracle/release_selfloop-float64/unwrapped-audit/schedule.json", + "bytes": 1807, + "sha256": "42679bfcc102a0ec20fafe7fdf9cc82b02a0b8809931a49502ac6efd669fc9cd" + }, + { + "path": "oracle/release_selfloop-float64/unwrapped-audit/state.npz", + "bytes": 7996, + "sha256": "e49aacc647ff1b1c42eeb7d8b25b797c2b2bcef4a2a3b9c1e7e78945e87fe65e" + }, + { + "path": "oracle/signed_random-float32/case.json", + "bytes": 1275, + "sha256": "41ffb65d2bb6c0cbce029a2bcc9c13a3d9cdd26bd1d2c38cad0f02d71ca33ad9" + }, + { + "path": "oracle/signed_random-float32/coefficients.json", + "bytes": 2335, + "sha256": "b31b081bcc455e5a3e29ab3c7094c020e9a4f56f47cbd108bfa12c23abb4f83a" + }, + { + "path": "oracle/signed_random-float32/environment.json", + "bytes": 352, + "sha256": "8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6" + }, + { + "path": "oracle/signed_random-float32/instrumented/coefficients.json", + "bytes": 2335, + "sha256": "b31b081bcc455e5a3e29ab3c7094c020e9a4f56f47cbd108bfa12c23abb4f83a" + }, + { + "path": "oracle/signed_random-float32/instrumented/compiled-code.json", + "bytes": 14949, + "sha256": "dfbcf815d17465e4c83a54320687e77c3035c5064f6a81a11bffc5ce35ec0dd1" + }, + { + "path": "oracle/signed_random-float32/instrumented/completeness.csv", + "bytes": 964, + "sha256": "847d1cf9168f7309567f41a98b9258003eb1174f46d3b61f19fab79c8a629c4f" + }, + { + "path": "oracle/signed_random-float32/instrumented/connectivity.parquet", + "bytes": 18557, + "sha256": "8e5386c56312953312d0aaef7f5d816544d859fbe66b0583ddcc2093f33c062d" + }, + { + "path": "oracle/signed_random-float32/instrumented/generated-code.json", + "bytes": 14969, + "sha256": "a1fc01a10b78668091c0e85a41fe5e090b886631237f155dc7e2203f12a86a2f" + }, + { + "path": "oracle/signed_random-float32/instrumented/input-audit.json", + "bytes": 1236, + "sha256": "1e75500b3d33a04cb3ebdb8978dec818f5c609e3528ed896b76225b461bed4c8" + }, + { + "path": "oracle/signed_random-float32/instrumented/queue-audit.json", + "bytes": 463, + "sha256": "632d60b3927ca573c01d427658b25d3a7c5b8dab6a95957e29ea5512ccf40c45" + }, + { + "path": "oracle/signed_random-float32/instrumented/schedule.json", + "bytes": 1984, + "sha256": "8d5492b7968694e913d3321b10d5779137045d4689fe50ec50b1ef7637d8fc04" + }, + { + "path": "oracle/signed_random-float32/instrumented/state.npz", + "bytes": 374635, + "sha256": "8657a63c2ea9703b8e37b0339eb63c24f31c597cf20cf214bb5e088312489d4a" + }, + { + "path": "oracle/signed_random-float32/proxy-validation.json", + "bytes": 774, + "sha256": "87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09" + }, + { + "path": "oracle/signed_random-float32/state.npz", + "bytes": 374635, + "sha256": "8657a63c2ea9703b8e37b0339eb63c24f31c597cf20cf214bb5e088312489d4a" + }, + { + "path": "oracle/signed_random-float32/summary.json", + "bytes": 583, + "sha256": "1b09126a1c80ec7e1239ebbc5ba7e8654644e091a9f4d1f86ef5fe1bea7942c1" + }, + { + "path": "oracle/signed_random-float32/unwrapped-audit/coefficients.json", + "bytes": 2335, + "sha256": "d87699f97f7e1c60379593c077990e8267d55c01a4b87c62a754764b3c67edde" + }, + { + "path": "oracle/signed_random-float32/unwrapped-audit/compiled-code.json", + "bytes": 14785, + "sha256": "82868f03604ec2a12efea07718960e3bfb1c8152950c3b6bc4fd8e1b1d46cf8d" + }, + { + "path": "oracle/signed_random-float32/unwrapped-audit/completeness.csv", + "bytes": 964, + "sha256": "847d1cf9168f7309567f41a98b9258003eb1174f46d3b61f19fab79c8a629c4f" + }, + { + "path": "oracle/signed_random-float32/unwrapped-audit/connectivity.parquet", + "bytes": 18557, + "sha256": "8e5386c56312953312d0aaef7f5d816544d859fbe66b0583ddcc2093f33c062d" + }, + { + "path": "oracle/signed_random-float32/unwrapped-audit/generated-code.json", + "bytes": 14805, + "sha256": "4392e7f76087a91d08e8143261cb912d5489dcccfb0bd8b2f6edb9759f24b119" + }, + { + "path": "oracle/signed_random-float32/unwrapped-audit/input-audit.json", + "bytes": 1237, + "sha256": "55acf52e153a3c1427954dab23d11d2b5de39b842d56b302b744f40b5300093f" + }, + { + "path": "oracle/signed_random-float32/unwrapped-audit/queue-audit.json", + "bytes": 371, + "sha256": "33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7" + }, + { + "path": "oracle/signed_random-float32/unwrapped-audit/schedule.json", + "bytes": 1807, + "sha256": "42679bfcc102a0ec20fafe7fdf9cc82b02a0b8809931a49502ac6efd669fc9cd" + }, + { + "path": "oracle/signed_random-float32/unwrapped-audit/state.npz", + "bytes": 371413, + "sha256": "217adfa0e6236f4213fb9c8ccdc3263e5cf73e1e65b9799b1feaabaf35dbfc00" + }, + { + "path": "oracle/signed_random-float64/case.json", + "bytes": 1275, + "sha256": "3a998345bf8746c0e2229574005dc64647a9911ed54e3db709d01e0c5400db50" + }, + { + "path": "oracle/signed_random-float64/coefficients.json", + "bytes": 2335, + "sha256": "18c982eeea655a6efb2ab684941ed13dcbea4cf8bf5add0bde564e1991c46918" + }, + { + "path": "oracle/signed_random-float64/environment.json", + "bytes": 352, + "sha256": "8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6" + }, + { + "path": "oracle/signed_random-float64/instrumented/coefficients.json", + "bytes": 2335, + "sha256": "18c982eeea655a6efb2ab684941ed13dcbea4cf8bf5add0bde564e1991c46918" + }, + { + "path": "oracle/signed_random-float64/instrumented/compiled-code.json", + "bytes": 14949, + "sha256": "dfbcf815d17465e4c83a54320687e77c3035c5064f6a81a11bffc5ce35ec0dd1" + }, + { + "path": "oracle/signed_random-float64/instrumented/completeness.csv", + "bytes": 964, + "sha256": "847d1cf9168f7309567f41a98b9258003eb1174f46d3b61f19fab79c8a629c4f" + }, + { + "path": "oracle/signed_random-float64/instrumented/connectivity.parquet", + "bytes": 18557, + "sha256": "8e5386c56312953312d0aaef7f5d816544d859fbe66b0583ddcc2093f33c062d" + }, + { + "path": "oracle/signed_random-float64/instrumented/generated-code.json", + "bytes": 14969, + "sha256": "016c7778c92643344b85c0d4a02c4a3596e8fd96bef364b074d3bca217268b40" + }, + { + "path": "oracle/signed_random-float64/instrumented/input-audit.json", + "bytes": 1236, + "sha256": "5c0283e72857d6b597fae4b7ae6e170a49b578c249ab61297b0abcb3a3dd08d2" + }, + { + "path": "oracle/signed_random-float64/instrumented/queue-audit.json", + "bytes": 463, + "sha256": "20a4213741e9ef87ab021f779e259129a49e89708d44c74717dc284b90264c52" + }, + { + "path": "oracle/signed_random-float64/instrumented/schedule.json", + "bytes": 1984, + "sha256": "8d5492b7968694e913d3321b10d5779137045d4689fe50ec50b1ef7637d8fc04" + }, + { + "path": "oracle/signed_random-float64/instrumented/state.npz", + "bytes": 697559, + "sha256": "148f6098bb58c952afe07b680a79355091cfb7d6c21e2fc49fc4c902a191cafd" + }, + { + "path": "oracle/signed_random-float64/proxy-validation.json", + "bytes": 774, + "sha256": "87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09" + }, + { + "path": "oracle/signed_random-float64/state.npz", + "bytes": 697559, + "sha256": "148f6098bb58c952afe07b680a79355091cfb7d6c21e2fc49fc4c902a191cafd" + }, + { + "path": "oracle/signed_random-float64/summary.json", + "bytes": 583, + "sha256": "c6ab83e4fe4b7758f74af24407a1df22f1283115d561e410c4ffda58e4fcc0d7" + }, + { + "path": "oracle/signed_random-float64/unwrapped-audit/coefficients.json", + "bytes": 2335, + "sha256": "d87699f97f7e1c60379593c077990e8267d55c01a4b87c62a754764b3c67edde" + }, + { + "path": "oracle/signed_random-float64/unwrapped-audit/compiled-code.json", + "bytes": 14785, + "sha256": "82868f03604ec2a12efea07718960e3bfb1c8152950c3b6bc4fd8e1b1d46cf8d" + }, + { + "path": "oracle/signed_random-float64/unwrapped-audit/completeness.csv", + "bytes": 964, + "sha256": "847d1cf9168f7309567f41a98b9258003eb1174f46d3b61f19fab79c8a629c4f" + }, + { + "path": "oracle/signed_random-float64/unwrapped-audit/connectivity.parquet", + "bytes": 18557, + "sha256": "8e5386c56312953312d0aaef7f5d816544d859fbe66b0583ddcc2093f33c062d" + }, + { + "path": "oracle/signed_random-float64/unwrapped-audit/generated-code.json", + "bytes": 14805, + "sha256": "89c9d663e1a33f36044a05d58ca417669c3d4a8746b2580127e75778a991711d" + }, + { + "path": "oracle/signed_random-float64/unwrapped-audit/input-audit.json", + "bytes": 1237, + "sha256": "0bbea9b06c74e659398f117e2a3d9c444d3e16fcf8ce9c2042cdc09d99318e4c" + }, + { + "path": "oracle/signed_random-float64/unwrapped-audit/queue-audit.json", + "bytes": 371, + "sha256": "33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7" + }, + { + "path": "oracle/signed_random-float64/unwrapped-audit/schedule.json", + "bytes": 1807, + "sha256": "42679bfcc102a0ec20fafe7fdf9cc82b02a0b8809931a49502ac6efd669fc9cd" + }, + { + "path": "oracle/signed_random-float64/unwrapped-audit/state.npz", + "bytes": 694337, + "sha256": "e516f877a467296ef6139dbd7442a5db5c3b4befa5fee0b3c5e258515f54a092" + }, + { + "path": "oracle/threshold_rounding-float32/case.json", + "bytes": 1281, + "sha256": "a5eb5baa4ca36263c75f80c348dd444836241cd270598ca660a9a4176557eb8c" + }, + { + "path": "oracle/threshold_rounding-float32/coefficients.json", + "bytes": 2335, + "sha256": "c463f321c25ce79fbb95756ca3fcc8b4b9e2b36a31ce074439b6a45d0641fcff" + }, + { + "path": "oracle/threshold_rounding-float32/environment.json", + "bytes": 352, + "sha256": "8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6" + }, + { + "path": "oracle/threshold_rounding-float32/instrumented/coefficients.json", + "bytes": 2335, + "sha256": "c463f321c25ce79fbb95756ca3fcc8b4b9e2b36a31ce074439b6a45d0641fcff" + }, + { + "path": "oracle/threshold_rounding-float32/instrumented/compiled-code.json", + "bytes": 11202, + "sha256": "d37bbac320791543bdc13106f71c8aab50c345ca93aeee06d49ce26131e5e198" + }, + { + "path": "oracle/threshold_rounding-float32/instrumented/completeness.csv", + "bytes": 81, + "sha256": "c391cd11c54130ce647d85f3b175256f1bfc2d5b50601ede4231cb7038cea401" + }, + { + "path": "oracle/threshold_rounding-float32/instrumented/connectivity.parquet", + "bytes": 4791, + "sha256": "abf150cbffed88d715f9282ad1f63a27652af8cef3e672bfbdaaa1f072a27355" + }, + { + "path": "oracle/threshold_rounding-float32/instrumented/generated-code.json", + "bytes": 11218, + "sha256": "80aba5afd83fd57e943ad930e58d25290488f32c47d1cfc6d807130462e0b9ee" + }, + { + "path": "oracle/threshold_rounding-float32/instrumented/input-audit.json", + "bytes": 1236, + "sha256": "61743ad6576a8d4d0dab49f2989cdf4e33bd0c6dc6205411b4b9ce446b671150" + }, + { + "path": "oracle/threshold_rounding-float32/instrumented/queue-audit.json", + "bytes": 457, + "sha256": "42db107c806b29780165845cf05e63f4e300b6c2352fa933454d5b7eef9d0f86" + }, + { + "path": "oracle/threshold_rounding-float32/instrumented/schedule.json", + "bytes": 1574, + "sha256": "0db2d5f73709934bf7a91db2908a8dc3301614d09490769bf369aad96ee4f0fb" + }, + { + "path": "oracle/threshold_rounding-float32/instrumented/state.npz", + "bytes": 7053, + "sha256": "e225d3b95c5455cfb5f850e8fc3b3c97e99b4bd87bbfce6c2e6f764f32432a44" + }, + { + "path": "oracle/threshold_rounding-float32/proxy-validation.json", + "bytes": 774, + "sha256": "87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09" + }, + { + "path": "oracle/threshold_rounding-float32/state.npz", + "bytes": 7053, + "sha256": "e225d3b95c5455cfb5f850e8fc3b3c97e99b4bd87bbfce6c2e6f764f32432a44" + }, + { + "path": "oracle/threshold_rounding-float32/summary.json", + "bytes": 587, + "sha256": "ed9025646a6f6cbfcdb542dfd4ad700b68f3ddf6e4dca4156843b7c4658a0115" + }, + { + "path": "oracle/threshold_rounding-float32/unwrapped-audit/coefficients.json", + "bytes": 2335, + "sha256": "e034e68f3a14e480bbef791cef03d2ebb4f654675663035c0788c8d4c4fe00e2" + }, + { + "path": "oracle/threshold_rounding-float32/unwrapped-audit/compiled-code.json", + "bytes": 11038, + "sha256": "9ef07e82240727c9761386ecdd054475050156677e9b0a3a6bc37b845c1f602c" + }, + { + "path": "oracle/threshold_rounding-float32/unwrapped-audit/completeness.csv", + "bytes": 81, + "sha256": "c391cd11c54130ce647d85f3b175256f1bfc2d5b50601ede4231cb7038cea401" + }, + { + "path": "oracle/threshold_rounding-float32/unwrapped-audit/connectivity.parquet", + "bytes": 4791, + "sha256": "abf150cbffed88d715f9282ad1f63a27652af8cef3e672bfbdaaa1f072a27355" + }, + { + "path": "oracle/threshold_rounding-float32/unwrapped-audit/generated-code.json", + "bytes": 11054, + "sha256": "5dba98727c043059d343a65c895990307c5e34cfe1d17d7f6a439a21cba5bf7c" + }, + { + "path": "oracle/threshold_rounding-float32/unwrapped-audit/input-audit.json", + "bytes": 1237, + "sha256": "9ff3841577d5755a5108c77147464655b07fb9fba2879d647cd0c94f96183548" + }, + { + "path": "oracle/threshold_rounding-float32/unwrapped-audit/queue-audit.json", + "bytes": 371, + "sha256": "33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7" + }, + { + "path": "oracle/threshold_rounding-float32/unwrapped-audit/schedule.json", + "bytes": 1411, + "sha256": "af9f8f7b182f3c780b23e1448888728ad89be2bbaf7ebe5631d6bff7c7ae77db" + }, + { + "path": "oracle/threshold_rounding-float32/unwrapped-audit/state.npz", + "bytes": 7053, + "sha256": "e225d3b95c5455cfb5f850e8fc3b3c97e99b4bd87bbfce6c2e6f764f32432a44" + }, + { + "path": "oracle/threshold_rounding-float64/case.json", + "bytes": 1281, + "sha256": "f2d7a8d5a067f0356ce106def5e8e1cde709e080837cfd87844cecfc6c7df884" + }, + { + "path": "oracle/threshold_rounding-float64/coefficients.json", + "bytes": 2335, + "sha256": "d87699f97f7e1c60379593c077990e8267d55c01a4b87c62a754764b3c67edde" + }, + { + "path": "oracle/threshold_rounding-float64/environment.json", + "bytes": 352, + "sha256": "8b311324a95f9598401ccdb8037611ab10bc420acc577ee0580b5abadcff49c6" + }, + { + "path": "oracle/threshold_rounding-float64/instrumented/coefficients.json", + "bytes": 2335, + "sha256": "d87699f97f7e1c60379593c077990e8267d55c01a4b87c62a754764b3c67edde" + }, + { + "path": "oracle/threshold_rounding-float64/instrumented/compiled-code.json", + "bytes": 11202, + "sha256": "d37bbac320791543bdc13106f71c8aab50c345ca93aeee06d49ce26131e5e198" + }, + { + "path": "oracle/threshold_rounding-float64/instrumented/completeness.csv", + "bytes": 81, + "sha256": "c391cd11c54130ce647d85f3b175256f1bfc2d5b50601ede4231cb7038cea401" + }, + { + "path": "oracle/threshold_rounding-float64/instrumented/connectivity.parquet", + "bytes": 4791, + "sha256": "abf150cbffed88d715f9282ad1f63a27652af8cef3e672bfbdaaa1f072a27355" + }, + { + "path": "oracle/threshold_rounding-float64/instrumented/generated-code.json", + "bytes": 11218, + "sha256": "f8855c24be8282f84e30d36e1d94c37389f0fb3a65537b121407311c25596f6b" + }, + { + "path": "oracle/threshold_rounding-float64/instrumented/input-audit.json", + "bytes": 1236, + "sha256": "8e10d2ac7488b62aacd4de02d4a0c16605b7ea3767c5c14678ce02919f0b24f0" + }, + { + "path": "oracle/threshold_rounding-float64/instrumented/queue-audit.json", + "bytes": 457, + "sha256": "242f188267ccd2c787842ebb71e00d0eeac1c05abfb60beddc88f1ce629d46ba" + }, + { + "path": "oracle/threshold_rounding-float64/instrumented/schedule.json", + "bytes": 1574, + "sha256": "0db2d5f73709934bf7a91db2908a8dc3301614d09490769bf369aad96ee4f0fb" + }, + { + "path": "oracle/threshold_rounding-float64/instrumented/state.npz", + "bytes": 9642, + "sha256": "2b7071d125814ce8855806157f8ff5b778f554076e6ab8f2488ad99fd8b447e0" + }, + { + "path": "oracle/threshold_rounding-float64/proxy-validation.json", + "bytes": 774, + "sha256": "87b24b8ce62842b681fc7b470572025b3fdee5cd0abe66bf6404fee5136c2f09" + }, + { + "path": "oracle/threshold_rounding-float64/state.npz", + "bytes": 9642, + "sha256": "2b7071d125814ce8855806157f8ff5b778f554076e6ab8f2488ad99fd8b447e0" + }, + { + "path": "oracle/threshold_rounding-float64/summary.json", + "bytes": 587, + "sha256": "4f5705946624e474f686ce2ec300cbc743b4cf4984281bf0c28394d8af2fd9ad" + }, + { + "path": "oracle/threshold_rounding-float64/unwrapped-audit/coefficients.json", + "bytes": 2335, + "sha256": "c463f321c25ce79fbb95756ca3fcc8b4b9e2b36a31ce074439b6a45d0641fcff" + }, + { + "path": "oracle/threshold_rounding-float64/unwrapped-audit/compiled-code.json", + "bytes": 11038, + "sha256": "9ef07e82240727c9761386ecdd054475050156677e9b0a3a6bc37b845c1f602c" + }, + { + "path": "oracle/threshold_rounding-float64/unwrapped-audit/completeness.csv", + "bytes": 81, + "sha256": "c391cd11c54130ce647d85f3b175256f1bfc2d5b50601ede4231cb7038cea401" + }, + { + "path": "oracle/threshold_rounding-float64/unwrapped-audit/connectivity.parquet", + "bytes": 4791, + "sha256": "abf150cbffed88d715f9282ad1f63a27652af8cef3e672bfbdaaa1f072a27355" + }, + { + "path": "oracle/threshold_rounding-float64/unwrapped-audit/generated-code.json", + "bytes": 11054, + "sha256": "679659ac5f0f6f82d0f7e130c37d640b5ffc22211191cdf56c350929cf539c58" + }, + { + "path": "oracle/threshold_rounding-float64/unwrapped-audit/input-audit.json", + "bytes": 1237, + "sha256": "b3a74657044ee0f3dbc4190b453dc4b8d6615f9be27d94141075de1e18095fa2" + }, + { + "path": "oracle/threshold_rounding-float64/unwrapped-audit/queue-audit.json", + "bytes": 371, + "sha256": "33ba2db10e5c65015d82d88ef1d0d704d46923677e0d4f9c8242136a31c86cd7" + }, + { + "path": "oracle/threshold_rounding-float64/unwrapped-audit/schedule.json", + "bytes": 1411, + "sha256": "af9f8f7b182f3c780b23e1448888728ad89be2bbaf7ebe5631d6bff7c7ae77db" + }, + { + "path": "oracle/threshold_rounding-float64/unwrapped-audit/state.npz", + "bytes": 9642, + "sha256": "2b7071d125814ce8855806157f8ff5b778f554076e6ab8f2488ad99fd8b447e0" + }, + { + "path": "protocol/case-hashes.json", + "bytes": 3883, + "sha256": "3b0095dd04f6467323150497ac84c4d375a83f9ed3130250955eb65f8d406063" + }, + { + "path": "protocol/preregistered.json", + "bytes": 3395, + "sha256": "f2cbcbf0dd85a61a7267a7567332b00f162d42e69d655792c1bf980d3f1b7c90" + }, + { + "path": "regression/frozen-five.json", + "bytes": 1282, + "sha256": "863d7c13334f75e0dd270f1bb870c4a2d86dbf2ff7324a4146560509aab1abd0" + }, + { + "path": "regression/gpu-complete.json", + "bytes": 101768, + "sha256": "9ac57b06217a4d7d75a36a8611df398381b4313772ba39b6af0b92a0dd2cd073" + }, + { + "path": "regression/old-integrity-after.json", + "bytes": 3130, + "sha256": "c4dba5e26a96277f128887d20734705675507395755747f4af1e8a36dc36a538" + }, + { + "path": "regression/old-integrity-before.json", + "bytes": 3130, + "sha256": "c4dba5e26a96277f128887d20734705675507395755747f4af1e8a36dc36a538" + }, + { + "path": "regression/oracle-complete.json", + "bytes": 2330, + "sha256": "58f6d1c1afe4f96a82a247ae46d8a987d74cc6f59a79eded650bf24ca2a18751" + } + ] +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float32/case.json b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float32/case.json new file mode 100644 index 0000000..7274059 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float32/case.json @@ -0,0 +1,35 @@ +{ + "author_commit": "91bdd1e7dcf193f3e7ca5a8933497fcef63b7960", + "author_path": "/data/digital-drosophila/experiments/phase4ad-author-semantics/external-resources/model.py", + "author_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "case_arrays_sha256": "f3a900e9032754619549005131283cbaf87fdaa9093887a90a295589dac590fb", + "case_spec_sha256": "90850d6968a7832e415d0966b57e216a65f5ba8f63e488e497148b6525806d79", + "common_interface_preserved": true, + "learning": false, + "original_poi_interface_adopted": false, + "precision": "float32", + "spec": { + "description": "256-source signed fan-in, labelled duplicate/loop; refractory requests and external writes.", + "dt_ms": 0.1, + "duration_ms": 60.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 + }, + "name": "fanin_bursts", + "selection": null, + "steps": 600, + "trace_queue": true, + "validate_queue_proxy": true + }, + "trace_queue": true, + "validate_queue_proxy": true, + "whole_brain": false +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float32/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float32/coefficients.json new file mode 100644 index 0000000..6425957 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float32/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_2", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_2", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_2", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_2", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_2", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_2", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float32/environment.json b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float32/environment.json new file mode 100644 index 0000000..7b43f4f --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float32/environment.json @@ -0,0 +1,14 @@ +{ + "backend": "Brian2 numpy runtime", + "packages": { + "brian2": "2.5.1", + "cython": "0.29.33", + "numpy": "1.22.3", + "pandas": "1.4.3", + "pyarrow": "11.0.0", + "scipy": "1.8.1", + "sympy": "1.12" + }, + "platform": "Linux-5.15.0-194-generic-x86_64-with-glibc2.35", + "python": "3.10.12 (main, Aug 31 2026, 10:18:17) [GCC 11.4.0]" +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float32/instrumented/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float32/instrumented/coefficients.json new file mode 100644 index 0000000..6425957 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float32/instrumented/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_2", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_2", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_2", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_2", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_2", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_2", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float32/instrumented/compiled-code.json b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float32/instrumented/compiled-code.json new file mode 100644 index 0000000..759f6b7 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float32/instrumented/compiled-code.json @@ -0,0 +1,162 @@ +[ + { + "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" + }, + { + "active": true, + "code_objects": [], + "name": "zz_external_arrivals", + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "when": "thresholds" + }, + { + "abstract_code": "", + "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 _the_period = _array_zz_external_sources__period_bins[0]\n _timebin = _array_defaultclock_timestep[0]\n _n_spikes = 0\n _lastindex_before = _array_zz_external_sources__lastindex[0]\n if _the_period > 0:\n _timebin %= _the_period\n # If there is a periodicity in the SpikeGenerator, we need to reset the\n # lastindex when the period has passed\n if _lastindex_before > 0 and _array_zz_external_sources__timebins[_lastindex_before - 1] >= _timebin:\n _lastindex_before = 0\n _n_spikes = _numpy.searchsorted(_array_zz_external_sources__timebins[_lastindex_before:],\n _timebin, side='right')\n _array_zz_external_sources__lastindex[0] = _lastindex_before + _n_spikes\n _indices = _array_zz_external_sources_neuron_index[_lastindex_before:_lastindex_before+_n_spikes]\n _array_zz_external_sources__spikespace[:_n_spikes] = _indices\n _array_zz_external_sources__spikespace[-1] = _n_spikes\n", + "name": "zz_external_sources_codeobject" + } + ], + "name": "zz_external_sources", + "order": 0, + "type": "SpikeGeneratorGroup", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "when": "synapses" + }, + { + "abstract_code": "g_post += 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": "zz_external_arrivals_pre_push_spikes" + }, + { + "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_post += w\n _postsynaptic_idx = _array_zz_external_arrivals__synaptic_post[_idx]\n not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_zz_external_arrivals_w[_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": "zz_external_arrivals_pre_codeobject" + } + ], + "name": "zz_external_arrivals_pre", + "order": 0, + "type": "SynapticPathway", + "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" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + }, + { + "active": true, + "code_objects": [], + "name": "zz_oracle_queue_installer", + "order": 1000000, + "type": "QueueInstaller", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float32/instrumented/completeness.csv b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float32/instrumented/completeness.csv new file mode 100644 index 0000000..654117f --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float32/instrumented/completeness.csv @@ -0,0 +1,258 @@ +global_neuron_idx,local_index +-257,0 +-256,1 +-255,2 +-254,3 +-253,4 +-252,5 +-251,6 +-250,7 +-249,8 +-248,9 +-247,10 +-246,11 +-245,12 +-244,13 +-243,14 +-242,15 +-241,16 +-240,17 +-239,18 +-238,19 +-237,20 +-236,21 +-235,22 +-234,23 +-233,24 +-232,25 +-231,26 +-230,27 +-229,28 +-228,29 +-227,30 +-226,31 +-225,32 +-224,33 +-223,34 +-222,35 +-221,36 +-220,37 +-219,38 +-218,39 +-217,40 +-216,41 +-215,42 +-214,43 +-213,44 +-212,45 +-211,46 +-210,47 +-209,48 +-208,49 +-207,50 +-206,51 +-205,52 +-204,53 +-203,54 +-202,55 +-201,56 +-200,57 +-199,58 +-198,59 +-197,60 +-196,61 +-195,62 +-194,63 +-193,64 +-192,65 +-191,66 +-190,67 +-189,68 +-188,69 +-187,70 +-186,71 +-185,72 +-184,73 +-183,74 +-182,75 +-181,76 +-180,77 +-179,78 +-178,79 +-177,80 +-176,81 +-175,82 +-174,83 +-173,84 +-172,85 +-171,86 +-170,87 +-169,88 +-168,89 +-167,90 +-166,91 +-165,92 +-164,93 +-163,94 +-162,95 +-161,96 +-160,97 +-159,98 +-158,99 +-157,100 +-156,101 +-155,102 +-154,103 +-153,104 +-152,105 +-151,106 +-150,107 +-149,108 +-148,109 +-147,110 +-146,111 +-145,112 +-144,113 +-143,114 +-142,115 +-141,116 +-140,117 +-139,118 +-138,119 +-137,120 +-136,121 +-135,122 +-134,123 +-133,124 +-132,125 +-131,126 +-130,127 +-129,128 +-128,129 +-127,130 +-126,131 +-125,132 +-124,133 +-123,134 +-122,135 +-121,136 +-120,137 +-119,138 +-118,139 +-117,140 +-116,141 +-115,142 +-114,143 +-113,144 +-112,145 +-111,146 +-110,147 +-109,148 +-108,149 +-107,150 +-106,151 +-105,152 +-104,153 +-103,154 +-102,155 +-101,156 +-100,157 +-99,158 +-98,159 +-97,160 +-96,161 +-95,162 +-94,163 +-93,164 +-92,165 +-91,166 +-90,167 +-89,168 +-88,169 +-87,170 +-86,171 +-85,172 +-84,173 +-83,174 +-82,175 +-81,176 +-80,177 +-79,178 +-78,179 +-77,180 +-76,181 +-75,182 +-74,183 +-73,184 +-72,185 +-71,186 +-70,187 +-69,188 +-68,189 +-67,190 +-66,191 +-65,192 +-64,193 +-63,194 +-62,195 +-61,196 +-60,197 +-59,198 +-58,199 +-57,200 +-56,201 +-55,202 +-54,203 +-53,204 +-52,205 +-51,206 +-50,207 +-49,208 +-48,209 +-47,210 +-46,211 +-45,212 +-44,213 +-43,214 +-42,215 +-41,216 +-40,217 +-39,218 +-38,219 +-37,220 +-36,221 +-35,222 +-34,223 +-33,224 +-32,225 +-31,226 +-30,227 +-29,228 +-28,229 +-27,230 +-26,231 +-25,232 +-24,233 +-23,234 +-22,235 +-21,236 +-20,237 +-19,238 +-18,239 +-17,240 +-16,241 +-15,242 +-14,243 +-13,244 +-12,245 +-11,246 +-10,247 +-9,248 +-8,249 +-7,250 +-6,251 +-5,252 +-4,253 +-3,254 +-2,255 +-1,256 diff --git a/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float32/instrumented/generated-code.json b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float32/instrumented/generated-code.json new file mode 100644 index 0000000..b50d10a --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float32/instrumented/generated-code.json @@ -0,0 +1,162 @@ +[ + { + "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" + }, + { + "active": true, + "code_objects": [], + "name": "zz_external_arrivals", + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject_2" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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_2" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "when": "thresholds" + }, + { + "abstract_code": "", + "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 _the_period = _array_zz_external_sources__period_bins[0]\n _timebin = _array_defaultclock_timestep[0]\n _n_spikes = 0\n _lastindex_before = _array_zz_external_sources__lastindex[0]\n if _the_period > 0:\n _timebin %= _the_period\n # If there is a periodicity in the SpikeGenerator, we need to reset the\n # lastindex when the period has passed\n if _lastindex_before > 0 and _array_zz_external_sources__timebins[_lastindex_before - 1] >= _timebin:\n _lastindex_before = 0\n _n_spikes = _numpy.searchsorted(_array_zz_external_sources__timebins[_lastindex_before:],\n _timebin, side='right')\n _array_zz_external_sources__lastindex[0] = _lastindex_before + _n_spikes\n _indices = _array_zz_external_sources_neuron_index[_lastindex_before:_lastindex_before+_n_spikes]\n _array_zz_external_sources__spikespace[:_n_spikes] = _indices\n _array_zz_external_sources__spikespace[-1] = _n_spikes\n", + "name": "zz_external_sources_codeobject_2" + } + ], + "name": "zz_external_sources", + "order": 0, + "type": "SpikeGeneratorGroup", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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_1" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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_2" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "when": "synapses" + }, + { + "abstract_code": "g_post += 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": "zz_external_arrivals_pre_push_spikes" + }, + { + "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_post += w\n _postsynaptic_idx = _array_zz_external_arrivals__synaptic_post[_idx]\n not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_zz_external_arrivals_w[_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": "zz_external_arrivals_pre_codeobject_2" + } + ], + "name": "zz_external_arrivals_pre", + "order": 0, + "type": "SynapticPathway", + "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_2" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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_1" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + }, + { + "active": true, + "code_objects": [], + "name": "zz_oracle_queue_installer", + "order": 1000000, + "type": "QueueInstaller", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float32/instrumented/input-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float32/instrumented/input-audit.json new file mode 100644 index 0000000..174b3ed --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float32/instrumented/input-audit.json @@ -0,0 +1,48 @@ +{ + "all_neurons_keep_original_rfc": true, + "completeness_sha256": "d8163907696aec1bf853ecccbe301c50efb4abd5b1c76b9a3dfa34f0e9e36c20", + "connectivity_sha256": "87dfbd207929725101477715d0684af71971d93cb279c3e195704b2b939b3f86", + "dt_ms": 0.1, + "parameter_checks": { + "membrane_tau_ms": { + "author": 20.0, + "case": 20.0 + }, + "refractory_ms": { + "author": 2.2, + "case": 2.2 + }, + "reset_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "resting_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "synaptic_delay_ms": { + "author": 1.8, + "case": 1.8 + }, + "synaptic_tau_ms": { + "author": 5.0, + "case": 5.0 + }, + "threshold_mv": { + "author": -45.0, + "case": -45.0 + }, + "w_syn_mv_per_anatomical_synapse": { + "author": 0.275, + "case": 0.275 + } + }, + "poisson_helper_used": false, + "precision": "float32", + "queue_trace_enabled": true, + "request_interface": "before_thresholds; v=v_th+1mV only if not_refractory", + "source_parameters_modified": false, + "source_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "state_units": "SI volts, original dtype", + "steps": 600 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float32/instrumented/queue-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float32/instrumented/queue-audit.json new file mode 100644 index 0000000..cfba0e6 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float32/instrumented/queue-audit.json @@ -0,0 +1,14 @@ +{ + "accepted_due_events": 1285, + "advance_calls": 600, + "all_due_events_preserved": true, + "due_events": 1545, + "installations": [ + "default_synapses_pre_codeobject", + "default_synapses_pre_codeobject_2" + ], + "ordering": "raw anatomical queue.peek local edge-index sequence; no sorting or filtering", + "peek_calls": 600, + "proxy_contract": "peek returns original object; advance and all other methods forward unchanged", + "trace_enabled": true +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float32/instrumented/schedule.json b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float32/instrumented/schedule.json new file mode 100644 index 0000000..445ab0c --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float32/instrumented/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_common_requests (NetworkOperation) | -- | 100. us (every step) | before_thresholds | 0 | yes \ndefault_neurons_spike_thresholder (Thresholder) | default_neurons (NeuronGroup) | 100. us (every step) | thresholds | 0 | yes \nzz_external_sources (SpikeGeneratorGroup) | zz_external_sources (SpikeGeneratorGroup) | 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 \nzz_external_arrivals_pre (SynapticPathway) | zz_external_arrivals (Synapses) | 100. us (every step) | synapses | 0 | 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 \nzz_oracle_queue_installer (QueueInstaller) | -- | 100. us (every step) | end | 1000000 | yes " +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float32/proxy-validation.json b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float32/proxy-validation.json new file mode 100644 index 0000000..50c684d --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float32/proxy-validation.json @@ -0,0 +1,33 @@ +{ + "arrival_arrays_excluded": "An unwrapped queue is deliberately not observed", + "exact_arrays": { + "applicable_count": true, + "coefficients": true, + "counts": true, + "external_accepted": true, + "external_step": true, + "external_target": true, + "external_weights": true, + "fired": true, + "g": true, + "history": true, + "initial_g": true, + "initial_v": true, + "local_idx": true, + "neuron_idx": true, + "nodes": true, + "not_refractory": true, + "ref": true, + "ref_history": true, + "rejected_count": true, + "request_accepted": true, + "request_attempted": true, + "request_count": true, + "request_rejected": true, + "step": true, + "v": true, + "weights": true + }, + "pass": true, + "performed": true +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float32/summary.json b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float32/summary.json new file mode 100644 index 0000000..caf4c6a --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float32/summary.json @@ -0,0 +1,18 @@ +{ + "applicable_requests": 1537, + "coefficient_file": "/data/digital-drosophila/experiments/phase4ae-author-runtime/oracle/fanin_bursts-float32/coefficients.json", + "complete": true, + "due_arrivals": 1545, + "edges": 258, + "name": "fanin_bursts", + "nodes": 257, + "precision": "float32", + "queue_proxy_validated": true, + "queue_trace_enabled": true, + "rejected_requests": 512, + "requests": 2049, + "source_unchanged": true, + "spikes": 1539, + "state_file": "/data/digital-drosophila/experiments/phase4ae-author-runtime/oracle/fanin_bursts-float32/state.npz", + "steps": 600 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float32/unwrapped-audit/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float32/unwrapped-audit/coefficients.json new file mode 100644 index 0000000..5ca0ad6 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float32/unwrapped-audit/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_3", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_3", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_3", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_3", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_3", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_3", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float32/unwrapped-audit/compiled-code.json b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float32/unwrapped-audit/compiled-code.json new file mode 100644 index 0000000..b323fd4 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float32/unwrapped-audit/compiled-code.json @@ -0,0 +1,154 @@ +[ + { + "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" + }, + { + "active": true, + "code_objects": [], + "name": "zz_external_arrivals", + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "when": "thresholds" + }, + { + "abstract_code": "", + "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 _the_period = _array_zz_external_sources__period_bins[0]\n _timebin = _array_defaultclock_timestep[0]\n _n_spikes = 0\n _lastindex_before = _array_zz_external_sources__lastindex[0]\n if _the_period > 0:\n _timebin %= _the_period\n # If there is a periodicity in the SpikeGenerator, we need to reset the\n # lastindex when the period has passed\n if _lastindex_before > 0 and _array_zz_external_sources__timebins[_lastindex_before - 1] >= _timebin:\n _lastindex_before = 0\n _n_spikes = _numpy.searchsorted(_array_zz_external_sources__timebins[_lastindex_before:],\n _timebin, side='right')\n _array_zz_external_sources__lastindex[0] = _lastindex_before + _n_spikes\n _indices = _array_zz_external_sources_neuron_index[_lastindex_before:_lastindex_before+_n_spikes]\n _array_zz_external_sources__spikespace[:_n_spikes] = _indices\n _array_zz_external_sources__spikespace[-1] = _n_spikes\n", + "name": "zz_external_sources_codeobject" + } + ], + "name": "zz_external_sources", + "order": 0, + "type": "SpikeGeneratorGroup", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "when": "synapses" + }, + { + "abstract_code": "g_post += 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": "zz_external_arrivals_pre_push_spikes" + }, + { + "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_post += w\n _postsynaptic_idx = _array_zz_external_arrivals__synaptic_post[_idx]\n not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_zz_external_arrivals_w[_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": "zz_external_arrivals_pre_codeobject" + } + ], + "name": "zz_external_arrivals_pre", + "order": 0, + "type": "SynapticPathway", + "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" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float32/unwrapped-audit/completeness.csv b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float32/unwrapped-audit/completeness.csv new file mode 100644 index 0000000..654117f --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float32/unwrapped-audit/completeness.csv @@ -0,0 +1,258 @@ +global_neuron_idx,local_index +-257,0 +-256,1 +-255,2 +-254,3 +-253,4 +-252,5 +-251,6 +-250,7 +-249,8 +-248,9 +-247,10 +-246,11 +-245,12 +-244,13 +-243,14 +-242,15 +-241,16 +-240,17 +-239,18 +-238,19 +-237,20 +-236,21 +-235,22 +-234,23 +-233,24 +-232,25 +-231,26 +-230,27 +-229,28 +-228,29 +-227,30 +-226,31 +-225,32 +-224,33 +-223,34 +-222,35 +-221,36 +-220,37 +-219,38 +-218,39 +-217,40 +-216,41 +-215,42 +-214,43 +-213,44 +-212,45 +-211,46 +-210,47 +-209,48 +-208,49 +-207,50 +-206,51 +-205,52 +-204,53 +-203,54 +-202,55 +-201,56 +-200,57 +-199,58 +-198,59 +-197,60 +-196,61 +-195,62 +-194,63 +-193,64 +-192,65 +-191,66 +-190,67 +-189,68 +-188,69 +-187,70 +-186,71 +-185,72 +-184,73 +-183,74 +-182,75 +-181,76 +-180,77 +-179,78 +-178,79 +-177,80 +-176,81 +-175,82 +-174,83 +-173,84 +-172,85 +-171,86 +-170,87 +-169,88 +-168,89 +-167,90 +-166,91 +-165,92 +-164,93 +-163,94 +-162,95 +-161,96 +-160,97 +-159,98 +-158,99 +-157,100 +-156,101 +-155,102 +-154,103 +-153,104 +-152,105 +-151,106 +-150,107 +-149,108 +-148,109 +-147,110 +-146,111 +-145,112 +-144,113 +-143,114 +-142,115 +-141,116 +-140,117 +-139,118 +-138,119 +-137,120 +-136,121 +-135,122 +-134,123 +-133,124 +-132,125 +-131,126 +-130,127 +-129,128 +-128,129 +-127,130 +-126,131 +-125,132 +-124,133 +-123,134 +-122,135 +-121,136 +-120,137 +-119,138 +-118,139 +-117,140 +-116,141 +-115,142 +-114,143 +-113,144 +-112,145 +-111,146 +-110,147 +-109,148 +-108,149 +-107,150 +-106,151 +-105,152 +-104,153 +-103,154 +-102,155 +-101,156 +-100,157 +-99,158 +-98,159 +-97,160 +-96,161 +-95,162 +-94,163 +-93,164 +-92,165 +-91,166 +-90,167 +-89,168 +-88,169 +-87,170 +-86,171 +-85,172 +-84,173 +-83,174 +-82,175 +-81,176 +-80,177 +-79,178 +-78,179 +-77,180 +-76,181 +-75,182 +-74,183 +-73,184 +-72,185 +-71,186 +-70,187 +-69,188 +-68,189 +-67,190 +-66,191 +-65,192 +-64,193 +-63,194 +-62,195 +-61,196 +-60,197 +-59,198 +-58,199 +-57,200 +-56,201 +-55,202 +-54,203 +-53,204 +-52,205 +-51,206 +-50,207 +-49,208 +-48,209 +-47,210 +-46,211 +-45,212 +-44,213 +-43,214 +-42,215 +-41,216 +-40,217 +-39,218 +-38,219 +-37,220 +-36,221 +-35,222 +-34,223 +-33,224 +-32,225 +-31,226 +-30,227 +-29,228 +-28,229 +-27,230 +-26,231 +-25,232 +-24,233 +-23,234 +-22,235 +-21,236 +-20,237 +-19,238 +-18,239 +-17,240 +-16,241 +-15,242 +-14,243 +-13,244 +-12,245 +-11,246 +-10,247 +-9,248 +-8,249 +-7,250 +-6,251 +-5,252 +-4,253 +-3,254 +-2,255 +-1,256 diff --git a/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float32/unwrapped-audit/generated-code.json b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float32/unwrapped-audit/generated-code.json new file mode 100644 index 0000000..aff2ccd --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float32/unwrapped-audit/generated-code.json @@ -0,0 +1,154 @@ +[ + { + "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" + }, + { + "active": true, + "code_objects": [], + "name": "zz_external_arrivals", + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject_3" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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_3" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "when": "thresholds" + }, + { + "abstract_code": "", + "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 _the_period = _array_zz_external_sources__period_bins[0]\n _timebin = _array_defaultclock_timestep[0]\n _n_spikes = 0\n _lastindex_before = _array_zz_external_sources__lastindex[0]\n if _the_period > 0:\n _timebin %= _the_period\n # If there is a periodicity in the SpikeGenerator, we need to reset the\n # lastindex when the period has passed\n if _lastindex_before > 0 and _array_zz_external_sources__timebins[_lastindex_before - 1] >= _timebin:\n _lastindex_before = 0\n _n_spikes = _numpy.searchsorted(_array_zz_external_sources__timebins[_lastindex_before:],\n _timebin, side='right')\n _array_zz_external_sources__lastindex[0] = _lastindex_before + _n_spikes\n _indices = _array_zz_external_sources_neuron_index[_lastindex_before:_lastindex_before+_n_spikes]\n _array_zz_external_sources__spikespace[:_n_spikes] = _indices\n _array_zz_external_sources__spikespace[-1] = _n_spikes\n", + "name": "zz_external_sources_codeobject_3" + } + ], + "name": "zz_external_sources", + "order": 0, + "type": "SpikeGeneratorGroup", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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_1" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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_3" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "when": "synapses" + }, + { + "abstract_code": "g_post += 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": "zz_external_arrivals_pre_push_spikes" + }, + { + "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_post += w\n _postsynaptic_idx = _array_zz_external_arrivals__synaptic_post[_idx]\n not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_zz_external_arrivals_w[_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": "zz_external_arrivals_pre_codeobject_3" + } + ], + "name": "zz_external_arrivals_pre", + "order": 0, + "type": "SynapticPathway", + "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_3" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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_1" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float32/unwrapped-audit/input-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float32/unwrapped-audit/input-audit.json new file mode 100644 index 0000000..7b378c8 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float32/unwrapped-audit/input-audit.json @@ -0,0 +1,48 @@ +{ + "all_neurons_keep_original_rfc": true, + "completeness_sha256": "d8163907696aec1bf853ecccbe301c50efb4abd5b1c76b9a3dfa34f0e9e36c20", + "connectivity_sha256": "87dfbd207929725101477715d0684af71971d93cb279c3e195704b2b939b3f86", + "dt_ms": 0.1, + "parameter_checks": { + "membrane_tau_ms": { + "author": 20.0, + "case": 20.0 + }, + "refractory_ms": { + "author": 2.2, + "case": 2.2 + }, + "reset_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "resting_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "synaptic_delay_ms": { + "author": 1.8, + "case": 1.8 + }, + "synaptic_tau_ms": { + "author": 5.0, + "case": 5.0 + }, + "threshold_mv": { + "author": -45.0, + "case": -45.0 + }, + "w_syn_mv_per_anatomical_synapse": { + "author": 0.275, + "case": 0.275 + } + }, + "poisson_helper_used": false, + "precision": "float32", + "queue_trace_enabled": false, + "request_interface": "before_thresholds; v=v_th+1mV only if not_refractory", + "source_parameters_modified": false, + "source_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "state_units": "SI volts, original dtype", + "steps": 600 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float32/unwrapped-audit/queue-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float32/unwrapped-audit/queue-audit.json new file mode 100644 index 0000000..6d2ed14 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float32/unwrapped-audit/queue-audit.json @@ -0,0 +1,11 @@ +{ + "accepted_due_events": 0, + "advance_calls": 0, + "all_due_events_preserved": null, + "due_events": 0, + "installations": [], + "ordering": "raw anatomical queue.peek local edge-index sequence; no sorting or filtering", + "peek_calls": 0, + "proxy_contract": "peek returns original object; advance and all other methods forward unchanged", + "trace_enabled": false +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float32/unwrapped-audit/schedule.json b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float32/unwrapped-audit/schedule.json new file mode 100644 index 0000000..30bc294 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float32/unwrapped-audit/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_common_requests (NetworkOperation) | -- | 100. us (every step) | before_thresholds | 0 | yes \ndefault_neurons_spike_thresholder (Thresholder) | default_neurons (NeuronGroup) | 100. us (every step) | thresholds | 0 | yes \nzz_external_sources (SpikeGeneratorGroup) | zz_external_sources (SpikeGeneratorGroup) | 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 \nzz_external_arrivals_pre (SynapticPathway) | zz_external_arrivals (Synapses) | 100. us (every step) | synapses | 0 | 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 " +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float64/case.json b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float64/case.json new file mode 100644 index 0000000..3829bbe --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float64/case.json @@ -0,0 +1,35 @@ +{ + "author_commit": "91bdd1e7dcf193f3e7ca5a8933497fcef63b7960", + "author_path": "/data/digital-drosophila/experiments/phase4ad-author-semantics/external-resources/model.py", + "author_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "case_arrays_sha256": "f3a900e9032754619549005131283cbaf87fdaa9093887a90a295589dac590fb", + "case_spec_sha256": "90850d6968a7832e415d0966b57e216a65f5ba8f63e488e497148b6525806d79", + "common_interface_preserved": true, + "learning": false, + "original_poi_interface_adopted": false, + "precision": "float64", + "spec": { + "description": "256-source signed fan-in, labelled duplicate/loop; refractory requests and external writes.", + "dt_ms": 0.1, + "duration_ms": 60.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 + }, + "name": "fanin_bursts", + "selection": null, + "steps": 600, + "trace_queue": true, + "validate_queue_proxy": true + }, + "trace_queue": true, + "validate_queue_proxy": true, + "whole_brain": false +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float64/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float64/coefficients.json new file mode 100644 index 0000000..48ffa23 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float64/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_1", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_1", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_1", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_1", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_1", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_1", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float64/environment.json b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float64/environment.json new file mode 100644 index 0000000..7b43f4f --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float64/environment.json @@ -0,0 +1,14 @@ +{ + "backend": "Brian2 numpy runtime", + "packages": { + "brian2": "2.5.1", + "cython": "0.29.33", + "numpy": "1.22.3", + "pandas": "1.4.3", + "pyarrow": "11.0.0", + "scipy": "1.8.1", + "sympy": "1.12" + }, + "platform": "Linux-5.15.0-194-generic-x86_64-with-glibc2.35", + "python": "3.10.12 (main, Aug 31 2026, 10:18:17) [GCC 11.4.0]" +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float64/instrumented/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float64/instrumented/coefficients.json new file mode 100644 index 0000000..48ffa23 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float64/instrumented/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_1", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_1", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_1", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_1", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_1", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_1", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float64/instrumented/compiled-code.json b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float64/instrumented/compiled-code.json new file mode 100644 index 0000000..759f6b7 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float64/instrumented/compiled-code.json @@ -0,0 +1,162 @@ +[ + { + "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" + }, + { + "active": true, + "code_objects": [], + "name": "zz_external_arrivals", + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "when": "thresholds" + }, + { + "abstract_code": "", + "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 _the_period = _array_zz_external_sources__period_bins[0]\n _timebin = _array_defaultclock_timestep[0]\n _n_spikes = 0\n _lastindex_before = _array_zz_external_sources__lastindex[0]\n if _the_period > 0:\n _timebin %= _the_period\n # If there is a periodicity in the SpikeGenerator, we need to reset the\n # lastindex when the period has passed\n if _lastindex_before > 0 and _array_zz_external_sources__timebins[_lastindex_before - 1] >= _timebin:\n _lastindex_before = 0\n _n_spikes = _numpy.searchsorted(_array_zz_external_sources__timebins[_lastindex_before:],\n _timebin, side='right')\n _array_zz_external_sources__lastindex[0] = _lastindex_before + _n_spikes\n _indices = _array_zz_external_sources_neuron_index[_lastindex_before:_lastindex_before+_n_spikes]\n _array_zz_external_sources__spikespace[:_n_spikes] = _indices\n _array_zz_external_sources__spikespace[-1] = _n_spikes\n", + "name": "zz_external_sources_codeobject" + } + ], + "name": "zz_external_sources", + "order": 0, + "type": "SpikeGeneratorGroup", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "when": "synapses" + }, + { + "abstract_code": "g_post += 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": "zz_external_arrivals_pre_push_spikes" + }, + { + "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_post += w\n _postsynaptic_idx = _array_zz_external_arrivals__synaptic_post[_idx]\n not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_zz_external_arrivals_w[_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": "zz_external_arrivals_pre_codeobject" + } + ], + "name": "zz_external_arrivals_pre", + "order": 0, + "type": "SynapticPathway", + "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" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + }, + { + "active": true, + "code_objects": [], + "name": "zz_oracle_queue_installer", + "order": 1000000, + "type": "QueueInstaller", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float64/instrumented/completeness.csv b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float64/instrumented/completeness.csv new file mode 100644 index 0000000..654117f --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float64/instrumented/completeness.csv @@ -0,0 +1,258 @@ +global_neuron_idx,local_index +-257,0 +-256,1 +-255,2 +-254,3 +-253,4 +-252,5 +-251,6 +-250,7 +-249,8 +-248,9 +-247,10 +-246,11 +-245,12 +-244,13 +-243,14 +-242,15 +-241,16 +-240,17 +-239,18 +-238,19 +-237,20 +-236,21 +-235,22 +-234,23 +-233,24 +-232,25 +-231,26 +-230,27 +-229,28 +-228,29 +-227,30 +-226,31 +-225,32 +-224,33 +-223,34 +-222,35 +-221,36 +-220,37 +-219,38 +-218,39 +-217,40 +-216,41 +-215,42 +-214,43 +-213,44 +-212,45 +-211,46 +-210,47 +-209,48 +-208,49 +-207,50 +-206,51 +-205,52 +-204,53 +-203,54 +-202,55 +-201,56 +-200,57 +-199,58 +-198,59 +-197,60 +-196,61 +-195,62 +-194,63 +-193,64 +-192,65 +-191,66 +-190,67 +-189,68 +-188,69 +-187,70 +-186,71 +-185,72 +-184,73 +-183,74 +-182,75 +-181,76 +-180,77 +-179,78 +-178,79 +-177,80 +-176,81 +-175,82 +-174,83 +-173,84 +-172,85 +-171,86 +-170,87 +-169,88 +-168,89 +-167,90 +-166,91 +-165,92 +-164,93 +-163,94 +-162,95 +-161,96 +-160,97 +-159,98 +-158,99 +-157,100 +-156,101 +-155,102 +-154,103 +-153,104 +-152,105 +-151,106 +-150,107 +-149,108 +-148,109 +-147,110 +-146,111 +-145,112 +-144,113 +-143,114 +-142,115 +-141,116 +-140,117 +-139,118 +-138,119 +-137,120 +-136,121 +-135,122 +-134,123 +-133,124 +-132,125 +-131,126 +-130,127 +-129,128 +-128,129 +-127,130 +-126,131 +-125,132 +-124,133 +-123,134 +-122,135 +-121,136 +-120,137 +-119,138 +-118,139 +-117,140 +-116,141 +-115,142 +-114,143 +-113,144 +-112,145 +-111,146 +-110,147 +-109,148 +-108,149 +-107,150 +-106,151 +-105,152 +-104,153 +-103,154 +-102,155 +-101,156 +-100,157 +-99,158 +-98,159 +-97,160 +-96,161 +-95,162 +-94,163 +-93,164 +-92,165 +-91,166 +-90,167 +-89,168 +-88,169 +-87,170 +-86,171 +-85,172 +-84,173 +-83,174 +-82,175 +-81,176 +-80,177 +-79,178 +-78,179 +-77,180 +-76,181 +-75,182 +-74,183 +-73,184 +-72,185 +-71,186 +-70,187 +-69,188 +-68,189 +-67,190 +-66,191 +-65,192 +-64,193 +-63,194 +-62,195 +-61,196 +-60,197 +-59,198 +-58,199 +-57,200 +-56,201 +-55,202 +-54,203 +-53,204 +-52,205 +-51,206 +-50,207 +-49,208 +-48,209 +-47,210 +-46,211 +-45,212 +-44,213 +-43,214 +-42,215 +-41,216 +-40,217 +-39,218 +-38,219 +-37,220 +-36,221 +-35,222 +-34,223 +-33,224 +-32,225 +-31,226 +-30,227 +-29,228 +-28,229 +-27,230 +-26,231 +-25,232 +-24,233 +-23,234 +-22,235 +-21,236 +-20,237 +-19,238 +-18,239 +-17,240 +-16,241 +-15,242 +-14,243 +-13,244 +-12,245 +-11,246 +-10,247 +-9,248 +-8,249 +-7,250 +-6,251 +-5,252 +-4,253 +-3,254 +-2,255 +-1,256 diff --git a/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float64/instrumented/generated-code.json b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float64/instrumented/generated-code.json new file mode 100644 index 0000000..5e843e0 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float64/instrumented/generated-code.json @@ -0,0 +1,162 @@ +[ + { + "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" + }, + { + "active": true, + "code_objects": [], + "name": "zz_external_arrivals", + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject_1" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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_1" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "when": "thresholds" + }, + { + "abstract_code": "", + "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 _the_period = _array_zz_external_sources__period_bins[0]\n _timebin = _array_defaultclock_timestep[0]\n _n_spikes = 0\n _lastindex_before = _array_zz_external_sources__lastindex[0]\n if _the_period > 0:\n _timebin %= _the_period\n # If there is a periodicity in the SpikeGenerator, we need to reset the\n # lastindex when the period has passed\n if _lastindex_before > 0 and _array_zz_external_sources__timebins[_lastindex_before - 1] >= _timebin:\n _lastindex_before = 0\n _n_spikes = _numpy.searchsorted(_array_zz_external_sources__timebins[_lastindex_before:],\n _timebin, side='right')\n _array_zz_external_sources__lastindex[0] = _lastindex_before + _n_spikes\n _indices = _array_zz_external_sources_neuron_index[_lastindex_before:_lastindex_before+_n_spikes]\n _array_zz_external_sources__spikespace[:_n_spikes] = _indices\n _array_zz_external_sources__spikespace[-1] = _n_spikes\n", + "name": "zz_external_sources_codeobject_1" + } + ], + "name": "zz_external_sources", + "order": 0, + "type": "SpikeGeneratorGroup", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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_1" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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_1" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "when": "synapses" + }, + { + "abstract_code": "g_post += 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": "zz_external_arrivals_pre_push_spikes" + }, + { + "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_post += w\n _postsynaptic_idx = _array_zz_external_arrivals__synaptic_post[_idx]\n not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_zz_external_arrivals_w[_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": "zz_external_arrivals_pre_codeobject_1" + } + ], + "name": "zz_external_arrivals_pre", + "order": 0, + "type": "SynapticPathway", + "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_1" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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_1" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + }, + { + "active": true, + "code_objects": [], + "name": "zz_oracle_queue_installer", + "order": 1000000, + "type": "QueueInstaller", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float64/instrumented/input-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float64/instrumented/input-audit.json new file mode 100644 index 0000000..9062a74 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float64/instrumented/input-audit.json @@ -0,0 +1,48 @@ +{ + "all_neurons_keep_original_rfc": true, + "completeness_sha256": "d8163907696aec1bf853ecccbe301c50efb4abd5b1c76b9a3dfa34f0e9e36c20", + "connectivity_sha256": "87dfbd207929725101477715d0684af71971d93cb279c3e195704b2b939b3f86", + "dt_ms": 0.1, + "parameter_checks": { + "membrane_tau_ms": { + "author": 20.0, + "case": 20.0 + }, + "refractory_ms": { + "author": 2.2, + "case": 2.2 + }, + "reset_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "resting_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "synaptic_delay_ms": { + "author": 1.8, + "case": 1.8 + }, + "synaptic_tau_ms": { + "author": 5.0, + "case": 5.0 + }, + "threshold_mv": { + "author": -45.0, + "case": -45.0 + }, + "w_syn_mv_per_anatomical_synapse": { + "author": 0.275, + "case": 0.275 + } + }, + "poisson_helper_used": false, + "precision": "float64", + "queue_trace_enabled": true, + "request_interface": "before_thresholds; v=v_th+1mV only if not_refractory", + "source_parameters_modified": false, + "source_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "state_units": "SI volts, original dtype", + "steps": 600 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float64/instrumented/queue-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float64/instrumented/queue-audit.json new file mode 100644 index 0000000..3229f70 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float64/instrumented/queue-audit.json @@ -0,0 +1,14 @@ +{ + "accepted_due_events": 1285, + "advance_calls": 600, + "all_due_events_preserved": true, + "due_events": 1545, + "installations": [ + "default_synapses_pre_codeobject", + "default_synapses_pre_codeobject_1" + ], + "ordering": "raw anatomical queue.peek local edge-index sequence; no sorting or filtering", + "peek_calls": 600, + "proxy_contract": "peek returns original object; advance and all other methods forward unchanged", + "trace_enabled": true +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float64/instrumented/schedule.json b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float64/instrumented/schedule.json new file mode 100644 index 0000000..445ab0c --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float64/instrumented/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_common_requests (NetworkOperation) | -- | 100. us (every step) | before_thresholds | 0 | yes \ndefault_neurons_spike_thresholder (Thresholder) | default_neurons (NeuronGroup) | 100. us (every step) | thresholds | 0 | yes \nzz_external_sources (SpikeGeneratorGroup) | zz_external_sources (SpikeGeneratorGroup) | 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 \nzz_external_arrivals_pre (SynapticPathway) | zz_external_arrivals (Synapses) | 100. us (every step) | synapses | 0 | 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 \nzz_oracle_queue_installer (QueueInstaller) | -- | 100. us (every step) | end | 1000000 | yes " +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float64/proxy-validation.json b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float64/proxy-validation.json new file mode 100644 index 0000000..50c684d --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float64/proxy-validation.json @@ -0,0 +1,33 @@ +{ + "arrival_arrays_excluded": "An unwrapped queue is deliberately not observed", + "exact_arrays": { + "applicable_count": true, + "coefficients": true, + "counts": true, + "external_accepted": true, + "external_step": true, + "external_target": true, + "external_weights": true, + "fired": true, + "g": true, + "history": true, + "initial_g": true, + "initial_v": true, + "local_idx": true, + "neuron_idx": true, + "nodes": true, + "not_refractory": true, + "ref": true, + "ref_history": true, + "rejected_count": true, + "request_accepted": true, + "request_attempted": true, + "request_count": true, + "request_rejected": true, + "step": true, + "v": true, + "weights": true + }, + "pass": true, + "performed": true +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float64/summary.json b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float64/summary.json new file mode 100644 index 0000000..bc4d729 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float64/summary.json @@ -0,0 +1,18 @@ +{ + "applicable_requests": 1537, + "coefficient_file": "/data/digital-drosophila/experiments/phase4ae-author-runtime/oracle/fanin_bursts-float64/coefficients.json", + "complete": true, + "due_arrivals": 1545, + "edges": 258, + "name": "fanin_bursts", + "nodes": 257, + "precision": "float64", + "queue_proxy_validated": true, + "queue_trace_enabled": true, + "rejected_requests": 512, + "requests": 2049, + "source_unchanged": true, + "spikes": 1539, + "state_file": "/data/digital-drosophila/experiments/phase4ae-author-runtime/oracle/fanin_bursts-float64/state.npz", + "steps": 600 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float64/unwrapped-audit/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float64/unwrapped-audit/coefficients.json new file mode 100644 index 0000000..6425957 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float64/unwrapped-audit/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_2", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_2", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_2", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_2", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_2", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_2", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float64/unwrapped-audit/compiled-code.json b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float64/unwrapped-audit/compiled-code.json new file mode 100644 index 0000000..b323fd4 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float64/unwrapped-audit/compiled-code.json @@ -0,0 +1,154 @@ +[ + { + "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" + }, + { + "active": true, + "code_objects": [], + "name": "zz_external_arrivals", + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "when": "thresholds" + }, + { + "abstract_code": "", + "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 _the_period = _array_zz_external_sources__period_bins[0]\n _timebin = _array_defaultclock_timestep[0]\n _n_spikes = 0\n _lastindex_before = _array_zz_external_sources__lastindex[0]\n if _the_period > 0:\n _timebin %= _the_period\n # If there is a periodicity in the SpikeGenerator, we need to reset the\n # lastindex when the period has passed\n if _lastindex_before > 0 and _array_zz_external_sources__timebins[_lastindex_before - 1] >= _timebin:\n _lastindex_before = 0\n _n_spikes = _numpy.searchsorted(_array_zz_external_sources__timebins[_lastindex_before:],\n _timebin, side='right')\n _array_zz_external_sources__lastindex[0] = _lastindex_before + _n_spikes\n _indices = _array_zz_external_sources_neuron_index[_lastindex_before:_lastindex_before+_n_spikes]\n _array_zz_external_sources__spikespace[:_n_spikes] = _indices\n _array_zz_external_sources__spikespace[-1] = _n_spikes\n", + "name": "zz_external_sources_codeobject" + } + ], + "name": "zz_external_sources", + "order": 0, + "type": "SpikeGeneratorGroup", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "when": "synapses" + }, + { + "abstract_code": "g_post += 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": "zz_external_arrivals_pre_push_spikes" + }, + { + "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_post += w\n _postsynaptic_idx = _array_zz_external_arrivals__synaptic_post[_idx]\n not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_zz_external_arrivals_w[_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": "zz_external_arrivals_pre_codeobject" + } + ], + "name": "zz_external_arrivals_pre", + "order": 0, + "type": "SynapticPathway", + "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" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float64/unwrapped-audit/completeness.csv b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float64/unwrapped-audit/completeness.csv new file mode 100644 index 0000000..654117f --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float64/unwrapped-audit/completeness.csv @@ -0,0 +1,258 @@ +global_neuron_idx,local_index +-257,0 +-256,1 +-255,2 +-254,3 +-253,4 +-252,5 +-251,6 +-250,7 +-249,8 +-248,9 +-247,10 +-246,11 +-245,12 +-244,13 +-243,14 +-242,15 +-241,16 +-240,17 +-239,18 +-238,19 +-237,20 +-236,21 +-235,22 +-234,23 +-233,24 +-232,25 +-231,26 +-230,27 +-229,28 +-228,29 +-227,30 +-226,31 +-225,32 +-224,33 +-223,34 +-222,35 +-221,36 +-220,37 +-219,38 +-218,39 +-217,40 +-216,41 +-215,42 +-214,43 +-213,44 +-212,45 +-211,46 +-210,47 +-209,48 +-208,49 +-207,50 +-206,51 +-205,52 +-204,53 +-203,54 +-202,55 +-201,56 +-200,57 +-199,58 +-198,59 +-197,60 +-196,61 +-195,62 +-194,63 +-193,64 +-192,65 +-191,66 +-190,67 +-189,68 +-188,69 +-187,70 +-186,71 +-185,72 +-184,73 +-183,74 +-182,75 +-181,76 +-180,77 +-179,78 +-178,79 +-177,80 +-176,81 +-175,82 +-174,83 +-173,84 +-172,85 +-171,86 +-170,87 +-169,88 +-168,89 +-167,90 +-166,91 +-165,92 +-164,93 +-163,94 +-162,95 +-161,96 +-160,97 +-159,98 +-158,99 +-157,100 +-156,101 +-155,102 +-154,103 +-153,104 +-152,105 +-151,106 +-150,107 +-149,108 +-148,109 +-147,110 +-146,111 +-145,112 +-144,113 +-143,114 +-142,115 +-141,116 +-140,117 +-139,118 +-138,119 +-137,120 +-136,121 +-135,122 +-134,123 +-133,124 +-132,125 +-131,126 +-130,127 +-129,128 +-128,129 +-127,130 +-126,131 +-125,132 +-124,133 +-123,134 +-122,135 +-121,136 +-120,137 +-119,138 +-118,139 +-117,140 +-116,141 +-115,142 +-114,143 +-113,144 +-112,145 +-111,146 +-110,147 +-109,148 +-108,149 +-107,150 +-106,151 +-105,152 +-104,153 +-103,154 +-102,155 +-101,156 +-100,157 +-99,158 +-98,159 +-97,160 +-96,161 +-95,162 +-94,163 +-93,164 +-92,165 +-91,166 +-90,167 +-89,168 +-88,169 +-87,170 +-86,171 +-85,172 +-84,173 +-83,174 +-82,175 +-81,176 +-80,177 +-79,178 +-78,179 +-77,180 +-76,181 +-75,182 +-74,183 +-73,184 +-72,185 +-71,186 +-70,187 +-69,188 +-68,189 +-67,190 +-66,191 +-65,192 +-64,193 +-63,194 +-62,195 +-61,196 +-60,197 +-59,198 +-58,199 +-57,200 +-56,201 +-55,202 +-54,203 +-53,204 +-52,205 +-51,206 +-50,207 +-49,208 +-48,209 +-47,210 +-46,211 +-45,212 +-44,213 +-43,214 +-42,215 +-41,216 +-40,217 +-39,218 +-38,219 +-37,220 +-36,221 +-35,222 +-34,223 +-33,224 +-32,225 +-31,226 +-30,227 +-29,228 +-28,229 +-27,230 +-26,231 +-25,232 +-24,233 +-23,234 +-22,235 +-21,236 +-20,237 +-19,238 +-18,239 +-17,240 +-16,241 +-15,242 +-14,243 +-13,244 +-12,245 +-11,246 +-10,247 +-9,248 +-8,249 +-7,250 +-6,251 +-5,252 +-4,253 +-3,254 +-2,255 +-1,256 diff --git a/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float64/unwrapped-audit/generated-code.json b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float64/unwrapped-audit/generated-code.json new file mode 100644 index 0000000..bbc06c8 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float64/unwrapped-audit/generated-code.json @@ -0,0 +1,154 @@ +[ + { + "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" + }, + { + "active": true, + "code_objects": [], + "name": "zz_external_arrivals", + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject_2" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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_2" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "when": "thresholds" + }, + { + "abstract_code": "", + "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 _the_period = _array_zz_external_sources__period_bins[0]\n _timebin = _array_defaultclock_timestep[0]\n _n_spikes = 0\n _lastindex_before = _array_zz_external_sources__lastindex[0]\n if _the_period > 0:\n _timebin %= _the_period\n # If there is a periodicity in the SpikeGenerator, we need to reset the\n # lastindex when the period has passed\n if _lastindex_before > 0 and _array_zz_external_sources__timebins[_lastindex_before - 1] >= _timebin:\n _lastindex_before = 0\n _n_spikes = _numpy.searchsorted(_array_zz_external_sources__timebins[_lastindex_before:],\n _timebin, side='right')\n _array_zz_external_sources__lastindex[0] = _lastindex_before + _n_spikes\n _indices = _array_zz_external_sources_neuron_index[_lastindex_before:_lastindex_before+_n_spikes]\n _array_zz_external_sources__spikespace[:_n_spikes] = _indices\n _array_zz_external_sources__spikespace[-1] = _n_spikes\n", + "name": "zz_external_sources_codeobject_2" + } + ], + "name": "zz_external_sources", + "order": 0, + "type": "SpikeGeneratorGroup", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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_1" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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_2" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "when": "synapses" + }, + { + "abstract_code": "g_post += 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": "zz_external_arrivals_pre_push_spikes" + }, + { + "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_post += w\n _postsynaptic_idx = _array_zz_external_arrivals__synaptic_post[_idx]\n not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_zz_external_arrivals_w[_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": "zz_external_arrivals_pre_codeobject_2" + } + ], + "name": "zz_external_arrivals_pre", + "order": 0, + "type": "SynapticPathway", + "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_2" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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_1" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float64/unwrapped-audit/input-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float64/unwrapped-audit/input-audit.json new file mode 100644 index 0000000..f95336c --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float64/unwrapped-audit/input-audit.json @@ -0,0 +1,48 @@ +{ + "all_neurons_keep_original_rfc": true, + "completeness_sha256": "d8163907696aec1bf853ecccbe301c50efb4abd5b1c76b9a3dfa34f0e9e36c20", + "connectivity_sha256": "87dfbd207929725101477715d0684af71971d93cb279c3e195704b2b939b3f86", + "dt_ms": 0.1, + "parameter_checks": { + "membrane_tau_ms": { + "author": 20.0, + "case": 20.0 + }, + "refractory_ms": { + "author": 2.2, + "case": 2.2 + }, + "reset_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "resting_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "synaptic_delay_ms": { + "author": 1.8, + "case": 1.8 + }, + "synaptic_tau_ms": { + "author": 5.0, + "case": 5.0 + }, + "threshold_mv": { + "author": -45.0, + "case": -45.0 + }, + "w_syn_mv_per_anatomical_synapse": { + "author": 0.275, + "case": 0.275 + } + }, + "poisson_helper_used": false, + "precision": "float64", + "queue_trace_enabled": false, + "request_interface": "before_thresholds; v=v_th+1mV only if not_refractory", + "source_parameters_modified": false, + "source_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "state_units": "SI volts, original dtype", + "steps": 600 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float64/unwrapped-audit/queue-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float64/unwrapped-audit/queue-audit.json new file mode 100644 index 0000000..6d2ed14 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float64/unwrapped-audit/queue-audit.json @@ -0,0 +1,11 @@ +{ + "accepted_due_events": 0, + "advance_calls": 0, + "all_due_events_preserved": null, + "due_events": 0, + "installations": [], + "ordering": "raw anatomical queue.peek local edge-index sequence; no sorting or filtering", + "peek_calls": 0, + "proxy_contract": "peek returns original object; advance and all other methods forward unchanged", + "trace_enabled": false +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float64/unwrapped-audit/schedule.json b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float64/unwrapped-audit/schedule.json new file mode 100644 index 0000000..30bc294 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/fanin_bursts-float64/unwrapped-audit/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_common_requests (NetworkOperation) | -- | 100. us (every step) | before_thresholds | 0 | yes \ndefault_neurons_spike_thresholder (Thresholder) | default_neurons (NeuronGroup) | 100. us (every step) | thresholds | 0 | yes \nzz_external_sources (SpikeGeneratorGroup) | zz_external_sources (SpikeGeneratorGroup) | 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 \nzz_external_arrivals_pre (SynapticPathway) | zz_external_arrivals (Synapses) | 100. us (every step) | synapses | 0 | 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 " +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float32/case.json b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float32/case.json new file mode 100644 index 0000000..349aea8 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float32/case.json @@ -0,0 +1,59 @@ +{ + "author_commit": "91bdd1e7dcf193f3e7ca5a8933497fcef63b7960", + "author_path": "/data/digital-drosophila/experiments/phase4ad-author-semantics/external-resources/model.py", + "author_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "case_arrays_sha256": "02ab938969b4369b1e08bc4a82e8c5fe68683f7318baf5eb052098d63fab0302", + "case_spec_sha256": "eab2c18f120fd3e9f067f489cee0a4c07477607facf3094083d3e3fa60bfd1ef", + "common_interface_preserved": true, + "learning": false, + "original_poi_interface_adopted": false, + "precision": "float32", + "spec": { + "description": "Deterministically selected real induced graph; canonical edge IDs/counts and frozen signs.", + "dt_ms": 0.1, + "duration_ms": 50.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 + }, + "name": "highest_indegree", + "selection": { + "global_in_degree": 11526, + "negative_in_edges": 1403, + "positive_in_edges": 10076, + "stimulated_neuron_idx": [ + 494, + 775, + 1572, + 61804, + 62257, + 62700, + 62795, + 63041, + 65262, + 66225, + 66237, + 67241, + 67324, + 68856, + 70626, + 137444 + ], + "target_body_id": 10009, + "target_neuron_idx": 5 + }, + "steps": 500, + "trace_queue": true, + "validate_queue_proxy": true + }, + "trace_queue": true, + "validate_queue_proxy": true, + "whole_brain": false +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float32/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float32/coefficients.json new file mode 100644 index 0000000..30742b3 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float32/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_4", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_4", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_4", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_4", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_4", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_4", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float32/environment.json b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float32/environment.json new file mode 100644 index 0000000..7b43f4f --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float32/environment.json @@ -0,0 +1,14 @@ +{ + "backend": "Brian2 numpy runtime", + "packages": { + "brian2": "2.5.1", + "cython": "0.29.33", + "numpy": "1.22.3", + "pandas": "1.4.3", + "pyarrow": "11.0.0", + "scipy": "1.8.1", + "sympy": "1.12" + }, + "platform": "Linux-5.15.0-194-generic-x86_64-with-glibc2.35", + "python": "3.10.12 (main, Aug 31 2026, 10:18:17) [GCC 11.4.0]" +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float32/instrumented/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float32/instrumented/coefficients.json new file mode 100644 index 0000000..30742b3 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float32/instrumented/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_4", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_4", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_4", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_4", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_4", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_4", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float32/instrumented/compiled-code.json b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float32/instrumented/compiled-code.json new file mode 100644 index 0000000..3b9afa3 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float32/instrumented/compiled-code.json @@ -0,0 +1,122 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + }, + { + "active": true, + "code_objects": [], + "name": "zz_oracle_queue_installer", + "order": 1000000, + "type": "QueueInstaller", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float32/instrumented/completeness.csv b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float32/instrumented/completeness.csv new file mode 100644 index 0000000..adc3c09 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float32/instrumented/completeness.csv @@ -0,0 +1,129 @@ +global_neuron_idx,local_index +5,0 +21,1 +494,2 +775,3 +1572,4 +52515,5 +57252,6 +59937,7 +60155,8 +60450,9 +60737,10 +61164,11 +61387,12 +61721,13 +61804,14 +61941,15 +62257,16 +62700,17 +62734,18 +62795,19 +62888,20 +63041,21 +63106,22 +63173,23 +63287,24 +63339,25 +63918,26 +64210,27 +64233,28 +64443,29 +64514,30 +65001,31 +65235,32 +65262,33 +65374,34 +65565,35 +65691,36 +65742,37 +66003,38 +66127,39 +66225,40 +66237,41 +66541,42 +66598,43 +66843,44 +66958,45 +67072,46 +67135,47 +67241,48 +67284,49 +67324,50 +67373,51 +67453,52 +67483,53 +67537,54 +67594,55 +68056,56 +68074,57 +68192,58 +68199,59 +68355,60 +68543,61 +68617,62 +68656,63 +68838,64 +68856,65 +68869,66 +69139,67 +69415,68 +69516,69 +69540,70 +69809,71 +69860,72 +69966,73 +69982,74 +70036,75 +70202,76 +70316,77 +70561,78 +70626,79 +70744,80 +70783,81 +70897,82 +70977,83 +70995,84 +71060,85 +71120,86 +71215,87 +71267,88 +71346,89 +71440,90 +71456,91 +71738,92 +72060,93 +72219,94 +72322,95 +72365,96 +72473,97 +72485,98 +72578,99 +73026,100 +73221,101 +73544,102 +73653,103 +73903,104 +74495,105 +74818,106 +74995,107 +75925,108 +76961,109 +77090,110 +77291,111 +77444,112 +78506,113 +78574,114 +80691,115 +85419,116 +91986,117 +97175,118 +98515,119 +101566,120 +102237,121 +104598,122 +105190,123 +105260,124 +106136,125 +137444,126 +140350,127 diff --git a/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float32/instrumented/generated-code.json b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float32/instrumented/generated-code.json new file mode 100644 index 0000000..942ed7c --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float32/instrumented/generated-code.json @@ -0,0 +1,122 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject_4" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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_1" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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_1" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + }, + { + "active": true, + "code_objects": [], + "name": "zz_oracle_queue_installer", + "order": 1000000, + "type": "QueueInstaller", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float32/instrumented/input-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float32/instrumented/input-audit.json new file mode 100644 index 0000000..fe27f43 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float32/instrumented/input-audit.json @@ -0,0 +1,48 @@ +{ + "all_neurons_keep_original_rfc": true, + "completeness_sha256": "e90a4d12741fbd0bd0b5fdcf447c2664f7dfcdba7930f4e9e7f05811f0b530f4", + "connectivity_sha256": "1228ee73ad73051748dd1db62b5063c005471667fd8baacd6a9e76b134024800", + "dt_ms": 0.1, + "parameter_checks": { + "membrane_tau_ms": { + "author": 20.0, + "case": 20.0 + }, + "refractory_ms": { + "author": 2.2, + "case": 2.2 + }, + "reset_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "resting_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "synaptic_delay_ms": { + "author": 1.8, + "case": 1.8 + }, + "synaptic_tau_ms": { + "author": 5.0, + "case": 5.0 + }, + "threshold_mv": { + "author": -45.0, + "case": -45.0 + }, + "w_syn_mv_per_anatomical_synapse": { + "author": 0.275, + "case": 0.275 + } + }, + "poisson_helper_used": false, + "precision": "float32", + "queue_trace_enabled": true, + "request_interface": "before_thresholds; v=v_th+1mV only if not_refractory", + "source_parameters_modified": false, + "source_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "state_units": "SI volts, original dtype", + "steps": 500 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float32/instrumented/queue-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float32/instrumented/queue-audit.json new file mode 100644 index 0000000..f82eaa4 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float32/instrumented/queue-audit.json @@ -0,0 +1,14 @@ +{ + "accepted_due_events": 839, + "advance_calls": 500, + "all_due_events_preserved": true, + "due_events": 930, + "installations": [ + "default_synapses_pre_codeobject", + "default_synapses_pre_codeobject_4" + ], + "ordering": "raw anatomical queue.peek local edge-index sequence; no sorting or filtering", + "peek_calls": 500, + "proxy_contract": "peek returns original object; advance and all other methods forward unchanged", + "trace_enabled": true +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float32/instrumented/schedule.json b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float32/instrumented/schedule.json new file mode 100644 index 0000000..93e03d3 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float32/instrumented/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_common_requests (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 \nzz_oracle_queue_installer (QueueInstaller) | -- | 100. us (every step) | end | 1000000 | yes " +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float32/proxy-validation.json b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float32/proxy-validation.json new file mode 100644 index 0000000..50c684d --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float32/proxy-validation.json @@ -0,0 +1,33 @@ +{ + "arrival_arrays_excluded": "An unwrapped queue is deliberately not observed", + "exact_arrays": { + "applicable_count": true, + "coefficients": true, + "counts": true, + "external_accepted": true, + "external_step": true, + "external_target": true, + "external_weights": true, + "fired": true, + "g": true, + "history": true, + "initial_g": true, + "initial_v": true, + "local_idx": true, + "neuron_idx": true, + "nodes": true, + "not_refractory": true, + "ref": true, + "ref_history": true, + "rejected_count": true, + "request_accepted": true, + "request_attempted": true, + "request_count": true, + "request_rejected": true, + "step": true, + "v": true, + "weights": true + }, + "pass": true, + "performed": true +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float32/summary.json b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float32/summary.json new file mode 100644 index 0000000..d12b876 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float32/summary.json @@ -0,0 +1,18 @@ +{ + "applicable_requests": 96, + "coefficient_file": "/data/digital-drosophila/experiments/phase4ae-author-runtime/oracle/highest_indegree-float32/coefficients.json", + "complete": true, + "due_arrivals": 930, + "edges": 320, + "name": "highest_indegree", + "nodes": 128, + "precision": "float32", + "queue_proxy_validated": true, + "queue_trace_enabled": true, + "rejected_requests": 0, + "requests": 96, + "source_unchanged": true, + "spikes": 101, + "state_file": "/data/digital-drosophila/experiments/phase4ae-author-runtime/oracle/highest_indegree-float32/state.npz", + "steps": 500 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float32/unwrapped-audit/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float32/unwrapped-audit/coefficients.json new file mode 100644 index 0000000..0d1775a --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float32/unwrapped-audit/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_5", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_5", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_5", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_5", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_5", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_5", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float32/unwrapped-audit/compiled-code.json b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float32/unwrapped-audit/compiled-code.json new file mode 100644 index 0000000..9a4ea64 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float32/unwrapped-audit/compiled-code.json @@ -0,0 +1,114 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float32/unwrapped-audit/completeness.csv b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float32/unwrapped-audit/completeness.csv new file mode 100644 index 0000000..adc3c09 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float32/unwrapped-audit/completeness.csv @@ -0,0 +1,129 @@ +global_neuron_idx,local_index +5,0 +21,1 +494,2 +775,3 +1572,4 +52515,5 +57252,6 +59937,7 +60155,8 +60450,9 +60737,10 +61164,11 +61387,12 +61721,13 +61804,14 +61941,15 +62257,16 +62700,17 +62734,18 +62795,19 +62888,20 +63041,21 +63106,22 +63173,23 +63287,24 +63339,25 +63918,26 +64210,27 +64233,28 +64443,29 +64514,30 +65001,31 +65235,32 +65262,33 +65374,34 +65565,35 +65691,36 +65742,37 +66003,38 +66127,39 +66225,40 +66237,41 +66541,42 +66598,43 +66843,44 +66958,45 +67072,46 +67135,47 +67241,48 +67284,49 +67324,50 +67373,51 +67453,52 +67483,53 +67537,54 +67594,55 +68056,56 +68074,57 +68192,58 +68199,59 +68355,60 +68543,61 +68617,62 +68656,63 +68838,64 +68856,65 +68869,66 +69139,67 +69415,68 +69516,69 +69540,70 +69809,71 +69860,72 +69966,73 +69982,74 +70036,75 +70202,76 +70316,77 +70561,78 +70626,79 +70744,80 +70783,81 +70897,82 +70977,83 +70995,84 +71060,85 +71120,86 +71215,87 +71267,88 +71346,89 +71440,90 +71456,91 +71738,92 +72060,93 +72219,94 +72322,95 +72365,96 +72473,97 +72485,98 +72578,99 +73026,100 +73221,101 +73544,102 +73653,103 +73903,104 +74495,105 +74818,106 +74995,107 +75925,108 +76961,109 +77090,110 +77291,111 +77444,112 +78506,113 +78574,114 +80691,115 +85419,116 +91986,117 +97175,118 +98515,119 +101566,120 +102237,121 +104598,122 +105190,123 +105260,124 +106136,125 +137444,126 +140350,127 diff --git a/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float32/unwrapped-audit/generated-code.json b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float32/unwrapped-audit/generated-code.json new file mode 100644 index 0000000..4ed124c --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float32/unwrapped-audit/generated-code.json @@ -0,0 +1,114 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject_5" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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_1" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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_1" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float32/unwrapped-audit/input-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float32/unwrapped-audit/input-audit.json new file mode 100644 index 0000000..88d4fde --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float32/unwrapped-audit/input-audit.json @@ -0,0 +1,48 @@ +{ + "all_neurons_keep_original_rfc": true, + "completeness_sha256": "e90a4d12741fbd0bd0b5fdcf447c2664f7dfcdba7930f4e9e7f05811f0b530f4", + "connectivity_sha256": "1228ee73ad73051748dd1db62b5063c005471667fd8baacd6a9e76b134024800", + "dt_ms": 0.1, + "parameter_checks": { + "membrane_tau_ms": { + "author": 20.0, + "case": 20.0 + }, + "refractory_ms": { + "author": 2.2, + "case": 2.2 + }, + "reset_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "resting_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "synaptic_delay_ms": { + "author": 1.8, + "case": 1.8 + }, + "synaptic_tau_ms": { + "author": 5.0, + "case": 5.0 + }, + "threshold_mv": { + "author": -45.0, + "case": -45.0 + }, + "w_syn_mv_per_anatomical_synapse": { + "author": 0.275, + "case": 0.275 + } + }, + "poisson_helper_used": false, + "precision": "float32", + "queue_trace_enabled": false, + "request_interface": "before_thresholds; v=v_th+1mV only if not_refractory", + "source_parameters_modified": false, + "source_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "state_units": "SI volts, original dtype", + "steps": 500 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float32/unwrapped-audit/queue-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float32/unwrapped-audit/queue-audit.json new file mode 100644 index 0000000..6d2ed14 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float32/unwrapped-audit/queue-audit.json @@ -0,0 +1,11 @@ +{ + "accepted_due_events": 0, + "advance_calls": 0, + "all_due_events_preserved": null, + "due_events": 0, + "installations": [], + "ordering": "raw anatomical queue.peek local edge-index sequence; no sorting or filtering", + "peek_calls": 0, + "proxy_contract": "peek returns original object; advance and all other methods forward unchanged", + "trace_enabled": false +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float32/unwrapped-audit/schedule.json b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float32/unwrapped-audit/schedule.json new file mode 100644 index 0000000..4202f07 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float32/unwrapped-audit/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_common_requests (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 " +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float64/case.json b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float64/case.json new file mode 100644 index 0000000..b4904d8 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float64/case.json @@ -0,0 +1,59 @@ +{ + "author_commit": "91bdd1e7dcf193f3e7ca5a8933497fcef63b7960", + "author_path": "/data/digital-drosophila/experiments/phase4ad-author-semantics/external-resources/model.py", + "author_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "case_arrays_sha256": "02ab938969b4369b1e08bc4a82e8c5fe68683f7318baf5eb052098d63fab0302", + "case_spec_sha256": "eab2c18f120fd3e9f067f489cee0a4c07477607facf3094083d3e3fa60bfd1ef", + "common_interface_preserved": true, + "learning": false, + "original_poi_interface_adopted": false, + "precision": "float64", + "spec": { + "description": "Deterministically selected real induced graph; canonical edge IDs/counts and frozen signs.", + "dt_ms": 0.1, + "duration_ms": 50.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 + }, + "name": "highest_indegree", + "selection": { + "global_in_degree": 11526, + "negative_in_edges": 1403, + "positive_in_edges": 10076, + "stimulated_neuron_idx": [ + 494, + 775, + 1572, + 61804, + 62257, + 62700, + 62795, + 63041, + 65262, + 66225, + 66237, + 67241, + 67324, + 68856, + 70626, + 137444 + ], + "target_body_id": 10009, + "target_neuron_idx": 5 + }, + "steps": 500, + "trace_queue": true, + "validate_queue_proxy": true + }, + "trace_queue": true, + "validate_queue_proxy": true, + "whole_brain": false +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float64/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float64/coefficients.json new file mode 100644 index 0000000..5ca0ad6 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float64/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_3", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_3", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_3", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_3", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_3", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_3", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float64/environment.json b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float64/environment.json new file mode 100644 index 0000000..7b43f4f --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float64/environment.json @@ -0,0 +1,14 @@ +{ + "backend": "Brian2 numpy runtime", + "packages": { + "brian2": "2.5.1", + "cython": "0.29.33", + "numpy": "1.22.3", + "pandas": "1.4.3", + "pyarrow": "11.0.0", + "scipy": "1.8.1", + "sympy": "1.12" + }, + "platform": "Linux-5.15.0-194-generic-x86_64-with-glibc2.35", + "python": "3.10.12 (main, Aug 31 2026, 10:18:17) [GCC 11.4.0]" +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float64/instrumented/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float64/instrumented/coefficients.json new file mode 100644 index 0000000..5ca0ad6 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float64/instrumented/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_3", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_3", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_3", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_3", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_3", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_3", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float64/instrumented/compiled-code.json b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float64/instrumented/compiled-code.json new file mode 100644 index 0000000..3b9afa3 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float64/instrumented/compiled-code.json @@ -0,0 +1,122 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + }, + { + "active": true, + "code_objects": [], + "name": "zz_oracle_queue_installer", + "order": 1000000, + "type": "QueueInstaller", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float64/instrumented/completeness.csv b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float64/instrumented/completeness.csv new file mode 100644 index 0000000..adc3c09 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float64/instrumented/completeness.csv @@ -0,0 +1,129 @@ +global_neuron_idx,local_index +5,0 +21,1 +494,2 +775,3 +1572,4 +52515,5 +57252,6 +59937,7 +60155,8 +60450,9 +60737,10 +61164,11 +61387,12 +61721,13 +61804,14 +61941,15 +62257,16 +62700,17 +62734,18 +62795,19 +62888,20 +63041,21 +63106,22 +63173,23 +63287,24 +63339,25 +63918,26 +64210,27 +64233,28 +64443,29 +64514,30 +65001,31 +65235,32 +65262,33 +65374,34 +65565,35 +65691,36 +65742,37 +66003,38 +66127,39 +66225,40 +66237,41 +66541,42 +66598,43 +66843,44 +66958,45 +67072,46 +67135,47 +67241,48 +67284,49 +67324,50 +67373,51 +67453,52 +67483,53 +67537,54 +67594,55 +68056,56 +68074,57 +68192,58 +68199,59 +68355,60 +68543,61 +68617,62 +68656,63 +68838,64 +68856,65 +68869,66 +69139,67 +69415,68 +69516,69 +69540,70 +69809,71 +69860,72 +69966,73 +69982,74 +70036,75 +70202,76 +70316,77 +70561,78 +70626,79 +70744,80 +70783,81 +70897,82 +70977,83 +70995,84 +71060,85 +71120,86 +71215,87 +71267,88 +71346,89 +71440,90 +71456,91 +71738,92 +72060,93 +72219,94 +72322,95 +72365,96 +72473,97 +72485,98 +72578,99 +73026,100 +73221,101 +73544,102 +73653,103 +73903,104 +74495,105 +74818,106 +74995,107 +75925,108 +76961,109 +77090,110 +77291,111 +77444,112 +78506,113 +78574,114 +80691,115 +85419,116 +91986,117 +97175,118 +98515,119 +101566,120 +102237,121 +104598,122 +105190,123 +105260,124 +106136,125 +137444,126 +140350,127 diff --git a/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float64/instrumented/generated-code.json b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float64/instrumented/generated-code.json new file mode 100644 index 0000000..5e8f89b --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float64/instrumented/generated-code.json @@ -0,0 +1,122 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject_3" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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_3" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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_1" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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_3" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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_3" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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_1" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + }, + { + "active": true, + "code_objects": [], + "name": "zz_oracle_queue_installer", + "order": 1000000, + "type": "QueueInstaller", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float64/instrumented/input-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float64/instrumented/input-audit.json new file mode 100644 index 0000000..259265c --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float64/instrumented/input-audit.json @@ -0,0 +1,48 @@ +{ + "all_neurons_keep_original_rfc": true, + "completeness_sha256": "e90a4d12741fbd0bd0b5fdcf447c2664f7dfcdba7930f4e9e7f05811f0b530f4", + "connectivity_sha256": "1228ee73ad73051748dd1db62b5063c005471667fd8baacd6a9e76b134024800", + "dt_ms": 0.1, + "parameter_checks": { + "membrane_tau_ms": { + "author": 20.0, + "case": 20.0 + }, + "refractory_ms": { + "author": 2.2, + "case": 2.2 + }, + "reset_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "resting_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "synaptic_delay_ms": { + "author": 1.8, + "case": 1.8 + }, + "synaptic_tau_ms": { + "author": 5.0, + "case": 5.0 + }, + "threshold_mv": { + "author": -45.0, + "case": -45.0 + }, + "w_syn_mv_per_anatomical_synapse": { + "author": 0.275, + "case": 0.275 + } + }, + "poisson_helper_used": false, + "precision": "float64", + "queue_trace_enabled": true, + "request_interface": "before_thresholds; v=v_th+1mV only if not_refractory", + "source_parameters_modified": false, + "source_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "state_units": "SI volts, original dtype", + "steps": 500 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float64/instrumented/queue-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float64/instrumented/queue-audit.json new file mode 100644 index 0000000..a7a85fb --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float64/instrumented/queue-audit.json @@ -0,0 +1,14 @@ +{ + "accepted_due_events": 839, + "advance_calls": 500, + "all_due_events_preserved": true, + "due_events": 930, + "installations": [ + "default_synapses_pre_codeobject", + "default_synapses_pre_codeobject_3" + ], + "ordering": "raw anatomical queue.peek local edge-index sequence; no sorting or filtering", + "peek_calls": 500, + "proxy_contract": "peek returns original object; advance and all other methods forward unchanged", + "trace_enabled": true +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float64/instrumented/schedule.json b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float64/instrumented/schedule.json new file mode 100644 index 0000000..93e03d3 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float64/instrumented/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_common_requests (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 \nzz_oracle_queue_installer (QueueInstaller) | -- | 100. us (every step) | end | 1000000 | yes " +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float64/proxy-validation.json b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float64/proxy-validation.json new file mode 100644 index 0000000..50c684d --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float64/proxy-validation.json @@ -0,0 +1,33 @@ +{ + "arrival_arrays_excluded": "An unwrapped queue is deliberately not observed", + "exact_arrays": { + "applicable_count": true, + "coefficients": true, + "counts": true, + "external_accepted": true, + "external_step": true, + "external_target": true, + "external_weights": true, + "fired": true, + "g": true, + "history": true, + "initial_g": true, + "initial_v": true, + "local_idx": true, + "neuron_idx": true, + "nodes": true, + "not_refractory": true, + "ref": true, + "ref_history": true, + "rejected_count": true, + "request_accepted": true, + "request_attempted": true, + "request_count": true, + "request_rejected": true, + "step": true, + "v": true, + "weights": true + }, + "pass": true, + "performed": true +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float64/summary.json b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float64/summary.json new file mode 100644 index 0000000..972e31c --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float64/summary.json @@ -0,0 +1,18 @@ +{ + "applicable_requests": 96, + "coefficient_file": "/data/digital-drosophila/experiments/phase4ae-author-runtime/oracle/highest_indegree-float64/coefficients.json", + "complete": true, + "due_arrivals": 930, + "edges": 320, + "name": "highest_indegree", + "nodes": 128, + "precision": "float64", + "queue_proxy_validated": true, + "queue_trace_enabled": true, + "rejected_requests": 0, + "requests": 96, + "source_unchanged": true, + "spikes": 101, + "state_file": "/data/digital-drosophila/experiments/phase4ae-author-runtime/oracle/highest_indegree-float64/state.npz", + "steps": 500 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float64/unwrapped-audit/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float64/unwrapped-audit/coefficients.json new file mode 100644 index 0000000..30742b3 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float64/unwrapped-audit/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_4", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_4", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_4", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_4", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_4", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_4", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float64/unwrapped-audit/compiled-code.json b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float64/unwrapped-audit/compiled-code.json new file mode 100644 index 0000000..9a4ea64 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float64/unwrapped-audit/compiled-code.json @@ -0,0 +1,114 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float64/unwrapped-audit/completeness.csv b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float64/unwrapped-audit/completeness.csv new file mode 100644 index 0000000..adc3c09 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float64/unwrapped-audit/completeness.csv @@ -0,0 +1,129 @@ +global_neuron_idx,local_index +5,0 +21,1 +494,2 +775,3 +1572,4 +52515,5 +57252,6 +59937,7 +60155,8 +60450,9 +60737,10 +61164,11 +61387,12 +61721,13 +61804,14 +61941,15 +62257,16 +62700,17 +62734,18 +62795,19 +62888,20 +63041,21 +63106,22 +63173,23 +63287,24 +63339,25 +63918,26 +64210,27 +64233,28 +64443,29 +64514,30 +65001,31 +65235,32 +65262,33 +65374,34 +65565,35 +65691,36 +65742,37 +66003,38 +66127,39 +66225,40 +66237,41 +66541,42 +66598,43 +66843,44 +66958,45 +67072,46 +67135,47 +67241,48 +67284,49 +67324,50 +67373,51 +67453,52 +67483,53 +67537,54 +67594,55 +68056,56 +68074,57 +68192,58 +68199,59 +68355,60 +68543,61 +68617,62 +68656,63 +68838,64 +68856,65 +68869,66 +69139,67 +69415,68 +69516,69 +69540,70 +69809,71 +69860,72 +69966,73 +69982,74 +70036,75 +70202,76 +70316,77 +70561,78 +70626,79 +70744,80 +70783,81 +70897,82 +70977,83 +70995,84 +71060,85 +71120,86 +71215,87 +71267,88 +71346,89 +71440,90 +71456,91 +71738,92 +72060,93 +72219,94 +72322,95 +72365,96 +72473,97 +72485,98 +72578,99 +73026,100 +73221,101 +73544,102 +73653,103 +73903,104 +74495,105 +74818,106 +74995,107 +75925,108 +76961,109 +77090,110 +77291,111 +77444,112 +78506,113 +78574,114 +80691,115 +85419,116 +91986,117 +97175,118 +98515,119 +101566,120 +102237,121 +104598,122 +105190,123 +105260,124 +106136,125 +137444,126 +140350,127 diff --git a/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float64/unwrapped-audit/generated-code.json b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float64/unwrapped-audit/generated-code.json new file mode 100644 index 0000000..6df8850 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float64/unwrapped-audit/generated-code.json @@ -0,0 +1,114 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject_4" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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_1" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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_1" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float64/unwrapped-audit/input-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float64/unwrapped-audit/input-audit.json new file mode 100644 index 0000000..de73408 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float64/unwrapped-audit/input-audit.json @@ -0,0 +1,48 @@ +{ + "all_neurons_keep_original_rfc": true, + "completeness_sha256": "e90a4d12741fbd0bd0b5fdcf447c2664f7dfcdba7930f4e9e7f05811f0b530f4", + "connectivity_sha256": "1228ee73ad73051748dd1db62b5063c005471667fd8baacd6a9e76b134024800", + "dt_ms": 0.1, + "parameter_checks": { + "membrane_tau_ms": { + "author": 20.0, + "case": 20.0 + }, + "refractory_ms": { + "author": 2.2, + "case": 2.2 + }, + "reset_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "resting_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "synaptic_delay_ms": { + "author": 1.8, + "case": 1.8 + }, + "synaptic_tau_ms": { + "author": 5.0, + "case": 5.0 + }, + "threshold_mv": { + "author": -45.0, + "case": -45.0 + }, + "w_syn_mv_per_anatomical_synapse": { + "author": 0.275, + "case": 0.275 + } + }, + "poisson_helper_used": false, + "precision": "float64", + "queue_trace_enabled": false, + "request_interface": "before_thresholds; v=v_th+1mV only if not_refractory", + "source_parameters_modified": false, + "source_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "state_units": "SI volts, original dtype", + "steps": 500 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float64/unwrapped-audit/queue-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float64/unwrapped-audit/queue-audit.json new file mode 100644 index 0000000..6d2ed14 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float64/unwrapped-audit/queue-audit.json @@ -0,0 +1,11 @@ +{ + "accepted_due_events": 0, + "advance_calls": 0, + "all_due_events_preserved": null, + "due_events": 0, + "installations": [], + "ordering": "raw anatomical queue.peek local edge-index sequence; no sorting or filtering", + "peek_calls": 0, + "proxy_contract": "peek returns original object; advance and all other methods forward unchanged", + "trace_enabled": false +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float64/unwrapped-audit/schedule.json b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float64/unwrapped-audit/schedule.json new file mode 100644 index 0000000..4202f07 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/highest_indegree-float64/unwrapped-audit/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_common_requests (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 " +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float32/case.json b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float32/case.json new file mode 100644 index 0000000..a070983 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float32/case.json @@ -0,0 +1,59 @@ +{ + "author_commit": "91bdd1e7dcf193f3e7ca5a8933497fcef63b7960", + "author_path": "/data/digital-drosophila/experiments/phase4ad-author-semantics/external-resources/model.py", + "author_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "case_arrays_sha256": "63fb734a967aee5f77709788ad9bd7d8783c2209c34f0e1d9aa6a0a8b7a6ecf5", + "case_spec_sha256": "11f07dd0a3e62b6ee66373022539a68daad766dce26fa759654f0201599f6703", + "common_interface_preserved": true, + "learning": false, + "original_poi_interface_adopted": false, + "precision": "float32", + "spec": { + "description": "Deterministically selected real induced graph; canonical edge IDs/counts and frozen signs.", + "dt_ms": 0.1, + "duration_ms": 50.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 + }, + "name": "mixed_high_indegree", + "selection": { + "global_in_degree": 11526, + "negative_in_edges": 1403, + "positive_in_edges": 10076, + "stimulated_neuron_idx": [ + 494, + 775, + 61804, + 62257, + 62700, + 62795, + 63041, + 65262, + 66225, + 66237, + 67241, + 67324, + 67373, + 68199, + 68856, + 70626 + ], + "target_body_id": 10009, + "target_neuron_idx": 5 + }, + "steps": 500, + "trace_queue": true, + "validate_queue_proxy": true + }, + "trace_queue": true, + "validate_queue_proxy": true, + "whole_brain": false +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float32/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float32/coefficients.json new file mode 100644 index 0000000..fa2e6a3 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float32/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_7", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_7", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_7", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_7", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_7", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_7", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float32/environment.json b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float32/environment.json new file mode 100644 index 0000000..7b43f4f --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float32/environment.json @@ -0,0 +1,14 @@ +{ + "backend": "Brian2 numpy runtime", + "packages": { + "brian2": "2.5.1", + "cython": "0.29.33", + "numpy": "1.22.3", + "pandas": "1.4.3", + "pyarrow": "11.0.0", + "scipy": "1.8.1", + "sympy": "1.12" + }, + "platform": "Linux-5.15.0-194-generic-x86_64-with-glibc2.35", + "python": "3.10.12 (main, Aug 31 2026, 10:18:17) [GCC 11.4.0]" +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float32/instrumented/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float32/instrumented/coefficients.json new file mode 100644 index 0000000..fa2e6a3 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float32/instrumented/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_7", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_7", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_7", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_7", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_7", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_7", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float32/instrumented/compiled-code.json b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float32/instrumented/compiled-code.json new file mode 100644 index 0000000..3b9afa3 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float32/instrumented/compiled-code.json @@ -0,0 +1,122 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + }, + { + "active": true, + "code_objects": [], + "name": "zz_oracle_queue_installer", + "order": 1000000, + "type": "QueueInstaller", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float32/instrumented/completeness.csv b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float32/instrumented/completeness.csv new file mode 100644 index 0000000..a37ef77 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float32/instrumented/completeness.csv @@ -0,0 +1,129 @@ +global_neuron_idx,local_index +5,0 +21,1 +44,2 +494,3 +775,4 +1572,5 +6667,6 +15460,7 +18811,8 +40937,9 +41813,10 +42005,11 +45077,12 +45449,13 +47004,14 +47028,15 +47491,16 +47754,17 +47782,18 +48155,19 +48221,20 +48947,21 +49476,22 +49706,23 +49809,24 +50350,25 +50455,26 +50561,27 +50622,28 +50734,29 +51102,30 +51157,31 +51608,32 +52222,33 +52352,34 +52494,35 +52515,36 +53063,37 +53324,38 +54010,39 +55100,40 +56539,41 +57201,42 +57252,43 +57612,44 +59164,45 +59365,46 +60182,47 +60450,48 +61164,49 +61707,50 +61721,51 +61804,52 +62257,53 +62700,54 +62734,55 +62795,56 +63041,57 +63173,58 +63287,59 +63339,60 +63918,61 +64210,62 +64233,63 +64335,64 +64514,65 +65262,66 +65848,67 +66225,68 +66237,69 +66541,70 +66598,71 +67072,72 +67241,73 +67284,74 +67324,75 +67373,76 +67453,77 +67537,78 +67594,79 +68074,80 +68199,81 +68506,82 +68617,83 +68656,84 +68785,85 +68856,86 +69139,87 +69462,88 +69516,89 +69809,90 +69860,91 +69887,92 +70316,93 +70626,94 +70662,95 +70897,96 +70959,97 +70995,98 +71060,99 +71215,100 +71267,101 +71440,102 +71456,103 +72060,104 +72275,105 +72322,106 +72365,107 +72473,108 +72485,109 +73026,110 +73544,111 +74878,112 +74995,113 +77390,114 +78506,115 +84964,116 +87611,117 +88823,118 +89271,119 +91986,120 +96731,121 +96909,122 +97175,123 +104999,124 +105260,125 +137444,126 +140350,127 diff --git a/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float32/instrumented/generated-code.json b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float32/instrumented/generated-code.json new file mode 100644 index 0000000..3af481d --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float32/instrumented/generated-code.json @@ -0,0 +1,122 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject_7" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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_1" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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_1" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + }, + { + "active": true, + "code_objects": [], + "name": "zz_oracle_queue_installer", + "order": 1000000, + "type": "QueueInstaller", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float32/instrumented/input-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float32/instrumented/input-audit.json new file mode 100644 index 0000000..7019cd1 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float32/instrumented/input-audit.json @@ -0,0 +1,48 @@ +{ + "all_neurons_keep_original_rfc": true, + "completeness_sha256": "1f01bd89fa27a1fc11336336d420c1100171017febe074713369fcf51db27363", + "connectivity_sha256": "21e51e4ecca6476d5116cfbf140b1fdd5a4a0a8ee976158f801dee8003f91ae2", + "dt_ms": 0.1, + "parameter_checks": { + "membrane_tau_ms": { + "author": 20.0, + "case": 20.0 + }, + "refractory_ms": { + "author": 2.2, + "case": 2.2 + }, + "reset_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "resting_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "synaptic_delay_ms": { + "author": 1.8, + "case": 1.8 + }, + "synaptic_tau_ms": { + "author": 5.0, + "case": 5.0 + }, + "threshold_mv": { + "author": -45.0, + "case": -45.0 + }, + "w_syn_mv_per_anatomical_synapse": { + "author": 0.275, + "case": 0.275 + } + }, + "poisson_helper_used": false, + "precision": "float32", + "queue_trace_enabled": true, + "request_interface": "before_thresholds; v=v_th+1mV only if not_refractory", + "source_parameters_modified": false, + "source_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "state_units": "SI volts, original dtype", + "steps": 500 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float32/instrumented/queue-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float32/instrumented/queue-audit.json new file mode 100644 index 0000000..69627c2 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float32/instrumented/queue-audit.json @@ -0,0 +1,14 @@ +{ + "accepted_due_events": 556, + "advance_calls": 500, + "all_due_events_preserved": true, + "due_events": 626, + "installations": [ + "default_synapses_pre_codeobject", + "default_synapses_pre_codeobject_7" + ], + "ordering": "raw anatomical queue.peek local edge-index sequence; no sorting or filtering", + "peek_calls": 500, + "proxy_contract": "peek returns original object; advance and all other methods forward unchanged", + "trace_enabled": true +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float32/instrumented/schedule.json b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float32/instrumented/schedule.json new file mode 100644 index 0000000..93e03d3 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float32/instrumented/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_common_requests (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 \nzz_oracle_queue_installer (QueueInstaller) | -- | 100. us (every step) | end | 1000000 | yes " +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float32/proxy-validation.json b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float32/proxy-validation.json new file mode 100644 index 0000000..50c684d --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float32/proxy-validation.json @@ -0,0 +1,33 @@ +{ + "arrival_arrays_excluded": "An unwrapped queue is deliberately not observed", + "exact_arrays": { + "applicable_count": true, + "coefficients": true, + "counts": true, + "external_accepted": true, + "external_step": true, + "external_target": true, + "external_weights": true, + "fired": true, + "g": true, + "history": true, + "initial_g": true, + "initial_v": true, + "local_idx": true, + "neuron_idx": true, + "nodes": true, + "not_refractory": true, + "ref": true, + "ref_history": true, + "rejected_count": true, + "request_accepted": true, + "request_attempted": true, + "request_count": true, + "request_rejected": true, + "step": true, + "v": true, + "weights": true + }, + "pass": true, + "performed": true +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float32/summary.json b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float32/summary.json new file mode 100644 index 0000000..22f7539 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float32/summary.json @@ -0,0 +1,18 @@ +{ + "applicable_requests": 96, + "coefficient_file": "/data/digital-drosophila/experiments/phase4ae-author-runtime/oracle/mixed_high_indegree-float32/coefficients.json", + "complete": true, + "due_arrivals": 626, + "edges": 266, + "name": "mixed_high_indegree", + "nodes": 128, + "precision": "float32", + "queue_proxy_validated": true, + "queue_trace_enabled": true, + "rejected_requests": 0, + "requests": 96, + "source_unchanged": true, + "spikes": 106, + "state_file": "/data/digital-drosophila/experiments/phase4ae-author-runtime/oracle/mixed_high_indegree-float32/state.npz", + "steps": 500 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float32/unwrapped-audit/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float32/unwrapped-audit/coefficients.json new file mode 100644 index 0000000..d5b405e --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float32/unwrapped-audit/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_8", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_8", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_8", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_8", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_8", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_8", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float32/unwrapped-audit/compiled-code.json b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float32/unwrapped-audit/compiled-code.json new file mode 100644 index 0000000..9a4ea64 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float32/unwrapped-audit/compiled-code.json @@ -0,0 +1,114 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float32/unwrapped-audit/completeness.csv b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float32/unwrapped-audit/completeness.csv new file mode 100644 index 0000000..a37ef77 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float32/unwrapped-audit/completeness.csv @@ -0,0 +1,129 @@ +global_neuron_idx,local_index +5,0 +21,1 +44,2 +494,3 +775,4 +1572,5 +6667,6 +15460,7 +18811,8 +40937,9 +41813,10 +42005,11 +45077,12 +45449,13 +47004,14 +47028,15 +47491,16 +47754,17 +47782,18 +48155,19 +48221,20 +48947,21 +49476,22 +49706,23 +49809,24 +50350,25 +50455,26 +50561,27 +50622,28 +50734,29 +51102,30 +51157,31 +51608,32 +52222,33 +52352,34 +52494,35 +52515,36 +53063,37 +53324,38 +54010,39 +55100,40 +56539,41 +57201,42 +57252,43 +57612,44 +59164,45 +59365,46 +60182,47 +60450,48 +61164,49 +61707,50 +61721,51 +61804,52 +62257,53 +62700,54 +62734,55 +62795,56 +63041,57 +63173,58 +63287,59 +63339,60 +63918,61 +64210,62 +64233,63 +64335,64 +64514,65 +65262,66 +65848,67 +66225,68 +66237,69 +66541,70 +66598,71 +67072,72 +67241,73 +67284,74 +67324,75 +67373,76 +67453,77 +67537,78 +67594,79 +68074,80 +68199,81 +68506,82 +68617,83 +68656,84 +68785,85 +68856,86 +69139,87 +69462,88 +69516,89 +69809,90 +69860,91 +69887,92 +70316,93 +70626,94 +70662,95 +70897,96 +70959,97 +70995,98 +71060,99 +71215,100 +71267,101 +71440,102 +71456,103 +72060,104 +72275,105 +72322,106 +72365,107 +72473,108 +72485,109 +73026,110 +73544,111 +74878,112 +74995,113 +77390,114 +78506,115 +84964,116 +87611,117 +88823,118 +89271,119 +91986,120 +96731,121 +96909,122 +97175,123 +104999,124 +105260,125 +137444,126 +140350,127 diff --git a/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float32/unwrapped-audit/generated-code.json b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float32/unwrapped-audit/generated-code.json new file mode 100644 index 0000000..9169c2f --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float32/unwrapped-audit/generated-code.json @@ -0,0 +1,114 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject_8" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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_1" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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_8" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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_8" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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_1" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float32/unwrapped-audit/input-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float32/unwrapped-audit/input-audit.json new file mode 100644 index 0000000..06c29de --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float32/unwrapped-audit/input-audit.json @@ -0,0 +1,48 @@ +{ + "all_neurons_keep_original_rfc": true, + "completeness_sha256": "1f01bd89fa27a1fc11336336d420c1100171017febe074713369fcf51db27363", + "connectivity_sha256": "21e51e4ecca6476d5116cfbf140b1fdd5a4a0a8ee976158f801dee8003f91ae2", + "dt_ms": 0.1, + "parameter_checks": { + "membrane_tau_ms": { + "author": 20.0, + "case": 20.0 + }, + "refractory_ms": { + "author": 2.2, + "case": 2.2 + }, + "reset_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "resting_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "synaptic_delay_ms": { + "author": 1.8, + "case": 1.8 + }, + "synaptic_tau_ms": { + "author": 5.0, + "case": 5.0 + }, + "threshold_mv": { + "author": -45.0, + "case": -45.0 + }, + "w_syn_mv_per_anatomical_synapse": { + "author": 0.275, + "case": 0.275 + } + }, + "poisson_helper_used": false, + "precision": "float32", + "queue_trace_enabled": false, + "request_interface": "before_thresholds; v=v_th+1mV only if not_refractory", + "source_parameters_modified": false, + "source_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "state_units": "SI volts, original dtype", + "steps": 500 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float32/unwrapped-audit/queue-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float32/unwrapped-audit/queue-audit.json new file mode 100644 index 0000000..6d2ed14 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float32/unwrapped-audit/queue-audit.json @@ -0,0 +1,11 @@ +{ + "accepted_due_events": 0, + "advance_calls": 0, + "all_due_events_preserved": null, + "due_events": 0, + "installations": [], + "ordering": "raw anatomical queue.peek local edge-index sequence; no sorting or filtering", + "peek_calls": 0, + "proxy_contract": "peek returns original object; advance and all other methods forward unchanged", + "trace_enabled": false +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float32/unwrapped-audit/schedule.json b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float32/unwrapped-audit/schedule.json new file mode 100644 index 0000000..4202f07 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float32/unwrapped-audit/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_common_requests (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 " +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float64/case.json b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float64/case.json new file mode 100644 index 0000000..53b56c8 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float64/case.json @@ -0,0 +1,59 @@ +{ + "author_commit": "91bdd1e7dcf193f3e7ca5a8933497fcef63b7960", + "author_path": "/data/digital-drosophila/experiments/phase4ad-author-semantics/external-resources/model.py", + "author_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "case_arrays_sha256": "63fb734a967aee5f77709788ad9bd7d8783c2209c34f0e1d9aa6a0a8b7a6ecf5", + "case_spec_sha256": "11f07dd0a3e62b6ee66373022539a68daad766dce26fa759654f0201599f6703", + "common_interface_preserved": true, + "learning": false, + "original_poi_interface_adopted": false, + "precision": "float64", + "spec": { + "description": "Deterministically selected real induced graph; canonical edge IDs/counts and frozen signs.", + "dt_ms": 0.1, + "duration_ms": 50.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 + }, + "name": "mixed_high_indegree", + "selection": { + "global_in_degree": 11526, + "negative_in_edges": 1403, + "positive_in_edges": 10076, + "stimulated_neuron_idx": [ + 494, + 775, + 61804, + 62257, + 62700, + 62795, + 63041, + 65262, + 66225, + 66237, + 67241, + 67324, + 67373, + 68199, + 68856, + 70626 + ], + "target_body_id": 10009, + "target_neuron_idx": 5 + }, + "steps": 500, + "trace_queue": true, + "validate_queue_proxy": true + }, + "trace_queue": true, + "validate_queue_proxy": true, + "whole_brain": false +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float64/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float64/coefficients.json new file mode 100644 index 0000000..51dff3f --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float64/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_6", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_6", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_6", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_6", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_6", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_6", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float64/environment.json b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float64/environment.json new file mode 100644 index 0000000..7b43f4f --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float64/environment.json @@ -0,0 +1,14 @@ +{ + "backend": "Brian2 numpy runtime", + "packages": { + "brian2": "2.5.1", + "cython": "0.29.33", + "numpy": "1.22.3", + "pandas": "1.4.3", + "pyarrow": "11.0.0", + "scipy": "1.8.1", + "sympy": "1.12" + }, + "platform": "Linux-5.15.0-194-generic-x86_64-with-glibc2.35", + "python": "3.10.12 (main, Aug 31 2026, 10:18:17) [GCC 11.4.0]" +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float64/instrumented/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float64/instrumented/coefficients.json new file mode 100644 index 0000000..51dff3f --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float64/instrumented/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_6", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_6", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_6", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_6", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_6", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_6", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float64/instrumented/compiled-code.json b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float64/instrumented/compiled-code.json new file mode 100644 index 0000000..3b9afa3 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float64/instrumented/compiled-code.json @@ -0,0 +1,122 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + }, + { + "active": true, + "code_objects": [], + "name": "zz_oracle_queue_installer", + "order": 1000000, + "type": "QueueInstaller", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float64/instrumented/completeness.csv b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float64/instrumented/completeness.csv new file mode 100644 index 0000000..a37ef77 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float64/instrumented/completeness.csv @@ -0,0 +1,129 @@ +global_neuron_idx,local_index +5,0 +21,1 +44,2 +494,3 +775,4 +1572,5 +6667,6 +15460,7 +18811,8 +40937,9 +41813,10 +42005,11 +45077,12 +45449,13 +47004,14 +47028,15 +47491,16 +47754,17 +47782,18 +48155,19 +48221,20 +48947,21 +49476,22 +49706,23 +49809,24 +50350,25 +50455,26 +50561,27 +50622,28 +50734,29 +51102,30 +51157,31 +51608,32 +52222,33 +52352,34 +52494,35 +52515,36 +53063,37 +53324,38 +54010,39 +55100,40 +56539,41 +57201,42 +57252,43 +57612,44 +59164,45 +59365,46 +60182,47 +60450,48 +61164,49 +61707,50 +61721,51 +61804,52 +62257,53 +62700,54 +62734,55 +62795,56 +63041,57 +63173,58 +63287,59 +63339,60 +63918,61 +64210,62 +64233,63 +64335,64 +64514,65 +65262,66 +65848,67 +66225,68 +66237,69 +66541,70 +66598,71 +67072,72 +67241,73 +67284,74 +67324,75 +67373,76 +67453,77 +67537,78 +67594,79 +68074,80 +68199,81 +68506,82 +68617,83 +68656,84 +68785,85 +68856,86 +69139,87 +69462,88 +69516,89 +69809,90 +69860,91 +69887,92 +70316,93 +70626,94 +70662,95 +70897,96 +70959,97 +70995,98 +71060,99 +71215,100 +71267,101 +71440,102 +71456,103 +72060,104 +72275,105 +72322,106 +72365,107 +72473,108 +72485,109 +73026,110 +73544,111 +74878,112 +74995,113 +77390,114 +78506,115 +84964,116 +87611,117 +88823,118 +89271,119 +91986,120 +96731,121 +96909,122 +97175,123 +104999,124 +105260,125 +137444,126 +140350,127 diff --git a/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float64/instrumented/generated-code.json b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float64/instrumented/generated-code.json new file mode 100644 index 0000000..83b34d6 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float64/instrumented/generated-code.json @@ -0,0 +1,122 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject_6" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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_1" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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_1" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + }, + { + "active": true, + "code_objects": [], + "name": "zz_oracle_queue_installer", + "order": 1000000, + "type": "QueueInstaller", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float64/instrumented/input-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float64/instrumented/input-audit.json new file mode 100644 index 0000000..56ab514 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float64/instrumented/input-audit.json @@ -0,0 +1,48 @@ +{ + "all_neurons_keep_original_rfc": true, + "completeness_sha256": "1f01bd89fa27a1fc11336336d420c1100171017febe074713369fcf51db27363", + "connectivity_sha256": "21e51e4ecca6476d5116cfbf140b1fdd5a4a0a8ee976158f801dee8003f91ae2", + "dt_ms": 0.1, + "parameter_checks": { + "membrane_tau_ms": { + "author": 20.0, + "case": 20.0 + }, + "refractory_ms": { + "author": 2.2, + "case": 2.2 + }, + "reset_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "resting_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "synaptic_delay_ms": { + "author": 1.8, + "case": 1.8 + }, + "synaptic_tau_ms": { + "author": 5.0, + "case": 5.0 + }, + "threshold_mv": { + "author": -45.0, + "case": -45.0 + }, + "w_syn_mv_per_anatomical_synapse": { + "author": 0.275, + "case": 0.275 + } + }, + "poisson_helper_used": false, + "precision": "float64", + "queue_trace_enabled": true, + "request_interface": "before_thresholds; v=v_th+1mV only if not_refractory", + "source_parameters_modified": false, + "source_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "state_units": "SI volts, original dtype", + "steps": 500 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float64/instrumented/queue-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float64/instrumented/queue-audit.json new file mode 100644 index 0000000..399a438 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float64/instrumented/queue-audit.json @@ -0,0 +1,14 @@ +{ + "accepted_due_events": 556, + "advance_calls": 500, + "all_due_events_preserved": true, + "due_events": 626, + "installations": [ + "default_synapses_pre_codeobject", + "default_synapses_pre_codeobject_6" + ], + "ordering": "raw anatomical queue.peek local edge-index sequence; no sorting or filtering", + "peek_calls": 500, + "proxy_contract": "peek returns original object; advance and all other methods forward unchanged", + "trace_enabled": true +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float64/instrumented/schedule.json b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float64/instrumented/schedule.json new file mode 100644 index 0000000..93e03d3 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float64/instrumented/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_common_requests (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 \nzz_oracle_queue_installer (QueueInstaller) | -- | 100. us (every step) | end | 1000000 | yes " +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float64/proxy-validation.json b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float64/proxy-validation.json new file mode 100644 index 0000000..50c684d --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float64/proxy-validation.json @@ -0,0 +1,33 @@ +{ + "arrival_arrays_excluded": "An unwrapped queue is deliberately not observed", + "exact_arrays": { + "applicable_count": true, + "coefficients": true, + "counts": true, + "external_accepted": true, + "external_step": true, + "external_target": true, + "external_weights": true, + "fired": true, + "g": true, + "history": true, + "initial_g": true, + "initial_v": true, + "local_idx": true, + "neuron_idx": true, + "nodes": true, + "not_refractory": true, + "ref": true, + "ref_history": true, + "rejected_count": true, + "request_accepted": true, + "request_attempted": true, + "request_count": true, + "request_rejected": true, + "step": true, + "v": true, + "weights": true + }, + "pass": true, + "performed": true +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float64/summary.json b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float64/summary.json new file mode 100644 index 0000000..a5210b9 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float64/summary.json @@ -0,0 +1,18 @@ +{ + "applicable_requests": 96, + "coefficient_file": "/data/digital-drosophila/experiments/phase4ae-author-runtime/oracle/mixed_high_indegree-float64/coefficients.json", + "complete": true, + "due_arrivals": 626, + "edges": 266, + "name": "mixed_high_indegree", + "nodes": 128, + "precision": "float64", + "queue_proxy_validated": true, + "queue_trace_enabled": true, + "rejected_requests": 0, + "requests": 96, + "source_unchanged": true, + "spikes": 106, + "state_file": "/data/digital-drosophila/experiments/phase4ae-author-runtime/oracle/mixed_high_indegree-float64/state.npz", + "steps": 500 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float64/unwrapped-audit/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float64/unwrapped-audit/coefficients.json new file mode 100644 index 0000000..0d1775a --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float64/unwrapped-audit/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_5", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_5", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_5", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_5", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_5", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_5", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float64/unwrapped-audit/compiled-code.json b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float64/unwrapped-audit/compiled-code.json new file mode 100644 index 0000000..9a4ea64 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float64/unwrapped-audit/compiled-code.json @@ -0,0 +1,114 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float64/unwrapped-audit/completeness.csv b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float64/unwrapped-audit/completeness.csv new file mode 100644 index 0000000..a37ef77 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float64/unwrapped-audit/completeness.csv @@ -0,0 +1,129 @@ +global_neuron_idx,local_index +5,0 +21,1 +44,2 +494,3 +775,4 +1572,5 +6667,6 +15460,7 +18811,8 +40937,9 +41813,10 +42005,11 +45077,12 +45449,13 +47004,14 +47028,15 +47491,16 +47754,17 +47782,18 +48155,19 +48221,20 +48947,21 +49476,22 +49706,23 +49809,24 +50350,25 +50455,26 +50561,27 +50622,28 +50734,29 +51102,30 +51157,31 +51608,32 +52222,33 +52352,34 +52494,35 +52515,36 +53063,37 +53324,38 +54010,39 +55100,40 +56539,41 +57201,42 +57252,43 +57612,44 +59164,45 +59365,46 +60182,47 +60450,48 +61164,49 +61707,50 +61721,51 +61804,52 +62257,53 +62700,54 +62734,55 +62795,56 +63041,57 +63173,58 +63287,59 +63339,60 +63918,61 +64210,62 +64233,63 +64335,64 +64514,65 +65262,66 +65848,67 +66225,68 +66237,69 +66541,70 +66598,71 +67072,72 +67241,73 +67284,74 +67324,75 +67373,76 +67453,77 +67537,78 +67594,79 +68074,80 +68199,81 +68506,82 +68617,83 +68656,84 +68785,85 +68856,86 +69139,87 +69462,88 +69516,89 +69809,90 +69860,91 +69887,92 +70316,93 +70626,94 +70662,95 +70897,96 +70959,97 +70995,98 +71060,99 +71215,100 +71267,101 +71440,102 +71456,103 +72060,104 +72275,105 +72322,106 +72365,107 +72473,108 +72485,109 +73026,110 +73544,111 +74878,112 +74995,113 +77390,114 +78506,115 +84964,116 +87611,117 +88823,118 +89271,119 +91986,120 +96731,121 +96909,122 +97175,123 +104999,124 +105260,125 +137444,126 +140350,127 diff --git a/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float64/unwrapped-audit/generated-code.json b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float64/unwrapped-audit/generated-code.json new file mode 100644 index 0000000..4ed124c --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float64/unwrapped-audit/generated-code.json @@ -0,0 +1,114 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject_5" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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_1" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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_1" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float64/unwrapped-audit/input-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float64/unwrapped-audit/input-audit.json new file mode 100644 index 0000000..e90737e --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float64/unwrapped-audit/input-audit.json @@ -0,0 +1,48 @@ +{ + "all_neurons_keep_original_rfc": true, + "completeness_sha256": "1f01bd89fa27a1fc11336336d420c1100171017febe074713369fcf51db27363", + "connectivity_sha256": "21e51e4ecca6476d5116cfbf140b1fdd5a4a0a8ee976158f801dee8003f91ae2", + "dt_ms": 0.1, + "parameter_checks": { + "membrane_tau_ms": { + "author": 20.0, + "case": 20.0 + }, + "refractory_ms": { + "author": 2.2, + "case": 2.2 + }, + "reset_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "resting_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "synaptic_delay_ms": { + "author": 1.8, + "case": 1.8 + }, + "synaptic_tau_ms": { + "author": 5.0, + "case": 5.0 + }, + "threshold_mv": { + "author": -45.0, + "case": -45.0 + }, + "w_syn_mv_per_anatomical_synapse": { + "author": 0.275, + "case": 0.275 + } + }, + "poisson_helper_used": false, + "precision": "float64", + "queue_trace_enabled": false, + "request_interface": "before_thresholds; v=v_th+1mV only if not_refractory", + "source_parameters_modified": false, + "source_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "state_units": "SI volts, original dtype", + "steps": 500 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float64/unwrapped-audit/queue-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float64/unwrapped-audit/queue-audit.json new file mode 100644 index 0000000..6d2ed14 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float64/unwrapped-audit/queue-audit.json @@ -0,0 +1,11 @@ +{ + "accepted_due_events": 0, + "advance_calls": 0, + "all_due_events_preserved": null, + "due_events": 0, + "installations": [], + "ordering": "raw anatomical queue.peek local edge-index sequence; no sorting or filtering", + "peek_calls": 0, + "proxy_contract": "peek returns original object; advance and all other methods forward unchanged", + "trace_enabled": false +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float64/unwrapped-audit/schedule.json b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float64/unwrapped-audit/schedule.json new file mode 100644 index 0000000..4202f07 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/mixed_high_indegree-float64/unwrapped-audit/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_common_requests (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 " +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float32/case.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float32/case.json new file mode 100644 index 0000000..18e5dbd --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float32/case.json @@ -0,0 +1,35 @@ +{ + "author_commit": "91bdd1e7dcf193f3e7ca5a8933497fcef63b7960", + "author_path": "/data/digital-drosophila/experiments/phase4ad-author-semantics/external-resources/model.py", + "author_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "case_arrays_sha256": "cdba32792924258112a2fd6ffaca5e329c71404840a290a9187e5d3e2b6550d4", + "case_spec_sha256": "1bb9ef28864e46336581d23fc15eaf80a329ee4d1a439abd0fc18c52f87a2b77", + "common_interface_preserved": true, + "learning": false, + "original_poi_interface_adopted": false, + "precision": "float32", + "spec": { + "description": "Same selected4AC/4AD motif,100ms prefix; no new edge or weight.", + "dt_ms": 0.1, + "duration_ms": 100.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 + }, + "name": "motif_feedforward", + "selection": null, + "steps": 1000, + "trace_queue": true, + "validate_queue_proxy": true + }, + "trace_queue": true, + "validate_queue_proxy": true, + "whole_brain": false +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float32/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float32/coefficients.json new file mode 100644 index 0000000..d5b405e --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float32/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_8", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_8", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_8", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_8", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_8", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_8", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float32/environment.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float32/environment.json new file mode 100644 index 0000000..7b43f4f --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float32/environment.json @@ -0,0 +1,14 @@ +{ + "backend": "Brian2 numpy runtime", + "packages": { + "brian2": "2.5.1", + "cython": "0.29.33", + "numpy": "1.22.3", + "pandas": "1.4.3", + "pyarrow": "11.0.0", + "scipy": "1.8.1", + "sympy": "1.12" + }, + "platform": "Linux-5.15.0-194-generic-x86_64-with-glibc2.35", + "python": "3.10.12 (main, Aug 31 2026, 10:18:17) [GCC 11.4.0]" +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float32/instrumented/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float32/instrumented/coefficients.json new file mode 100644 index 0000000..d5b405e --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float32/instrumented/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_8", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_8", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_8", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_8", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_8", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_8", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float32/instrumented/compiled-code.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float32/instrumented/compiled-code.json new file mode 100644 index 0000000..3b9afa3 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float32/instrumented/compiled-code.json @@ -0,0 +1,122 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + }, + { + "active": true, + "code_objects": [], + "name": "zz_oracle_queue_installer", + "order": 1000000, + "type": "QueueInstaller", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float32/instrumented/completeness.csv b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float32/instrumented/completeness.csv new file mode 100644 index 0000000..9592749 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float32/instrumented/completeness.csv @@ -0,0 +1,6 @@ +global_neuron_idx,local_index +1197,0 +1381,1 +1511,2 +82312,3 +133666,4 diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float32/instrumented/generated-code.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float32/instrumented/generated-code.json new file mode 100644 index 0000000..4adc7ce --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float32/instrumented/generated-code.json @@ -0,0 +1,122 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject_8" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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_1" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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_8" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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_8" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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_1" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + }, + { + "active": true, + "code_objects": [], + "name": "zz_oracle_queue_installer", + "order": 1000000, + "type": "QueueInstaller", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float32/instrumented/input-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float32/instrumented/input-audit.json new file mode 100644 index 0000000..18babd2 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float32/instrumented/input-audit.json @@ -0,0 +1,48 @@ +{ + "all_neurons_keep_original_rfc": true, + "completeness_sha256": "301ae4572c658aa307fc998e009377e9c82467d97d66aa1ac4b3f518385ec5a5", + "connectivity_sha256": "627406997fa994afffa6c4df18cc584c43f4161b389a6669c2ceb64e5ae9dcd1", + "dt_ms": 0.1, + "parameter_checks": { + "membrane_tau_ms": { + "author": 20.0, + "case": 20.0 + }, + "refractory_ms": { + "author": 2.2, + "case": 2.2 + }, + "reset_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "resting_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "synaptic_delay_ms": { + "author": 1.8, + "case": 1.8 + }, + "synaptic_tau_ms": { + "author": 5.0, + "case": 5.0 + }, + "threshold_mv": { + "author": -45.0, + "case": -45.0 + }, + "w_syn_mv_per_anatomical_synapse": { + "author": 0.275, + "case": 0.275 + } + }, + "poisson_helper_used": false, + "precision": "float32", + "queue_trace_enabled": true, + "request_interface": "before_thresholds; v=v_th+1mV only if not_refractory", + "source_parameters_modified": false, + "source_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "state_units": "SI volts, original dtype", + "steps": 1000 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float32/instrumented/queue-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float32/instrumented/queue-audit.json new file mode 100644 index 0000000..a48f1fe --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float32/instrumented/queue-audit.json @@ -0,0 +1,14 @@ +{ + "accepted_due_events": 3, + "advance_calls": 1000, + "all_due_events_preserved": true, + "due_events": 3, + "installations": [ + "default_synapses_pre_codeobject", + "default_synapses_pre_codeobject_8" + ], + "ordering": "raw anatomical queue.peek local edge-index sequence; no sorting or filtering", + "peek_calls": 1000, + "proxy_contract": "peek returns original object; advance and all other methods forward unchanged", + "trace_enabled": true +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float32/instrumented/schedule.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float32/instrumented/schedule.json new file mode 100644 index 0000000..93e03d3 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float32/instrumented/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_common_requests (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 \nzz_oracle_queue_installer (QueueInstaller) | -- | 100. us (every step) | end | 1000000 | yes " +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float32/proxy-validation.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float32/proxy-validation.json new file mode 100644 index 0000000..50c684d --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float32/proxy-validation.json @@ -0,0 +1,33 @@ +{ + "arrival_arrays_excluded": "An unwrapped queue is deliberately not observed", + "exact_arrays": { + "applicable_count": true, + "coefficients": true, + "counts": true, + "external_accepted": true, + "external_step": true, + "external_target": true, + "external_weights": true, + "fired": true, + "g": true, + "history": true, + "initial_g": true, + "initial_v": true, + "local_idx": true, + "neuron_idx": true, + "nodes": true, + "not_refractory": true, + "ref": true, + "ref_history": true, + "rejected_count": true, + "request_accepted": true, + "request_attempted": true, + "request_count": true, + "request_rejected": true, + "step": true, + "v": true, + "weights": true + }, + "pass": true, + "performed": true +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float32/summary.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float32/summary.json new file mode 100644 index 0000000..e734608 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float32/summary.json @@ -0,0 +1,18 @@ +{ + "applicable_requests": 1, + "coefficient_file": "/data/digital-drosophila/experiments/phase4ae-author-runtime/oracle/motif_feedforward-float32/coefficients.json", + "complete": true, + "due_arrivals": 3, + "edges": 4, + "name": "motif_feedforward", + "nodes": 5, + "precision": "float32", + "queue_proxy_validated": true, + "queue_trace_enabled": true, + "rejected_requests": 0, + "requests": 1, + "source_unchanged": true, + "spikes": 3, + "state_file": "/data/digital-drosophila/experiments/phase4ae-author-runtime/oracle/motif_feedforward-float32/state.npz", + "steps": 1000 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float32/unwrapped-audit/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float32/unwrapped-audit/coefficients.json new file mode 100644 index 0000000..de7e02d --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float32/unwrapped-audit/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_9", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_9", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_9", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_9", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_9", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_9", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float32/unwrapped-audit/compiled-code.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float32/unwrapped-audit/compiled-code.json new file mode 100644 index 0000000..9a4ea64 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float32/unwrapped-audit/compiled-code.json @@ -0,0 +1,114 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float32/unwrapped-audit/completeness.csv b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float32/unwrapped-audit/completeness.csv new file mode 100644 index 0000000..9592749 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float32/unwrapped-audit/completeness.csv @@ -0,0 +1,6 @@ +global_neuron_idx,local_index +1197,0 +1381,1 +1511,2 +82312,3 +133666,4 diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float32/unwrapped-audit/generated-code.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float32/unwrapped-audit/generated-code.json new file mode 100644 index 0000000..ad6081c --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float32/unwrapped-audit/generated-code.json @@ -0,0 +1,114 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject_9" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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_9" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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_1" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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_9" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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_9" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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_1" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float32/unwrapped-audit/input-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float32/unwrapped-audit/input-audit.json new file mode 100644 index 0000000..2f13555 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float32/unwrapped-audit/input-audit.json @@ -0,0 +1,48 @@ +{ + "all_neurons_keep_original_rfc": true, + "completeness_sha256": "301ae4572c658aa307fc998e009377e9c82467d97d66aa1ac4b3f518385ec5a5", + "connectivity_sha256": "627406997fa994afffa6c4df18cc584c43f4161b389a6669c2ceb64e5ae9dcd1", + "dt_ms": 0.1, + "parameter_checks": { + "membrane_tau_ms": { + "author": 20.0, + "case": 20.0 + }, + "refractory_ms": { + "author": 2.2, + "case": 2.2 + }, + "reset_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "resting_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "synaptic_delay_ms": { + "author": 1.8, + "case": 1.8 + }, + "synaptic_tau_ms": { + "author": 5.0, + "case": 5.0 + }, + "threshold_mv": { + "author": -45.0, + "case": -45.0 + }, + "w_syn_mv_per_anatomical_synapse": { + "author": 0.275, + "case": 0.275 + } + }, + "poisson_helper_used": false, + "precision": "float32", + "queue_trace_enabled": false, + "request_interface": "before_thresholds; v=v_th+1mV only if not_refractory", + "source_parameters_modified": false, + "source_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "state_units": "SI volts, original dtype", + "steps": 1000 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float32/unwrapped-audit/queue-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float32/unwrapped-audit/queue-audit.json new file mode 100644 index 0000000..6d2ed14 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float32/unwrapped-audit/queue-audit.json @@ -0,0 +1,11 @@ +{ + "accepted_due_events": 0, + "advance_calls": 0, + "all_due_events_preserved": null, + "due_events": 0, + "installations": [], + "ordering": "raw anatomical queue.peek local edge-index sequence; no sorting or filtering", + "peek_calls": 0, + "proxy_contract": "peek returns original object; advance and all other methods forward unchanged", + "trace_enabled": false +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float32/unwrapped-audit/schedule.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float32/unwrapped-audit/schedule.json new file mode 100644 index 0000000..4202f07 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float32/unwrapped-audit/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_common_requests (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 " +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float64/case.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float64/case.json new file mode 100644 index 0000000..7eafa0f --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float64/case.json @@ -0,0 +1,35 @@ +{ + "author_commit": "91bdd1e7dcf193f3e7ca5a8933497fcef63b7960", + "author_path": "/data/digital-drosophila/experiments/phase4ad-author-semantics/external-resources/model.py", + "author_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "case_arrays_sha256": "cdba32792924258112a2fd6ffaca5e329c71404840a290a9187e5d3e2b6550d4", + "case_spec_sha256": "1bb9ef28864e46336581d23fc15eaf80a329ee4d1a439abd0fc18c52f87a2b77", + "common_interface_preserved": true, + "learning": false, + "original_poi_interface_adopted": false, + "precision": "float64", + "spec": { + "description": "Same selected4AC/4AD motif,100ms prefix; no new edge or weight.", + "dt_ms": 0.1, + "duration_ms": 100.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 + }, + "name": "motif_feedforward", + "selection": null, + "steps": 1000, + "trace_queue": true, + "validate_queue_proxy": true + }, + "trace_queue": true, + "validate_queue_proxy": true, + "whole_brain": false +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float64/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float64/coefficients.json new file mode 100644 index 0000000..0d1775a --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float64/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_5", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_5", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_5", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_5", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_5", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_5", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float64/environment.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float64/environment.json new file mode 100644 index 0000000..7b43f4f --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float64/environment.json @@ -0,0 +1,14 @@ +{ + "backend": "Brian2 numpy runtime", + "packages": { + "brian2": "2.5.1", + "cython": "0.29.33", + "numpy": "1.22.3", + "pandas": "1.4.3", + "pyarrow": "11.0.0", + "scipy": "1.8.1", + "sympy": "1.12" + }, + "platform": "Linux-5.15.0-194-generic-x86_64-with-glibc2.35", + "python": "3.10.12 (main, Aug 31 2026, 10:18:17) [GCC 11.4.0]" +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float64/instrumented/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float64/instrumented/coefficients.json new file mode 100644 index 0000000..0d1775a --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float64/instrumented/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_5", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_5", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_5", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_5", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_5", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_5", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float64/instrumented/compiled-code.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float64/instrumented/compiled-code.json new file mode 100644 index 0000000..3b9afa3 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float64/instrumented/compiled-code.json @@ -0,0 +1,122 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + }, + { + "active": true, + "code_objects": [], + "name": "zz_oracle_queue_installer", + "order": 1000000, + "type": "QueueInstaller", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float64/instrumented/completeness.csv b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float64/instrumented/completeness.csv new file mode 100644 index 0000000..9592749 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float64/instrumented/completeness.csv @@ -0,0 +1,6 @@ +global_neuron_idx,local_index +1197,0 +1381,1 +1511,2 +82312,3 +133666,4 diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float64/instrumented/generated-code.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float64/instrumented/generated-code.json new file mode 100644 index 0000000..ee3f79b --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float64/instrumented/generated-code.json @@ -0,0 +1,122 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject_5" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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_1" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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_1" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + }, + { + "active": true, + "code_objects": [], + "name": "zz_oracle_queue_installer", + "order": 1000000, + "type": "QueueInstaller", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float64/instrumented/input-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float64/instrumented/input-audit.json new file mode 100644 index 0000000..14edb4a --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float64/instrumented/input-audit.json @@ -0,0 +1,48 @@ +{ + "all_neurons_keep_original_rfc": true, + "completeness_sha256": "301ae4572c658aa307fc998e009377e9c82467d97d66aa1ac4b3f518385ec5a5", + "connectivity_sha256": "627406997fa994afffa6c4df18cc584c43f4161b389a6669c2ceb64e5ae9dcd1", + "dt_ms": 0.1, + "parameter_checks": { + "membrane_tau_ms": { + "author": 20.0, + "case": 20.0 + }, + "refractory_ms": { + "author": 2.2, + "case": 2.2 + }, + "reset_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "resting_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "synaptic_delay_ms": { + "author": 1.8, + "case": 1.8 + }, + "synaptic_tau_ms": { + "author": 5.0, + "case": 5.0 + }, + "threshold_mv": { + "author": -45.0, + "case": -45.0 + }, + "w_syn_mv_per_anatomical_synapse": { + "author": 0.275, + "case": 0.275 + } + }, + "poisson_helper_used": false, + "precision": "float64", + "queue_trace_enabled": true, + "request_interface": "before_thresholds; v=v_th+1mV only if not_refractory", + "source_parameters_modified": false, + "source_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "state_units": "SI volts, original dtype", + "steps": 1000 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float64/instrumented/queue-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float64/instrumented/queue-audit.json new file mode 100644 index 0000000..46a8604 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float64/instrumented/queue-audit.json @@ -0,0 +1,14 @@ +{ + "accepted_due_events": 3, + "advance_calls": 1000, + "all_due_events_preserved": true, + "due_events": 3, + "installations": [ + "default_synapses_pre_codeobject", + "default_synapses_pre_codeobject_5" + ], + "ordering": "raw anatomical queue.peek local edge-index sequence; no sorting or filtering", + "peek_calls": 1000, + "proxy_contract": "peek returns original object; advance and all other methods forward unchanged", + "trace_enabled": true +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float64/instrumented/schedule.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float64/instrumented/schedule.json new file mode 100644 index 0000000..93e03d3 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float64/instrumented/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_common_requests (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 \nzz_oracle_queue_installer (QueueInstaller) | -- | 100. us (every step) | end | 1000000 | yes " +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float64/proxy-validation.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float64/proxy-validation.json new file mode 100644 index 0000000..50c684d --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float64/proxy-validation.json @@ -0,0 +1,33 @@ +{ + "arrival_arrays_excluded": "An unwrapped queue is deliberately not observed", + "exact_arrays": { + "applicable_count": true, + "coefficients": true, + "counts": true, + "external_accepted": true, + "external_step": true, + "external_target": true, + "external_weights": true, + "fired": true, + "g": true, + "history": true, + "initial_g": true, + "initial_v": true, + "local_idx": true, + "neuron_idx": true, + "nodes": true, + "not_refractory": true, + "ref": true, + "ref_history": true, + "rejected_count": true, + "request_accepted": true, + "request_attempted": true, + "request_count": true, + "request_rejected": true, + "step": true, + "v": true, + "weights": true + }, + "pass": true, + "performed": true +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float64/summary.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float64/summary.json new file mode 100644 index 0000000..19cba59 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float64/summary.json @@ -0,0 +1,18 @@ +{ + "applicable_requests": 1, + "coefficient_file": "/data/digital-drosophila/experiments/phase4ae-author-runtime/oracle/motif_feedforward-float64/coefficients.json", + "complete": true, + "due_arrivals": 3, + "edges": 4, + "name": "motif_feedforward", + "nodes": 5, + "precision": "float64", + "queue_proxy_validated": true, + "queue_trace_enabled": true, + "rejected_requests": 0, + "requests": 1, + "source_unchanged": true, + "spikes": 3, + "state_file": "/data/digital-drosophila/experiments/phase4ae-author-runtime/oracle/motif_feedforward-float64/state.npz", + "steps": 1000 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float64/unwrapped-audit/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float64/unwrapped-audit/coefficients.json new file mode 100644 index 0000000..d5b405e --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float64/unwrapped-audit/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_8", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_8", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_8", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_8", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_8", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_8", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float64/unwrapped-audit/compiled-code.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float64/unwrapped-audit/compiled-code.json new file mode 100644 index 0000000..9a4ea64 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float64/unwrapped-audit/compiled-code.json @@ -0,0 +1,114 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float64/unwrapped-audit/completeness.csv b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float64/unwrapped-audit/completeness.csv new file mode 100644 index 0000000..9592749 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float64/unwrapped-audit/completeness.csv @@ -0,0 +1,6 @@ +global_neuron_idx,local_index +1197,0 +1381,1 +1511,2 +82312,3 +133666,4 diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float64/unwrapped-audit/generated-code.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float64/unwrapped-audit/generated-code.json new file mode 100644 index 0000000..9169c2f --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float64/unwrapped-audit/generated-code.json @@ -0,0 +1,114 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject_8" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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_1" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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_8" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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_8" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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_1" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float64/unwrapped-audit/input-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float64/unwrapped-audit/input-audit.json new file mode 100644 index 0000000..4c63ab8 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float64/unwrapped-audit/input-audit.json @@ -0,0 +1,48 @@ +{ + "all_neurons_keep_original_rfc": true, + "completeness_sha256": "301ae4572c658aa307fc998e009377e9c82467d97d66aa1ac4b3f518385ec5a5", + "connectivity_sha256": "627406997fa994afffa6c4df18cc584c43f4161b389a6669c2ceb64e5ae9dcd1", + "dt_ms": 0.1, + "parameter_checks": { + "membrane_tau_ms": { + "author": 20.0, + "case": 20.0 + }, + "refractory_ms": { + "author": 2.2, + "case": 2.2 + }, + "reset_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "resting_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "synaptic_delay_ms": { + "author": 1.8, + "case": 1.8 + }, + "synaptic_tau_ms": { + "author": 5.0, + "case": 5.0 + }, + "threshold_mv": { + "author": -45.0, + "case": -45.0 + }, + "w_syn_mv_per_anatomical_synapse": { + "author": 0.275, + "case": 0.275 + } + }, + "poisson_helper_used": false, + "precision": "float64", + "queue_trace_enabled": false, + "request_interface": "before_thresholds; v=v_th+1mV only if not_refractory", + "source_parameters_modified": false, + "source_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "state_units": "SI volts, original dtype", + "steps": 1000 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float64/unwrapped-audit/queue-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float64/unwrapped-audit/queue-audit.json new file mode 100644 index 0000000..6d2ed14 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float64/unwrapped-audit/queue-audit.json @@ -0,0 +1,11 @@ +{ + "accepted_due_events": 0, + "advance_calls": 0, + "all_due_events_preserved": null, + "due_events": 0, + "installations": [], + "ordering": "raw anatomical queue.peek local edge-index sequence; no sorting or filtering", + "peek_calls": 0, + "proxy_contract": "peek returns original object; advance and all other methods forward unchanged", + "trace_enabled": false +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float64/unwrapped-audit/schedule.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float64/unwrapped-audit/schedule.json new file mode 100644 index 0000000..4202f07 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_feedforward-float64/unwrapped-audit/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_common_requests (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 " +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float32/case.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float32/case.json new file mode 100644 index 0000000..9afca1c --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float32/case.json @@ -0,0 +1,35 @@ +{ + "author_commit": "91bdd1e7dcf193f3e7ca5a8933497fcef63b7960", + "author_path": "/data/digital-drosophila/experiments/phase4ad-author-semantics/external-resources/model.py", + "author_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "case_arrays_sha256": "712a18275609cc71875e4ea04ca97222de917de9b1d6760f4052e2a3f0dd465e", + "case_spec_sha256": "f78ba9423ed1dfb686cd79a0a003cda0bf9e7603d37e8d318118e08766ece7b3", + "common_interface_preserved": true, + "learning": false, + "original_poi_interface_adopted": false, + "precision": "float32", + "spec": { + "description": "Same selected4AC/4AD motif,100ms prefix; no new edge or weight.", + "dt_ms": 0.1, + "duration_ms": 100.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 + }, + "name": "motif_five", + "selection": null, + "steps": 1000, + "trace_queue": true, + "validate_queue_proxy": true + }, + "trace_queue": true, + "validate_queue_proxy": true, + "whole_brain": false +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float32/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float32/coefficients.json new file mode 100644 index 0000000..82c27ba --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float32/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_11", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_11", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_11", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_11", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_11", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_11", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float32/environment.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float32/environment.json new file mode 100644 index 0000000..7b43f4f --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float32/environment.json @@ -0,0 +1,14 @@ +{ + "backend": "Brian2 numpy runtime", + "packages": { + "brian2": "2.5.1", + "cython": "0.29.33", + "numpy": "1.22.3", + "pandas": "1.4.3", + "pyarrow": "11.0.0", + "scipy": "1.8.1", + "sympy": "1.12" + }, + "platform": "Linux-5.15.0-194-generic-x86_64-with-glibc2.35", + "python": "3.10.12 (main, Aug 31 2026, 10:18:17) [GCC 11.4.0]" +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float32/instrumented/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float32/instrumented/coefficients.json new file mode 100644 index 0000000..82c27ba --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float32/instrumented/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_11", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_11", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_11", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_11", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_11", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_11", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float32/instrumented/compiled-code.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float32/instrumented/compiled-code.json new file mode 100644 index 0000000..3b9afa3 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float32/instrumented/compiled-code.json @@ -0,0 +1,122 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + }, + { + "active": true, + "code_objects": [], + "name": "zz_oracle_queue_installer", + "order": 1000000, + "type": "QueueInstaller", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float32/instrumented/completeness.csv b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float32/instrumented/completeness.csv new file mode 100644 index 0000000..9592749 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float32/instrumented/completeness.csv @@ -0,0 +1,6 @@ +global_neuron_idx,local_index +1197,0 +1381,1 +1511,2 +82312,3 +133666,4 diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float32/instrumented/generated-code.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float32/instrumented/generated-code.json new file mode 100644 index 0000000..2c6a88d --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float32/instrumented/generated-code.json @@ -0,0 +1,122 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject_11" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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_11" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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_1" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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_11" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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_11" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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_1" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + }, + { + "active": true, + "code_objects": [], + "name": "zz_oracle_queue_installer", + "order": 1000000, + "type": "QueueInstaller", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float32/instrumented/input-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float32/instrumented/input-audit.json new file mode 100644 index 0000000..2c51f07 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float32/instrumented/input-audit.json @@ -0,0 +1,48 @@ +{ + "all_neurons_keep_original_rfc": true, + "completeness_sha256": "301ae4572c658aa307fc998e009377e9c82467d97d66aa1ac4b3f518385ec5a5", + "connectivity_sha256": "43ea5a3c6c53315e9265863a6f05b3e6d8e9b9f299aef665e8bbe9c46f9eb2ce", + "dt_ms": 0.1, + "parameter_checks": { + "membrane_tau_ms": { + "author": 20.0, + "case": 20.0 + }, + "refractory_ms": { + "author": 2.2, + "case": 2.2 + }, + "reset_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "resting_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "synaptic_delay_ms": { + "author": 1.8, + "case": 1.8 + }, + "synaptic_tau_ms": { + "author": 5.0, + "case": 5.0 + }, + "threshold_mv": { + "author": -45.0, + "case": -45.0 + }, + "w_syn_mv_per_anatomical_synapse": { + "author": 0.275, + "case": 0.275 + } + }, + "poisson_helper_used": false, + "precision": "float32", + "queue_trace_enabled": true, + "request_interface": "before_thresholds; v=v_th+1mV only if not_refractory", + "source_parameters_modified": false, + "source_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "state_units": "SI volts, original dtype", + "steps": 1000 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float32/instrumented/queue-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float32/instrumented/queue-audit.json new file mode 100644 index 0000000..8476cbd --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float32/instrumented/queue-audit.json @@ -0,0 +1,14 @@ +{ + "accepted_due_events": 155, + "advance_calls": 1000, + "all_due_events_preserved": true, + "due_events": 185, + "installations": [ + "default_synapses_pre_codeobject", + "default_synapses_pre_codeobject_11" + ], + "ordering": "raw anatomical queue.peek local edge-index sequence; no sorting or filtering", + "peek_calls": 1000, + "proxy_contract": "peek returns original object; advance and all other methods forward unchanged", + "trace_enabled": true +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float32/instrumented/schedule.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float32/instrumented/schedule.json new file mode 100644 index 0000000..93e03d3 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float32/instrumented/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_common_requests (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 \nzz_oracle_queue_installer (QueueInstaller) | -- | 100. us (every step) | end | 1000000 | yes " +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float32/proxy-validation.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float32/proxy-validation.json new file mode 100644 index 0000000..50c684d --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float32/proxy-validation.json @@ -0,0 +1,33 @@ +{ + "arrival_arrays_excluded": "An unwrapped queue is deliberately not observed", + "exact_arrays": { + "applicable_count": true, + "coefficients": true, + "counts": true, + "external_accepted": true, + "external_step": true, + "external_target": true, + "external_weights": true, + "fired": true, + "g": true, + "history": true, + "initial_g": true, + "initial_v": true, + "local_idx": true, + "neuron_idx": true, + "nodes": true, + "not_refractory": true, + "ref": true, + "ref_history": true, + "rejected_count": true, + "request_accepted": true, + "request_attempted": true, + "request_count": true, + "request_rejected": true, + "step": true, + "v": true, + "weights": true + }, + "pass": true, + "performed": true +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float32/summary.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float32/summary.json new file mode 100644 index 0000000..f3e0983 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float32/summary.json @@ -0,0 +1,18 @@ +{ + "applicable_requests": 1, + "coefficient_file": "/data/digital-drosophila/experiments/phase4ae-author-runtime/oracle/motif_five-float32/coefficients.json", + "complete": true, + "due_arrivals": 185, + "edges": 13, + "name": "motif_five", + "nodes": 5, + "precision": "float32", + "queue_proxy_validated": true, + "queue_trace_enabled": true, + "rejected_requests": 0, + "requests": 1, + "source_unchanged": true, + "spikes": 60, + "state_file": "/data/digital-drosophila/experiments/phase4ae-author-runtime/oracle/motif_five-float32/state.npz", + "steps": 1000 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float32/unwrapped-audit/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float32/unwrapped-audit/coefficients.json new file mode 100644 index 0000000..f2437a9 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float32/unwrapped-audit/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_12", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_12", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_12", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_12", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_12", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_12", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float32/unwrapped-audit/compiled-code.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float32/unwrapped-audit/compiled-code.json new file mode 100644 index 0000000..9a4ea64 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float32/unwrapped-audit/compiled-code.json @@ -0,0 +1,114 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float32/unwrapped-audit/completeness.csv b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float32/unwrapped-audit/completeness.csv new file mode 100644 index 0000000..9592749 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float32/unwrapped-audit/completeness.csv @@ -0,0 +1,6 @@ +global_neuron_idx,local_index +1197,0 +1381,1 +1511,2 +82312,3 +133666,4 diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float32/unwrapped-audit/generated-code.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float32/unwrapped-audit/generated-code.json new file mode 100644 index 0000000..8762eb7 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float32/unwrapped-audit/generated-code.json @@ -0,0 +1,114 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject_12" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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_12" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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_1" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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_12" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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_12" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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_1" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float32/unwrapped-audit/input-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float32/unwrapped-audit/input-audit.json new file mode 100644 index 0000000..62dd15b --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float32/unwrapped-audit/input-audit.json @@ -0,0 +1,48 @@ +{ + "all_neurons_keep_original_rfc": true, + "completeness_sha256": "301ae4572c658aa307fc998e009377e9c82467d97d66aa1ac4b3f518385ec5a5", + "connectivity_sha256": "43ea5a3c6c53315e9265863a6f05b3e6d8e9b9f299aef665e8bbe9c46f9eb2ce", + "dt_ms": 0.1, + "parameter_checks": { + "membrane_tau_ms": { + "author": 20.0, + "case": 20.0 + }, + "refractory_ms": { + "author": 2.2, + "case": 2.2 + }, + "reset_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "resting_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "synaptic_delay_ms": { + "author": 1.8, + "case": 1.8 + }, + "synaptic_tau_ms": { + "author": 5.0, + "case": 5.0 + }, + "threshold_mv": { + "author": -45.0, + "case": -45.0 + }, + "w_syn_mv_per_anatomical_synapse": { + "author": 0.275, + "case": 0.275 + } + }, + "poisson_helper_used": false, + "precision": "float32", + "queue_trace_enabled": false, + "request_interface": "before_thresholds; v=v_th+1mV only if not_refractory", + "source_parameters_modified": false, + "source_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "state_units": "SI volts, original dtype", + "steps": 1000 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float32/unwrapped-audit/queue-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float32/unwrapped-audit/queue-audit.json new file mode 100644 index 0000000..6d2ed14 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float32/unwrapped-audit/queue-audit.json @@ -0,0 +1,11 @@ +{ + "accepted_due_events": 0, + "advance_calls": 0, + "all_due_events_preserved": null, + "due_events": 0, + "installations": [], + "ordering": "raw anatomical queue.peek local edge-index sequence; no sorting or filtering", + "peek_calls": 0, + "proxy_contract": "peek returns original object; advance and all other methods forward unchanged", + "trace_enabled": false +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float32/unwrapped-audit/schedule.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float32/unwrapped-audit/schedule.json new file mode 100644 index 0000000..4202f07 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float32/unwrapped-audit/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_common_requests (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 " +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float64/case.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float64/case.json new file mode 100644 index 0000000..36c365c --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float64/case.json @@ -0,0 +1,35 @@ +{ + "author_commit": "91bdd1e7dcf193f3e7ca5a8933497fcef63b7960", + "author_path": "/data/digital-drosophila/experiments/phase4ad-author-semantics/external-resources/model.py", + "author_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "case_arrays_sha256": "712a18275609cc71875e4ea04ca97222de917de9b1d6760f4052e2a3f0dd465e", + "case_spec_sha256": "f78ba9423ed1dfb686cd79a0a003cda0bf9e7603d37e8d318118e08766ece7b3", + "common_interface_preserved": true, + "learning": false, + "original_poi_interface_adopted": false, + "precision": "float64", + "spec": { + "description": "Same selected4AC/4AD motif,100ms prefix; no new edge or weight.", + "dt_ms": 0.1, + "duration_ms": 100.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 + }, + "name": "motif_five", + "selection": null, + "steps": 1000, + "trace_queue": true, + "validate_queue_proxy": true + }, + "trace_queue": true, + "validate_queue_proxy": true, + "whole_brain": false +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float64/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float64/coefficients.json new file mode 100644 index 0000000..dfe42e4 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float64/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_10", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_10", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_10", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_10", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_10", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_10", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float64/environment.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float64/environment.json new file mode 100644 index 0000000..7b43f4f --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float64/environment.json @@ -0,0 +1,14 @@ +{ + "backend": "Brian2 numpy runtime", + "packages": { + "brian2": "2.5.1", + "cython": "0.29.33", + "numpy": "1.22.3", + "pandas": "1.4.3", + "pyarrow": "11.0.0", + "scipy": "1.8.1", + "sympy": "1.12" + }, + "platform": "Linux-5.15.0-194-generic-x86_64-with-glibc2.35", + "python": "3.10.12 (main, Aug 31 2026, 10:18:17) [GCC 11.4.0]" +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float64/instrumented/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float64/instrumented/coefficients.json new file mode 100644 index 0000000..dfe42e4 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float64/instrumented/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_10", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_10", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_10", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_10", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_10", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_10", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float64/instrumented/compiled-code.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float64/instrumented/compiled-code.json new file mode 100644 index 0000000..3b9afa3 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float64/instrumented/compiled-code.json @@ -0,0 +1,122 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + }, + { + "active": true, + "code_objects": [], + "name": "zz_oracle_queue_installer", + "order": 1000000, + "type": "QueueInstaller", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float64/instrumented/completeness.csv b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float64/instrumented/completeness.csv new file mode 100644 index 0000000..9592749 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float64/instrumented/completeness.csv @@ -0,0 +1,6 @@ +global_neuron_idx,local_index +1197,0 +1381,1 +1511,2 +82312,3 +133666,4 diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float64/instrumented/generated-code.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float64/instrumented/generated-code.json new file mode 100644 index 0000000..64ec833 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float64/instrumented/generated-code.json @@ -0,0 +1,122 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject_10" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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_10" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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_1" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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_10" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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_10" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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_1" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + }, + { + "active": true, + "code_objects": [], + "name": "zz_oracle_queue_installer", + "order": 1000000, + "type": "QueueInstaller", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float64/instrumented/input-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float64/instrumented/input-audit.json new file mode 100644 index 0000000..9bcbd91 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float64/instrumented/input-audit.json @@ -0,0 +1,48 @@ +{ + "all_neurons_keep_original_rfc": true, + "completeness_sha256": "301ae4572c658aa307fc998e009377e9c82467d97d66aa1ac4b3f518385ec5a5", + "connectivity_sha256": "43ea5a3c6c53315e9265863a6f05b3e6d8e9b9f299aef665e8bbe9c46f9eb2ce", + "dt_ms": 0.1, + "parameter_checks": { + "membrane_tau_ms": { + "author": 20.0, + "case": 20.0 + }, + "refractory_ms": { + "author": 2.2, + "case": 2.2 + }, + "reset_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "resting_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "synaptic_delay_ms": { + "author": 1.8, + "case": 1.8 + }, + "synaptic_tau_ms": { + "author": 5.0, + "case": 5.0 + }, + "threshold_mv": { + "author": -45.0, + "case": -45.0 + }, + "w_syn_mv_per_anatomical_synapse": { + "author": 0.275, + "case": 0.275 + } + }, + "poisson_helper_used": false, + "precision": "float64", + "queue_trace_enabled": true, + "request_interface": "before_thresholds; v=v_th+1mV only if not_refractory", + "source_parameters_modified": false, + "source_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "state_units": "SI volts, original dtype", + "steps": 1000 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float64/instrumented/queue-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float64/instrumented/queue-audit.json new file mode 100644 index 0000000..3a30b2b --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float64/instrumented/queue-audit.json @@ -0,0 +1,14 @@ +{ + "accepted_due_events": 155, + "advance_calls": 1000, + "all_due_events_preserved": true, + "due_events": 185, + "installations": [ + "default_synapses_pre_codeobject", + "default_synapses_pre_codeobject_10" + ], + "ordering": "raw anatomical queue.peek local edge-index sequence; no sorting or filtering", + "peek_calls": 1000, + "proxy_contract": "peek returns original object; advance and all other methods forward unchanged", + "trace_enabled": true +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float64/instrumented/schedule.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float64/instrumented/schedule.json new file mode 100644 index 0000000..93e03d3 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float64/instrumented/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_common_requests (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 \nzz_oracle_queue_installer (QueueInstaller) | -- | 100. us (every step) | end | 1000000 | yes " +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float64/proxy-validation.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float64/proxy-validation.json new file mode 100644 index 0000000..50c684d --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float64/proxy-validation.json @@ -0,0 +1,33 @@ +{ + "arrival_arrays_excluded": "An unwrapped queue is deliberately not observed", + "exact_arrays": { + "applicable_count": true, + "coefficients": true, + "counts": true, + "external_accepted": true, + "external_step": true, + "external_target": true, + "external_weights": true, + "fired": true, + "g": true, + "history": true, + "initial_g": true, + "initial_v": true, + "local_idx": true, + "neuron_idx": true, + "nodes": true, + "not_refractory": true, + "ref": true, + "ref_history": true, + "rejected_count": true, + "request_accepted": true, + "request_attempted": true, + "request_count": true, + "request_rejected": true, + "step": true, + "v": true, + "weights": true + }, + "pass": true, + "performed": true +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float64/summary.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float64/summary.json new file mode 100644 index 0000000..c61fb52 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float64/summary.json @@ -0,0 +1,18 @@ +{ + "applicable_requests": 1, + "coefficient_file": "/data/digital-drosophila/experiments/phase4ae-author-runtime/oracle/motif_five-float64/coefficients.json", + "complete": true, + "due_arrivals": 185, + "edges": 13, + "name": "motif_five", + "nodes": 5, + "precision": "float64", + "queue_proxy_validated": true, + "queue_trace_enabled": true, + "rejected_requests": 0, + "requests": 1, + "source_unchanged": true, + "spikes": 60, + "state_file": "/data/digital-drosophila/experiments/phase4ae-author-runtime/oracle/motif_five-float64/state.npz", + "steps": 1000 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float64/unwrapped-audit/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float64/unwrapped-audit/coefficients.json new file mode 100644 index 0000000..de7e02d --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float64/unwrapped-audit/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_9", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_9", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_9", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_9", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_9", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_9", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float64/unwrapped-audit/compiled-code.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float64/unwrapped-audit/compiled-code.json new file mode 100644 index 0000000..9a4ea64 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float64/unwrapped-audit/compiled-code.json @@ -0,0 +1,114 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float64/unwrapped-audit/completeness.csv b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float64/unwrapped-audit/completeness.csv new file mode 100644 index 0000000..9592749 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float64/unwrapped-audit/completeness.csv @@ -0,0 +1,6 @@ +global_neuron_idx,local_index +1197,0 +1381,1 +1511,2 +82312,3 +133666,4 diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float64/unwrapped-audit/generated-code.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float64/unwrapped-audit/generated-code.json new file mode 100644 index 0000000..ad6081c --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float64/unwrapped-audit/generated-code.json @@ -0,0 +1,114 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject_9" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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_9" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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_1" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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_9" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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_9" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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_1" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float64/unwrapped-audit/input-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float64/unwrapped-audit/input-audit.json new file mode 100644 index 0000000..7fb6318 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float64/unwrapped-audit/input-audit.json @@ -0,0 +1,48 @@ +{ + "all_neurons_keep_original_rfc": true, + "completeness_sha256": "301ae4572c658aa307fc998e009377e9c82467d97d66aa1ac4b3f518385ec5a5", + "connectivity_sha256": "43ea5a3c6c53315e9265863a6f05b3e6d8e9b9f299aef665e8bbe9c46f9eb2ce", + "dt_ms": 0.1, + "parameter_checks": { + "membrane_tau_ms": { + "author": 20.0, + "case": 20.0 + }, + "refractory_ms": { + "author": 2.2, + "case": 2.2 + }, + "reset_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "resting_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "synaptic_delay_ms": { + "author": 1.8, + "case": 1.8 + }, + "synaptic_tau_ms": { + "author": 5.0, + "case": 5.0 + }, + "threshold_mv": { + "author": -45.0, + "case": -45.0 + }, + "w_syn_mv_per_anatomical_synapse": { + "author": 0.275, + "case": 0.275 + } + }, + "poisson_helper_used": false, + "precision": "float64", + "queue_trace_enabled": false, + "request_interface": "before_thresholds; v=v_th+1mV only if not_refractory", + "source_parameters_modified": false, + "source_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "state_units": "SI volts, original dtype", + "steps": 1000 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float64/unwrapped-audit/queue-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float64/unwrapped-audit/queue-audit.json new file mode 100644 index 0000000..6d2ed14 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float64/unwrapped-audit/queue-audit.json @@ -0,0 +1,11 @@ +{ + "accepted_due_events": 0, + "advance_calls": 0, + "all_due_events_preserved": null, + "due_events": 0, + "installations": [], + "ordering": "raw anatomical queue.peek local edge-index sequence; no sorting or filtering", + "peek_calls": 0, + "proxy_contract": "peek returns original object; advance and all other methods forward unchanged", + "trace_enabled": false +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float64/unwrapped-audit/schedule.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float64/unwrapped-audit/schedule.json new file mode 100644 index 0000000..4202f07 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_five-float64/unwrapped-audit/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_common_requests (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 " +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float32/case.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float32/case.json new file mode 100644 index 0000000..b63f0bf --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float32/case.json @@ -0,0 +1,35 @@ +{ + "author_commit": "91bdd1e7dcf193f3e7ca5a8933497fcef63b7960", + "author_path": "/data/digital-drosophila/experiments/phase4ad-author-semantics/external-resources/model.py", + "author_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "case_arrays_sha256": "3e3f7c2bd477e097761d3e34745f88fb215636c74d89a9e77a2b9a5f2fc738c3", + "case_spec_sha256": "02adfcd0717aa2d98eb571107136eae7186166ce1c7d7eb87df23bedb452fbd9", + "common_interface_preserved": true, + "learning": false, + "original_poi_interface_adopted": false, + "precision": "float32", + "spec": { + "description": "Same selected4AC/4AD motif,100ms prefix; no new edge or weight.", + "dt_ms": 0.1, + "duration_ms": 100.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 + }, + "name": "motif_no_input", + "selection": null, + "steps": 1000, + "trace_queue": true, + "validate_queue_proxy": true + }, + "trace_queue": true, + "validate_queue_proxy": true, + "whole_brain": false +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float32/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float32/coefficients.json new file mode 100644 index 0000000..03f5698 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float32/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_13", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_13", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_13", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_13", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_13", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_13", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float32/environment.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float32/environment.json new file mode 100644 index 0000000..7b43f4f --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float32/environment.json @@ -0,0 +1,14 @@ +{ + "backend": "Brian2 numpy runtime", + "packages": { + "brian2": "2.5.1", + "cython": "0.29.33", + "numpy": "1.22.3", + "pandas": "1.4.3", + "pyarrow": "11.0.0", + "scipy": "1.8.1", + "sympy": "1.12" + }, + "platform": "Linux-5.15.0-194-generic-x86_64-with-glibc2.35", + "python": "3.10.12 (main, Aug 31 2026, 10:18:17) [GCC 11.4.0]" +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float32/instrumented/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float32/instrumented/coefficients.json new file mode 100644 index 0000000..03f5698 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float32/instrumented/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_13", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_13", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_13", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_13", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_13", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_13", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float32/instrumented/compiled-code.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float32/instrumented/compiled-code.json new file mode 100644 index 0000000..3b9afa3 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float32/instrumented/compiled-code.json @@ -0,0 +1,122 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + }, + { + "active": true, + "code_objects": [], + "name": "zz_oracle_queue_installer", + "order": 1000000, + "type": "QueueInstaller", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float32/instrumented/completeness.csv b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float32/instrumented/completeness.csv new file mode 100644 index 0000000..9592749 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float32/instrumented/completeness.csv @@ -0,0 +1,6 @@ +global_neuron_idx,local_index +1197,0 +1381,1 +1511,2 +82312,3 +133666,4 diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float32/instrumented/generated-code.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float32/instrumented/generated-code.json new file mode 100644 index 0000000..8af1c54 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float32/instrumented/generated-code.json @@ -0,0 +1,122 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject_13" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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_13" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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_1" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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_13" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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_13" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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_1" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + }, + { + "active": true, + "code_objects": [], + "name": "zz_oracle_queue_installer", + "order": 1000000, + "type": "QueueInstaller", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float32/instrumented/input-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float32/instrumented/input-audit.json new file mode 100644 index 0000000..2c51f07 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float32/instrumented/input-audit.json @@ -0,0 +1,48 @@ +{ + "all_neurons_keep_original_rfc": true, + "completeness_sha256": "301ae4572c658aa307fc998e009377e9c82467d97d66aa1ac4b3f518385ec5a5", + "connectivity_sha256": "43ea5a3c6c53315e9265863a6f05b3e6d8e9b9f299aef665e8bbe9c46f9eb2ce", + "dt_ms": 0.1, + "parameter_checks": { + "membrane_tau_ms": { + "author": 20.0, + "case": 20.0 + }, + "refractory_ms": { + "author": 2.2, + "case": 2.2 + }, + "reset_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "resting_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "synaptic_delay_ms": { + "author": 1.8, + "case": 1.8 + }, + "synaptic_tau_ms": { + "author": 5.0, + "case": 5.0 + }, + "threshold_mv": { + "author": -45.0, + "case": -45.0 + }, + "w_syn_mv_per_anatomical_synapse": { + "author": 0.275, + "case": 0.275 + } + }, + "poisson_helper_used": false, + "precision": "float32", + "queue_trace_enabled": true, + "request_interface": "before_thresholds; v=v_th+1mV only if not_refractory", + "source_parameters_modified": false, + "source_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "state_units": "SI volts, original dtype", + "steps": 1000 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float32/instrumented/queue-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float32/instrumented/queue-audit.json new file mode 100644 index 0000000..f02cf64 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float32/instrumented/queue-audit.json @@ -0,0 +1,14 @@ +{ + "accepted_due_events": 0, + "advance_calls": 1000, + "all_due_events_preserved": true, + "due_events": 0, + "installations": [ + "default_synapses_pre_codeobject", + "default_synapses_pre_codeobject_13" + ], + "ordering": "raw anatomical queue.peek local edge-index sequence; no sorting or filtering", + "peek_calls": 1000, + "proxy_contract": "peek returns original object; advance and all other methods forward unchanged", + "trace_enabled": true +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float32/instrumented/schedule.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float32/instrumented/schedule.json new file mode 100644 index 0000000..93e03d3 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float32/instrumented/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_common_requests (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 \nzz_oracle_queue_installer (QueueInstaller) | -- | 100. us (every step) | end | 1000000 | yes " +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float32/proxy-validation.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float32/proxy-validation.json new file mode 100644 index 0000000..50c684d --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float32/proxy-validation.json @@ -0,0 +1,33 @@ +{ + "arrival_arrays_excluded": "An unwrapped queue is deliberately not observed", + "exact_arrays": { + "applicable_count": true, + "coefficients": true, + "counts": true, + "external_accepted": true, + "external_step": true, + "external_target": true, + "external_weights": true, + "fired": true, + "g": true, + "history": true, + "initial_g": true, + "initial_v": true, + "local_idx": true, + "neuron_idx": true, + "nodes": true, + "not_refractory": true, + "ref": true, + "ref_history": true, + "rejected_count": true, + "request_accepted": true, + "request_attempted": true, + "request_count": true, + "request_rejected": true, + "step": true, + "v": true, + "weights": true + }, + "pass": true, + "performed": true +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float32/summary.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float32/summary.json new file mode 100644 index 0000000..46022c8 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float32/summary.json @@ -0,0 +1,18 @@ +{ + "applicable_requests": 0, + "coefficient_file": "/data/digital-drosophila/experiments/phase4ae-author-runtime/oracle/motif_no_input-float32/coefficients.json", + "complete": true, + "due_arrivals": 0, + "edges": 13, + "name": "motif_no_input", + "nodes": 5, + "precision": "float32", + "queue_proxy_validated": true, + "queue_trace_enabled": true, + "rejected_requests": 0, + "requests": 0, + "source_unchanged": true, + "spikes": 0, + "state_file": "/data/digital-drosophila/experiments/phase4ae-author-runtime/oracle/motif_no_input-float32/state.npz", + "steps": 1000 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float32/unwrapped-audit/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float32/unwrapped-audit/coefficients.json new file mode 100644 index 0000000..d43f959 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float32/unwrapped-audit/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_14", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_14", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_14", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_14", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_14", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_14", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float32/unwrapped-audit/compiled-code.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float32/unwrapped-audit/compiled-code.json new file mode 100644 index 0000000..9a4ea64 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float32/unwrapped-audit/compiled-code.json @@ -0,0 +1,114 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float32/unwrapped-audit/completeness.csv b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float32/unwrapped-audit/completeness.csv new file mode 100644 index 0000000..9592749 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float32/unwrapped-audit/completeness.csv @@ -0,0 +1,6 @@ +global_neuron_idx,local_index +1197,0 +1381,1 +1511,2 +82312,3 +133666,4 diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float32/unwrapped-audit/generated-code.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float32/unwrapped-audit/generated-code.json new file mode 100644 index 0000000..bb6af17 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float32/unwrapped-audit/generated-code.json @@ -0,0 +1,114 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject_14" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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_14" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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_1" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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_14" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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_14" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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_1" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float32/unwrapped-audit/input-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float32/unwrapped-audit/input-audit.json new file mode 100644 index 0000000..62dd15b --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float32/unwrapped-audit/input-audit.json @@ -0,0 +1,48 @@ +{ + "all_neurons_keep_original_rfc": true, + "completeness_sha256": "301ae4572c658aa307fc998e009377e9c82467d97d66aa1ac4b3f518385ec5a5", + "connectivity_sha256": "43ea5a3c6c53315e9265863a6f05b3e6d8e9b9f299aef665e8bbe9c46f9eb2ce", + "dt_ms": 0.1, + "parameter_checks": { + "membrane_tau_ms": { + "author": 20.0, + "case": 20.0 + }, + "refractory_ms": { + "author": 2.2, + "case": 2.2 + }, + "reset_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "resting_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "synaptic_delay_ms": { + "author": 1.8, + "case": 1.8 + }, + "synaptic_tau_ms": { + "author": 5.0, + "case": 5.0 + }, + "threshold_mv": { + "author": -45.0, + "case": -45.0 + }, + "w_syn_mv_per_anatomical_synapse": { + "author": 0.275, + "case": 0.275 + } + }, + "poisson_helper_used": false, + "precision": "float32", + "queue_trace_enabled": false, + "request_interface": "before_thresholds; v=v_th+1mV only if not_refractory", + "source_parameters_modified": false, + "source_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "state_units": "SI volts, original dtype", + "steps": 1000 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float32/unwrapped-audit/queue-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float32/unwrapped-audit/queue-audit.json new file mode 100644 index 0000000..6d2ed14 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float32/unwrapped-audit/queue-audit.json @@ -0,0 +1,11 @@ +{ + "accepted_due_events": 0, + "advance_calls": 0, + "all_due_events_preserved": null, + "due_events": 0, + "installations": [], + "ordering": "raw anatomical queue.peek local edge-index sequence; no sorting or filtering", + "peek_calls": 0, + "proxy_contract": "peek returns original object; advance and all other methods forward unchanged", + "trace_enabled": false +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float32/unwrapped-audit/schedule.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float32/unwrapped-audit/schedule.json new file mode 100644 index 0000000..4202f07 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float32/unwrapped-audit/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_common_requests (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 " +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float64/case.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float64/case.json new file mode 100644 index 0000000..5cfb54d --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float64/case.json @@ -0,0 +1,35 @@ +{ + "author_commit": "91bdd1e7dcf193f3e7ca5a8933497fcef63b7960", + "author_path": "/data/digital-drosophila/experiments/phase4ad-author-semantics/external-resources/model.py", + "author_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "case_arrays_sha256": "3e3f7c2bd477e097761d3e34745f88fb215636c74d89a9e77a2b9a5f2fc738c3", + "case_spec_sha256": "02adfcd0717aa2d98eb571107136eae7186166ce1c7d7eb87df23bedb452fbd9", + "common_interface_preserved": true, + "learning": false, + "original_poi_interface_adopted": false, + "precision": "float64", + "spec": { + "description": "Same selected4AC/4AD motif,100ms prefix; no new edge or weight.", + "dt_ms": 0.1, + "duration_ms": 100.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 + }, + "name": "motif_no_input", + "selection": null, + "steps": 1000, + "trace_queue": true, + "validate_queue_proxy": true + }, + "trace_queue": true, + "validate_queue_proxy": true, + "whole_brain": false +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float64/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float64/coefficients.json new file mode 100644 index 0000000..de7e02d --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float64/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_9", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_9", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_9", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_9", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_9", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_9", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float64/environment.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float64/environment.json new file mode 100644 index 0000000..7b43f4f --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float64/environment.json @@ -0,0 +1,14 @@ +{ + "backend": "Brian2 numpy runtime", + "packages": { + "brian2": "2.5.1", + "cython": "0.29.33", + "numpy": "1.22.3", + "pandas": "1.4.3", + "pyarrow": "11.0.0", + "scipy": "1.8.1", + "sympy": "1.12" + }, + "platform": "Linux-5.15.0-194-generic-x86_64-with-glibc2.35", + "python": "3.10.12 (main, Aug 31 2026, 10:18:17) [GCC 11.4.0]" +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float64/instrumented/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float64/instrumented/coefficients.json new file mode 100644 index 0000000..de7e02d --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float64/instrumented/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_9", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_9", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_9", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_9", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_9", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_9", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float64/instrumented/compiled-code.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float64/instrumented/compiled-code.json new file mode 100644 index 0000000..3b9afa3 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float64/instrumented/compiled-code.json @@ -0,0 +1,122 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + }, + { + "active": true, + "code_objects": [], + "name": "zz_oracle_queue_installer", + "order": 1000000, + "type": "QueueInstaller", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float64/instrumented/completeness.csv b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float64/instrumented/completeness.csv new file mode 100644 index 0000000..9592749 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float64/instrumented/completeness.csv @@ -0,0 +1,6 @@ +global_neuron_idx,local_index +1197,0 +1381,1 +1511,2 +82312,3 +133666,4 diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float64/instrumented/generated-code.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float64/instrumented/generated-code.json new file mode 100644 index 0000000..ed3b9c4 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float64/instrumented/generated-code.json @@ -0,0 +1,122 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject_9" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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_9" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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_1" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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_9" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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_9" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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_1" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + }, + { + "active": true, + "code_objects": [], + "name": "zz_oracle_queue_installer", + "order": 1000000, + "type": "QueueInstaller", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float64/instrumented/input-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float64/instrumented/input-audit.json new file mode 100644 index 0000000..9bcbd91 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float64/instrumented/input-audit.json @@ -0,0 +1,48 @@ +{ + "all_neurons_keep_original_rfc": true, + "completeness_sha256": "301ae4572c658aa307fc998e009377e9c82467d97d66aa1ac4b3f518385ec5a5", + "connectivity_sha256": "43ea5a3c6c53315e9265863a6f05b3e6d8e9b9f299aef665e8bbe9c46f9eb2ce", + "dt_ms": 0.1, + "parameter_checks": { + "membrane_tau_ms": { + "author": 20.0, + "case": 20.0 + }, + "refractory_ms": { + "author": 2.2, + "case": 2.2 + }, + "reset_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "resting_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "synaptic_delay_ms": { + "author": 1.8, + "case": 1.8 + }, + "synaptic_tau_ms": { + "author": 5.0, + "case": 5.0 + }, + "threshold_mv": { + "author": -45.0, + "case": -45.0 + }, + "w_syn_mv_per_anatomical_synapse": { + "author": 0.275, + "case": 0.275 + } + }, + "poisson_helper_used": false, + "precision": "float64", + "queue_trace_enabled": true, + "request_interface": "before_thresholds; v=v_th+1mV only if not_refractory", + "source_parameters_modified": false, + "source_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "state_units": "SI volts, original dtype", + "steps": 1000 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float64/instrumented/queue-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float64/instrumented/queue-audit.json new file mode 100644 index 0000000..f3ac22e --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float64/instrumented/queue-audit.json @@ -0,0 +1,14 @@ +{ + "accepted_due_events": 0, + "advance_calls": 1000, + "all_due_events_preserved": true, + "due_events": 0, + "installations": [ + "default_synapses_pre_codeobject", + "default_synapses_pre_codeobject_9" + ], + "ordering": "raw anatomical queue.peek local edge-index sequence; no sorting or filtering", + "peek_calls": 1000, + "proxy_contract": "peek returns original object; advance and all other methods forward unchanged", + "trace_enabled": true +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float64/instrumented/schedule.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float64/instrumented/schedule.json new file mode 100644 index 0000000..93e03d3 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float64/instrumented/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_common_requests (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 \nzz_oracle_queue_installer (QueueInstaller) | -- | 100. us (every step) | end | 1000000 | yes " +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float64/proxy-validation.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float64/proxy-validation.json new file mode 100644 index 0000000..50c684d --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float64/proxy-validation.json @@ -0,0 +1,33 @@ +{ + "arrival_arrays_excluded": "An unwrapped queue is deliberately not observed", + "exact_arrays": { + "applicable_count": true, + "coefficients": true, + "counts": true, + "external_accepted": true, + "external_step": true, + "external_target": true, + "external_weights": true, + "fired": true, + "g": true, + "history": true, + "initial_g": true, + "initial_v": true, + "local_idx": true, + "neuron_idx": true, + "nodes": true, + "not_refractory": true, + "ref": true, + "ref_history": true, + "rejected_count": true, + "request_accepted": true, + "request_attempted": true, + "request_count": true, + "request_rejected": true, + "step": true, + "v": true, + "weights": true + }, + "pass": true, + "performed": true +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float64/summary.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float64/summary.json new file mode 100644 index 0000000..b76086e --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float64/summary.json @@ -0,0 +1,18 @@ +{ + "applicable_requests": 0, + "coefficient_file": "/data/digital-drosophila/experiments/phase4ae-author-runtime/oracle/motif_no_input-float64/coefficients.json", + "complete": true, + "due_arrivals": 0, + "edges": 13, + "name": "motif_no_input", + "nodes": 5, + "precision": "float64", + "queue_proxy_validated": true, + "queue_trace_enabled": true, + "rejected_requests": 0, + "requests": 0, + "source_unchanged": true, + "spikes": 0, + "state_file": "/data/digital-drosophila/experiments/phase4ae-author-runtime/oracle/motif_no_input-float64/state.npz", + "steps": 1000 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float64/unwrapped-audit/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float64/unwrapped-audit/coefficients.json new file mode 100644 index 0000000..f2437a9 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float64/unwrapped-audit/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_12", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_12", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_12", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_12", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_12", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_12", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float64/unwrapped-audit/compiled-code.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float64/unwrapped-audit/compiled-code.json new file mode 100644 index 0000000..9a4ea64 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float64/unwrapped-audit/compiled-code.json @@ -0,0 +1,114 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float64/unwrapped-audit/completeness.csv b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float64/unwrapped-audit/completeness.csv new file mode 100644 index 0000000..9592749 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float64/unwrapped-audit/completeness.csv @@ -0,0 +1,6 @@ +global_neuron_idx,local_index +1197,0 +1381,1 +1511,2 +82312,3 +133666,4 diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float64/unwrapped-audit/generated-code.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float64/unwrapped-audit/generated-code.json new file mode 100644 index 0000000..8762eb7 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float64/unwrapped-audit/generated-code.json @@ -0,0 +1,114 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject_12" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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_12" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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_1" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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_12" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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_12" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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_1" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float64/unwrapped-audit/input-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float64/unwrapped-audit/input-audit.json new file mode 100644 index 0000000..7fb6318 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float64/unwrapped-audit/input-audit.json @@ -0,0 +1,48 @@ +{ + "all_neurons_keep_original_rfc": true, + "completeness_sha256": "301ae4572c658aa307fc998e009377e9c82467d97d66aa1ac4b3f518385ec5a5", + "connectivity_sha256": "43ea5a3c6c53315e9265863a6f05b3e6d8e9b9f299aef665e8bbe9c46f9eb2ce", + "dt_ms": 0.1, + "parameter_checks": { + "membrane_tau_ms": { + "author": 20.0, + "case": 20.0 + }, + "refractory_ms": { + "author": 2.2, + "case": 2.2 + }, + "reset_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "resting_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "synaptic_delay_ms": { + "author": 1.8, + "case": 1.8 + }, + "synaptic_tau_ms": { + "author": 5.0, + "case": 5.0 + }, + "threshold_mv": { + "author": -45.0, + "case": -45.0 + }, + "w_syn_mv_per_anatomical_synapse": { + "author": 0.275, + "case": 0.275 + } + }, + "poisson_helper_used": false, + "precision": "float64", + "queue_trace_enabled": false, + "request_interface": "before_thresholds; v=v_th+1mV only if not_refractory", + "source_parameters_modified": false, + "source_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "state_units": "SI volts, original dtype", + "steps": 1000 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float64/unwrapped-audit/queue-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float64/unwrapped-audit/queue-audit.json new file mode 100644 index 0000000..6d2ed14 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float64/unwrapped-audit/queue-audit.json @@ -0,0 +1,11 @@ +{ + "accepted_due_events": 0, + "advance_calls": 0, + "all_due_events_preserved": null, + "due_events": 0, + "installations": [], + "ordering": "raw anatomical queue.peek local edge-index sequence; no sorting or filtering", + "peek_calls": 0, + "proxy_contract": "peek returns original object; advance and all other methods forward unchanged", + "trace_enabled": false +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float64/unwrapped-audit/schedule.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float64/unwrapped-audit/schedule.json new file mode 100644 index 0000000..4202f07 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_no_input-float64/unwrapped-audit/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_common_requests (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 " +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float32/case.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float32/case.json new file mode 100644 index 0000000..b779c8b --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float32/case.json @@ -0,0 +1,35 @@ +{ + "author_commit": "91bdd1e7dcf193f3e7ca5a8933497fcef63b7960", + "author_path": "/data/digital-drosophila/experiments/phase4ad-author-semantics/external-resources/model.py", + "author_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "case_arrays_sha256": "7c01e762480777b22474264f28cc413e554314602fad320a33b53dd028a1fb5a", + "case_spec_sha256": "faee4cdcdc93293b4b5e15d852a6a97b76767ce6aa7c534b12c6f204264daa7a", + "common_interface_preserved": true, + "learning": false, + "original_poi_interface_adopted": false, + "precision": "float32", + "spec": { + "description": "Same selected4AC/4AD motif,100ms prefix; no new edge or weight.", + "dt_ms": 0.1, + "duration_ms": 100.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 + }, + "name": "motif_pair", + "selection": null, + "steps": 1000, + "trace_queue": true, + "validate_queue_proxy": true + }, + "trace_queue": true, + "validate_queue_proxy": true, + "whole_brain": false +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float32/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float32/coefficients.json new file mode 100644 index 0000000..7745dad --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float32/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_15", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_15", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_15", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_15", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_15", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_15", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float32/environment.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float32/environment.json new file mode 100644 index 0000000..7b43f4f --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float32/environment.json @@ -0,0 +1,14 @@ +{ + "backend": "Brian2 numpy runtime", + "packages": { + "brian2": "2.5.1", + "cython": "0.29.33", + "numpy": "1.22.3", + "pandas": "1.4.3", + "pyarrow": "11.0.0", + "scipy": "1.8.1", + "sympy": "1.12" + }, + "platform": "Linux-5.15.0-194-generic-x86_64-with-glibc2.35", + "python": "3.10.12 (main, Aug 31 2026, 10:18:17) [GCC 11.4.0]" +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float32/instrumented/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float32/instrumented/coefficients.json new file mode 100644 index 0000000..7745dad --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float32/instrumented/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_15", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_15", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_15", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_15", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_15", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_15", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float32/instrumented/compiled-code.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float32/instrumented/compiled-code.json new file mode 100644 index 0000000..3b9afa3 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float32/instrumented/compiled-code.json @@ -0,0 +1,122 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + }, + { + "active": true, + "code_objects": [], + "name": "zz_oracle_queue_installer", + "order": 1000000, + "type": "QueueInstaller", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float32/instrumented/completeness.csv b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float32/instrumented/completeness.csv new file mode 100644 index 0000000..8ad30be --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float32/instrumented/completeness.csv @@ -0,0 +1,3 @@ +global_neuron_idx,local_index +1381,0 +1511,1 diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float32/instrumented/generated-code.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float32/instrumented/generated-code.json new file mode 100644 index 0000000..ed558d7 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float32/instrumented/generated-code.json @@ -0,0 +1,122 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject_15" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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_15" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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_1" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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_15" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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_15" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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_1" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + }, + { + "active": true, + "code_objects": [], + "name": "zz_oracle_queue_installer", + "order": 1000000, + "type": "QueueInstaller", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float32/instrumented/input-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float32/instrumented/input-audit.json new file mode 100644 index 0000000..3e83dba --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float32/instrumented/input-audit.json @@ -0,0 +1,48 @@ +{ + "all_neurons_keep_original_rfc": true, + "completeness_sha256": "5af02939034e66e7a8e7c361555203906d69bbba0042b1ab549041db1626f02b", + "connectivity_sha256": "1072f50d478d1890de7602c48f6a7f1b89e11a665a173e7a705a5fab3b3f8771", + "dt_ms": 0.1, + "parameter_checks": { + "membrane_tau_ms": { + "author": 20.0, + "case": 20.0 + }, + "refractory_ms": { + "author": 2.2, + "case": 2.2 + }, + "reset_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "resting_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "synaptic_delay_ms": { + "author": 1.8, + "case": 1.8 + }, + "synaptic_tau_ms": { + "author": 5.0, + "case": 5.0 + }, + "threshold_mv": { + "author": -45.0, + "case": -45.0 + }, + "w_syn_mv_per_anatomical_synapse": { + "author": 0.275, + "case": 0.275 + } + }, + "poisson_helper_used": false, + "precision": "float32", + "queue_trace_enabled": true, + "request_interface": "before_thresholds; v=v_th+1mV only if not_refractory", + "source_parameters_modified": false, + "source_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "state_units": "SI volts, original dtype", + "steps": 1000 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float32/instrumented/queue-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float32/instrumented/queue-audit.json new file mode 100644 index 0000000..07a7127 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float32/instrumented/queue-audit.json @@ -0,0 +1,14 @@ +{ + "accepted_due_events": 21, + "advance_calls": 1000, + "all_due_events_preserved": true, + "due_events": 21, + "installations": [ + "default_synapses_pre_codeobject", + "default_synapses_pre_codeobject_15" + ], + "ordering": "raw anatomical queue.peek local edge-index sequence; no sorting or filtering", + "peek_calls": 1000, + "proxy_contract": "peek returns original object; advance and all other methods forward unchanged", + "trace_enabled": true +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float32/instrumented/schedule.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float32/instrumented/schedule.json new file mode 100644 index 0000000..93e03d3 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float32/instrumented/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_common_requests (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 \nzz_oracle_queue_installer (QueueInstaller) | -- | 100. us (every step) | end | 1000000 | yes " +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float32/proxy-validation.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float32/proxy-validation.json new file mode 100644 index 0000000..50c684d --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float32/proxy-validation.json @@ -0,0 +1,33 @@ +{ + "arrival_arrays_excluded": "An unwrapped queue is deliberately not observed", + "exact_arrays": { + "applicable_count": true, + "coefficients": true, + "counts": true, + "external_accepted": true, + "external_step": true, + "external_target": true, + "external_weights": true, + "fired": true, + "g": true, + "history": true, + "initial_g": true, + "initial_v": true, + "local_idx": true, + "neuron_idx": true, + "nodes": true, + "not_refractory": true, + "ref": true, + "ref_history": true, + "rejected_count": true, + "request_accepted": true, + "request_attempted": true, + "request_count": true, + "request_rejected": true, + "step": true, + "v": true, + "weights": true + }, + "pass": true, + "performed": true +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float32/summary.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float32/summary.json new file mode 100644 index 0000000..3940f05 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float32/summary.json @@ -0,0 +1,18 @@ +{ + "applicable_requests": 1, + "coefficient_file": "/data/digital-drosophila/experiments/phase4ae-author-runtime/oracle/motif_pair-float32/coefficients.json", + "complete": true, + "due_arrivals": 21, + "edges": 2, + "name": "motif_pair", + "nodes": 2, + "precision": "float32", + "queue_proxy_validated": true, + "queue_trace_enabled": true, + "rejected_requests": 0, + "requests": 1, + "source_unchanged": true, + "spikes": 22, + "state_file": "/data/digital-drosophila/experiments/phase4ae-author-runtime/oracle/motif_pair-float32/state.npz", + "steps": 1000 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float32/unwrapped-audit/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float32/unwrapped-audit/coefficients.json new file mode 100644 index 0000000..d251654 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float32/unwrapped-audit/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_16", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_16", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_16", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_16", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_16", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_16", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float32/unwrapped-audit/compiled-code.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float32/unwrapped-audit/compiled-code.json new file mode 100644 index 0000000..9a4ea64 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float32/unwrapped-audit/compiled-code.json @@ -0,0 +1,114 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float32/unwrapped-audit/completeness.csv b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float32/unwrapped-audit/completeness.csv new file mode 100644 index 0000000..8ad30be --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float32/unwrapped-audit/completeness.csv @@ -0,0 +1,3 @@ +global_neuron_idx,local_index +1381,0 +1511,1 diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float32/unwrapped-audit/generated-code.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float32/unwrapped-audit/generated-code.json new file mode 100644 index 0000000..8af3c6e --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float32/unwrapped-audit/generated-code.json @@ -0,0 +1,114 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject_16" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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_16" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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_1" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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_16" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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_16" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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_1" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float32/unwrapped-audit/input-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float32/unwrapped-audit/input-audit.json new file mode 100644 index 0000000..f0b8cca --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float32/unwrapped-audit/input-audit.json @@ -0,0 +1,48 @@ +{ + "all_neurons_keep_original_rfc": true, + "completeness_sha256": "5af02939034e66e7a8e7c361555203906d69bbba0042b1ab549041db1626f02b", + "connectivity_sha256": "1072f50d478d1890de7602c48f6a7f1b89e11a665a173e7a705a5fab3b3f8771", + "dt_ms": 0.1, + "parameter_checks": { + "membrane_tau_ms": { + "author": 20.0, + "case": 20.0 + }, + "refractory_ms": { + "author": 2.2, + "case": 2.2 + }, + "reset_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "resting_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "synaptic_delay_ms": { + "author": 1.8, + "case": 1.8 + }, + "synaptic_tau_ms": { + "author": 5.0, + "case": 5.0 + }, + "threshold_mv": { + "author": -45.0, + "case": -45.0 + }, + "w_syn_mv_per_anatomical_synapse": { + "author": 0.275, + "case": 0.275 + } + }, + "poisson_helper_used": false, + "precision": "float32", + "queue_trace_enabled": false, + "request_interface": "before_thresholds; v=v_th+1mV only if not_refractory", + "source_parameters_modified": false, + "source_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "state_units": "SI volts, original dtype", + "steps": 1000 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float32/unwrapped-audit/queue-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float32/unwrapped-audit/queue-audit.json new file mode 100644 index 0000000..6d2ed14 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float32/unwrapped-audit/queue-audit.json @@ -0,0 +1,11 @@ +{ + "accepted_due_events": 0, + "advance_calls": 0, + "all_due_events_preserved": null, + "due_events": 0, + "installations": [], + "ordering": "raw anatomical queue.peek local edge-index sequence; no sorting or filtering", + "peek_calls": 0, + "proxy_contract": "peek returns original object; advance and all other methods forward unchanged", + "trace_enabled": false +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float32/unwrapped-audit/schedule.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float32/unwrapped-audit/schedule.json new file mode 100644 index 0000000..4202f07 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float32/unwrapped-audit/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_common_requests (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 " +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float64/case.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float64/case.json new file mode 100644 index 0000000..cbf8265 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float64/case.json @@ -0,0 +1,35 @@ +{ + "author_commit": "91bdd1e7dcf193f3e7ca5a8933497fcef63b7960", + "author_path": "/data/digital-drosophila/experiments/phase4ad-author-semantics/external-resources/model.py", + "author_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "case_arrays_sha256": "7c01e762480777b22474264f28cc413e554314602fad320a33b53dd028a1fb5a", + "case_spec_sha256": "faee4cdcdc93293b4b5e15d852a6a97b76767ce6aa7c534b12c6f204264daa7a", + "common_interface_preserved": true, + "learning": false, + "original_poi_interface_adopted": false, + "precision": "float64", + "spec": { + "description": "Same selected4AC/4AD motif,100ms prefix; no new edge or weight.", + "dt_ms": 0.1, + "duration_ms": 100.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 + }, + "name": "motif_pair", + "selection": null, + "steps": 1000, + "trace_queue": true, + "validate_queue_proxy": true + }, + "trace_queue": true, + "validate_queue_proxy": true, + "whole_brain": false +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float64/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float64/coefficients.json new file mode 100644 index 0000000..f2437a9 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float64/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_12", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_12", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_12", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_12", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_12", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_12", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float64/environment.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float64/environment.json new file mode 100644 index 0000000..7b43f4f --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float64/environment.json @@ -0,0 +1,14 @@ +{ + "backend": "Brian2 numpy runtime", + "packages": { + "brian2": "2.5.1", + "cython": "0.29.33", + "numpy": "1.22.3", + "pandas": "1.4.3", + "pyarrow": "11.0.0", + "scipy": "1.8.1", + "sympy": "1.12" + }, + "platform": "Linux-5.15.0-194-generic-x86_64-with-glibc2.35", + "python": "3.10.12 (main, Aug 31 2026, 10:18:17) [GCC 11.4.0]" +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float64/instrumented/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float64/instrumented/coefficients.json new file mode 100644 index 0000000..f2437a9 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float64/instrumented/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_12", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_12", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_12", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_12", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_12", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_12", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float64/instrumented/compiled-code.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float64/instrumented/compiled-code.json new file mode 100644 index 0000000..3b9afa3 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float64/instrumented/compiled-code.json @@ -0,0 +1,122 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + }, + { + "active": true, + "code_objects": [], + "name": "zz_oracle_queue_installer", + "order": 1000000, + "type": "QueueInstaller", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float64/instrumented/completeness.csv b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float64/instrumented/completeness.csv new file mode 100644 index 0000000..8ad30be --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float64/instrumented/completeness.csv @@ -0,0 +1,3 @@ +global_neuron_idx,local_index +1381,0 +1511,1 diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float64/instrumented/generated-code.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float64/instrumented/generated-code.json new file mode 100644 index 0000000..c2e5dff --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float64/instrumented/generated-code.json @@ -0,0 +1,122 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject_12" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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_12" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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_1" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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_12" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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_12" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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_1" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + }, + { + "active": true, + "code_objects": [], + "name": "zz_oracle_queue_installer", + "order": 1000000, + "type": "QueueInstaller", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float64/instrumented/input-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float64/instrumented/input-audit.json new file mode 100644 index 0000000..2562187 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float64/instrumented/input-audit.json @@ -0,0 +1,48 @@ +{ + "all_neurons_keep_original_rfc": true, + "completeness_sha256": "5af02939034e66e7a8e7c361555203906d69bbba0042b1ab549041db1626f02b", + "connectivity_sha256": "1072f50d478d1890de7602c48f6a7f1b89e11a665a173e7a705a5fab3b3f8771", + "dt_ms": 0.1, + "parameter_checks": { + "membrane_tau_ms": { + "author": 20.0, + "case": 20.0 + }, + "refractory_ms": { + "author": 2.2, + "case": 2.2 + }, + "reset_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "resting_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "synaptic_delay_ms": { + "author": 1.8, + "case": 1.8 + }, + "synaptic_tau_ms": { + "author": 5.0, + "case": 5.0 + }, + "threshold_mv": { + "author": -45.0, + "case": -45.0 + }, + "w_syn_mv_per_anatomical_synapse": { + "author": 0.275, + "case": 0.275 + } + }, + "poisson_helper_used": false, + "precision": "float64", + "queue_trace_enabled": true, + "request_interface": "before_thresholds; v=v_th+1mV only if not_refractory", + "source_parameters_modified": false, + "source_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "state_units": "SI volts, original dtype", + "steps": 1000 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float64/instrumented/queue-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float64/instrumented/queue-audit.json new file mode 100644 index 0000000..6b344fd --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float64/instrumented/queue-audit.json @@ -0,0 +1,14 @@ +{ + "accepted_due_events": 21, + "advance_calls": 1000, + "all_due_events_preserved": true, + "due_events": 21, + "installations": [ + "default_synapses_pre_codeobject", + "default_synapses_pre_codeobject_12" + ], + "ordering": "raw anatomical queue.peek local edge-index sequence; no sorting or filtering", + "peek_calls": 1000, + "proxy_contract": "peek returns original object; advance and all other methods forward unchanged", + "trace_enabled": true +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float64/instrumented/schedule.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float64/instrumented/schedule.json new file mode 100644 index 0000000..93e03d3 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float64/instrumented/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_common_requests (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 \nzz_oracle_queue_installer (QueueInstaller) | -- | 100. us (every step) | end | 1000000 | yes " +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float64/proxy-validation.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float64/proxy-validation.json new file mode 100644 index 0000000..50c684d --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float64/proxy-validation.json @@ -0,0 +1,33 @@ +{ + "arrival_arrays_excluded": "An unwrapped queue is deliberately not observed", + "exact_arrays": { + "applicable_count": true, + "coefficients": true, + "counts": true, + "external_accepted": true, + "external_step": true, + "external_target": true, + "external_weights": true, + "fired": true, + "g": true, + "history": true, + "initial_g": true, + "initial_v": true, + "local_idx": true, + "neuron_idx": true, + "nodes": true, + "not_refractory": true, + "ref": true, + "ref_history": true, + "rejected_count": true, + "request_accepted": true, + "request_attempted": true, + "request_count": true, + "request_rejected": true, + "step": true, + "v": true, + "weights": true + }, + "pass": true, + "performed": true +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float64/summary.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float64/summary.json new file mode 100644 index 0000000..e4cc7bc --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float64/summary.json @@ -0,0 +1,18 @@ +{ + "applicable_requests": 1, + "coefficient_file": "/data/digital-drosophila/experiments/phase4ae-author-runtime/oracle/motif_pair-float64/coefficients.json", + "complete": true, + "due_arrivals": 21, + "edges": 2, + "name": "motif_pair", + "nodes": 2, + "precision": "float64", + "queue_proxy_validated": true, + "queue_trace_enabled": true, + "rejected_requests": 0, + "requests": 1, + "source_unchanged": true, + "spikes": 22, + "state_file": "/data/digital-drosophila/experiments/phase4ae-author-runtime/oracle/motif_pair-float64/state.npz", + "steps": 1000 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float64/unwrapped-audit/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float64/unwrapped-audit/coefficients.json new file mode 100644 index 0000000..d43f959 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float64/unwrapped-audit/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_14", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_14", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_14", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_14", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_14", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_14", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float64/unwrapped-audit/compiled-code.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float64/unwrapped-audit/compiled-code.json new file mode 100644 index 0000000..9a4ea64 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float64/unwrapped-audit/compiled-code.json @@ -0,0 +1,114 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float64/unwrapped-audit/completeness.csv b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float64/unwrapped-audit/completeness.csv new file mode 100644 index 0000000..8ad30be --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float64/unwrapped-audit/completeness.csv @@ -0,0 +1,3 @@ +global_neuron_idx,local_index +1381,0 +1511,1 diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float64/unwrapped-audit/generated-code.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float64/unwrapped-audit/generated-code.json new file mode 100644 index 0000000..bb6af17 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float64/unwrapped-audit/generated-code.json @@ -0,0 +1,114 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject_14" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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_14" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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_1" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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_14" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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_14" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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_1" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float64/unwrapped-audit/input-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float64/unwrapped-audit/input-audit.json new file mode 100644 index 0000000..9ec6f2b --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float64/unwrapped-audit/input-audit.json @@ -0,0 +1,48 @@ +{ + "all_neurons_keep_original_rfc": true, + "completeness_sha256": "5af02939034e66e7a8e7c361555203906d69bbba0042b1ab549041db1626f02b", + "connectivity_sha256": "1072f50d478d1890de7602c48f6a7f1b89e11a665a173e7a705a5fab3b3f8771", + "dt_ms": 0.1, + "parameter_checks": { + "membrane_tau_ms": { + "author": 20.0, + "case": 20.0 + }, + "refractory_ms": { + "author": 2.2, + "case": 2.2 + }, + "reset_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "resting_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "synaptic_delay_ms": { + "author": 1.8, + "case": 1.8 + }, + "synaptic_tau_ms": { + "author": 5.0, + "case": 5.0 + }, + "threshold_mv": { + "author": -45.0, + "case": -45.0 + }, + "w_syn_mv_per_anatomical_synapse": { + "author": 0.275, + "case": 0.275 + } + }, + "poisson_helper_used": false, + "precision": "float64", + "queue_trace_enabled": false, + "request_interface": "before_thresholds; v=v_th+1mV only if not_refractory", + "source_parameters_modified": false, + "source_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "state_units": "SI volts, original dtype", + "steps": 1000 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float64/unwrapped-audit/queue-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float64/unwrapped-audit/queue-audit.json new file mode 100644 index 0000000..6d2ed14 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float64/unwrapped-audit/queue-audit.json @@ -0,0 +1,11 @@ +{ + "accepted_due_events": 0, + "advance_calls": 0, + "all_due_events_preserved": null, + "due_events": 0, + "installations": [], + "ordering": "raw anatomical queue.peek local edge-index sequence; no sorting or filtering", + "peek_calls": 0, + "proxy_contract": "peek returns original object; advance and all other methods forward unchanged", + "trace_enabled": false +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float64/unwrapped-audit/schedule.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float64/unwrapped-audit/schedule.json new file mode 100644 index 0000000..4202f07 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_pair-float64/unwrapped-audit/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_common_requests (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 " +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float32/case.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float32/case.json new file mode 100644 index 0000000..888e391 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float32/case.json @@ -0,0 +1,35 @@ +{ + "author_commit": "91bdd1e7dcf193f3e7ca5a8933497fcef63b7960", + "author_path": "/data/digital-drosophila/experiments/phase4ad-author-semantics/external-resources/model.py", + "author_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "case_arrays_sha256": "a40e803b1227d4bb6b2c24d76bdf1454cb63ace61ebb9e77ff01010dd91cab37", + "case_spec_sha256": "da4b6cea0b8a33ca15e552425b55ce699d74ddf81660b02eeb30d5edcc4494cd", + "common_interface_preserved": true, + "learning": false, + "original_poi_interface_adopted": false, + "precision": "float32", + "spec": { + "description": "Same selected4AC/4AD motif,100ms prefix; no new edge or weight.", + "dt_ms": 0.1, + "duration_ms": 100.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 + }, + "name": "motif_trio", + "selection": null, + "steps": 1000, + "trace_queue": true, + "validate_queue_proxy": true + }, + "trace_queue": true, + "validate_queue_proxy": true, + "whole_brain": false +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float32/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float32/coefficients.json new file mode 100644 index 0000000..f191c81 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float32/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_17", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_17", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_17", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_17", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_17", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_17", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float32/environment.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float32/environment.json new file mode 100644 index 0000000..7b43f4f --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float32/environment.json @@ -0,0 +1,14 @@ +{ + "backend": "Brian2 numpy runtime", + "packages": { + "brian2": "2.5.1", + "cython": "0.29.33", + "numpy": "1.22.3", + "pandas": "1.4.3", + "pyarrow": "11.0.0", + "scipy": "1.8.1", + "sympy": "1.12" + }, + "platform": "Linux-5.15.0-194-generic-x86_64-with-glibc2.35", + "python": "3.10.12 (main, Aug 31 2026, 10:18:17) [GCC 11.4.0]" +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float32/instrumented/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float32/instrumented/coefficients.json new file mode 100644 index 0000000..f191c81 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float32/instrumented/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_17", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_17", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_17", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_17", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_17", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_17", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float32/instrumented/compiled-code.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float32/instrumented/compiled-code.json new file mode 100644 index 0000000..3b9afa3 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float32/instrumented/compiled-code.json @@ -0,0 +1,122 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + }, + { + "active": true, + "code_objects": [], + "name": "zz_oracle_queue_installer", + "order": 1000000, + "type": "QueueInstaller", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float32/instrumented/completeness.csv b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float32/instrumented/completeness.csv new file mode 100644 index 0000000..38343a0 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float32/instrumented/completeness.csv @@ -0,0 +1,4 @@ +global_neuron_idx,local_index +1197,0 +1381,1 +1511,2 diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float32/instrumented/generated-code.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float32/instrumented/generated-code.json new file mode 100644 index 0000000..1d00fee --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float32/instrumented/generated-code.json @@ -0,0 +1,122 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject_17" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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_17" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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_1" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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_17" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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_17" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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_1" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + }, + { + "active": true, + "code_objects": [], + "name": "zz_oracle_queue_installer", + "order": 1000000, + "type": "QueueInstaller", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float32/instrumented/input-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float32/instrumented/input-audit.json new file mode 100644 index 0000000..3c048a8 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float32/instrumented/input-audit.json @@ -0,0 +1,48 @@ +{ + "all_neurons_keep_original_rfc": true, + "completeness_sha256": "e8795d5efb2eebefaae419c6df6d18d3cea3c390d9df7987f55823f5a860169e", + "connectivity_sha256": "22570cdceb09128d4bde46fd75897af776f7d91d89b8581d13133f55779f1e91", + "dt_ms": 0.1, + "parameter_checks": { + "membrane_tau_ms": { + "author": 20.0, + "case": 20.0 + }, + "refractory_ms": { + "author": 2.2, + "case": 2.2 + }, + "reset_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "resting_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "synaptic_delay_ms": { + "author": 1.8, + "case": 1.8 + }, + "synaptic_tau_ms": { + "author": 5.0, + "case": 5.0 + }, + "threshold_mv": { + "author": -45.0, + "case": -45.0 + }, + "w_syn_mv_per_anatomical_synapse": { + "author": 0.275, + "case": 0.275 + } + }, + "poisson_helper_used": false, + "precision": "float32", + "queue_trace_enabled": true, + "request_interface": "before_thresholds; v=v_th+1mV only if not_refractory", + "source_parameters_modified": false, + "source_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "state_units": "SI volts, original dtype", + "steps": 1000 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float32/instrumented/queue-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float32/instrumented/queue-audit.json new file mode 100644 index 0000000..fead1d1 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float32/instrumented/queue-audit.json @@ -0,0 +1,14 @@ +{ + "accepted_due_events": 87, + "advance_calls": 1000, + "all_due_events_preserved": true, + "due_events": 88, + "installations": [ + "default_synapses_pre_codeobject", + "default_synapses_pre_codeobject_17" + ], + "ordering": "raw anatomical queue.peek local edge-index sequence; no sorting or filtering", + "peek_calls": 1000, + "proxy_contract": "peek returns original object; advance and all other methods forward unchanged", + "trace_enabled": true +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float32/instrumented/schedule.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float32/instrumented/schedule.json new file mode 100644 index 0000000..93e03d3 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float32/instrumented/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_common_requests (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 \nzz_oracle_queue_installer (QueueInstaller) | -- | 100. us (every step) | end | 1000000 | yes " +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float32/proxy-validation.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float32/proxy-validation.json new file mode 100644 index 0000000..50c684d --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float32/proxy-validation.json @@ -0,0 +1,33 @@ +{ + "arrival_arrays_excluded": "An unwrapped queue is deliberately not observed", + "exact_arrays": { + "applicable_count": true, + "coefficients": true, + "counts": true, + "external_accepted": true, + "external_step": true, + "external_target": true, + "external_weights": true, + "fired": true, + "g": true, + "history": true, + "initial_g": true, + "initial_v": true, + "local_idx": true, + "neuron_idx": true, + "nodes": true, + "not_refractory": true, + "ref": true, + "ref_history": true, + "rejected_count": true, + "request_accepted": true, + "request_attempted": true, + "request_count": true, + "request_rejected": true, + "step": true, + "v": true, + "weights": true + }, + "pass": true, + "performed": true +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float32/summary.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float32/summary.json new file mode 100644 index 0000000..18ab669 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float32/summary.json @@ -0,0 +1,18 @@ +{ + "applicable_requests": 1, + "coefficient_file": "/data/digital-drosophila/experiments/phase4ae-author-runtime/oracle/motif_trio-float32/coefficients.json", + "complete": true, + "due_arrivals": 88, + "edges": 6, + "name": "motif_trio", + "nodes": 3, + "precision": "float32", + "queue_proxy_validated": true, + "queue_trace_enabled": true, + "rejected_requests": 0, + "requests": 1, + "source_unchanged": true, + "spikes": 45, + "state_file": "/data/digital-drosophila/experiments/phase4ae-author-runtime/oracle/motif_trio-float32/state.npz", + "steps": 1000 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float32/unwrapped-audit/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float32/unwrapped-audit/coefficients.json new file mode 100644 index 0000000..ac12f58 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float32/unwrapped-audit/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_18", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_18", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_18", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_18", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_18", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_18", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float32/unwrapped-audit/compiled-code.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float32/unwrapped-audit/compiled-code.json new file mode 100644 index 0000000..9a4ea64 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float32/unwrapped-audit/compiled-code.json @@ -0,0 +1,114 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float32/unwrapped-audit/completeness.csv b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float32/unwrapped-audit/completeness.csv new file mode 100644 index 0000000..38343a0 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float32/unwrapped-audit/completeness.csv @@ -0,0 +1,4 @@ +global_neuron_idx,local_index +1197,0 +1381,1 +1511,2 diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float32/unwrapped-audit/generated-code.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float32/unwrapped-audit/generated-code.json new file mode 100644 index 0000000..cc981b3 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float32/unwrapped-audit/generated-code.json @@ -0,0 +1,114 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject_18" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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_18" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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_1" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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_18" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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_18" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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_1" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float32/unwrapped-audit/input-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float32/unwrapped-audit/input-audit.json new file mode 100644 index 0000000..c1c1b58 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float32/unwrapped-audit/input-audit.json @@ -0,0 +1,48 @@ +{ + "all_neurons_keep_original_rfc": true, + "completeness_sha256": "e8795d5efb2eebefaae419c6df6d18d3cea3c390d9df7987f55823f5a860169e", + "connectivity_sha256": "22570cdceb09128d4bde46fd75897af776f7d91d89b8581d13133f55779f1e91", + "dt_ms": 0.1, + "parameter_checks": { + "membrane_tau_ms": { + "author": 20.0, + "case": 20.0 + }, + "refractory_ms": { + "author": 2.2, + "case": 2.2 + }, + "reset_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "resting_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "synaptic_delay_ms": { + "author": 1.8, + "case": 1.8 + }, + "synaptic_tau_ms": { + "author": 5.0, + "case": 5.0 + }, + "threshold_mv": { + "author": -45.0, + "case": -45.0 + }, + "w_syn_mv_per_anatomical_synapse": { + "author": 0.275, + "case": 0.275 + } + }, + "poisson_helper_used": false, + "precision": "float32", + "queue_trace_enabled": false, + "request_interface": "before_thresholds; v=v_th+1mV only if not_refractory", + "source_parameters_modified": false, + "source_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "state_units": "SI volts, original dtype", + "steps": 1000 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float32/unwrapped-audit/queue-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float32/unwrapped-audit/queue-audit.json new file mode 100644 index 0000000..6d2ed14 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float32/unwrapped-audit/queue-audit.json @@ -0,0 +1,11 @@ +{ + "accepted_due_events": 0, + "advance_calls": 0, + "all_due_events_preserved": null, + "due_events": 0, + "installations": [], + "ordering": "raw anatomical queue.peek local edge-index sequence; no sorting or filtering", + "peek_calls": 0, + "proxy_contract": "peek returns original object; advance and all other methods forward unchanged", + "trace_enabled": false +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float32/unwrapped-audit/schedule.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float32/unwrapped-audit/schedule.json new file mode 100644 index 0000000..4202f07 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float32/unwrapped-audit/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_common_requests (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 " +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float64/case.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float64/case.json new file mode 100644 index 0000000..e7fee56 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float64/case.json @@ -0,0 +1,35 @@ +{ + "author_commit": "91bdd1e7dcf193f3e7ca5a8933497fcef63b7960", + "author_path": "/data/digital-drosophila/experiments/phase4ad-author-semantics/external-resources/model.py", + "author_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "case_arrays_sha256": "a40e803b1227d4bb6b2c24d76bdf1454cb63ace61ebb9e77ff01010dd91cab37", + "case_spec_sha256": "da4b6cea0b8a33ca15e552425b55ce699d74ddf81660b02eeb30d5edcc4494cd", + "common_interface_preserved": true, + "learning": false, + "original_poi_interface_adopted": false, + "precision": "float64", + "spec": { + "description": "Same selected4AC/4AD motif,100ms prefix; no new edge or weight.", + "dt_ms": 0.1, + "duration_ms": 100.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 + }, + "name": "motif_trio", + "selection": null, + "steps": 1000, + "trace_queue": true, + "validate_queue_proxy": true + }, + "trace_queue": true, + "validate_queue_proxy": true, + "whole_brain": false +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float64/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float64/coefficients.json new file mode 100644 index 0000000..d251654 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float64/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_16", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_16", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_16", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_16", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_16", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_16", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float64/environment.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float64/environment.json new file mode 100644 index 0000000..7b43f4f --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float64/environment.json @@ -0,0 +1,14 @@ +{ + "backend": "Brian2 numpy runtime", + "packages": { + "brian2": "2.5.1", + "cython": "0.29.33", + "numpy": "1.22.3", + "pandas": "1.4.3", + "pyarrow": "11.0.0", + "scipy": "1.8.1", + "sympy": "1.12" + }, + "platform": "Linux-5.15.0-194-generic-x86_64-with-glibc2.35", + "python": "3.10.12 (main, Aug 31 2026, 10:18:17) [GCC 11.4.0]" +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float64/instrumented/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float64/instrumented/coefficients.json new file mode 100644 index 0000000..d251654 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float64/instrumented/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_16", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_16", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_16", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_16", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_16", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_16", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float64/instrumented/compiled-code.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float64/instrumented/compiled-code.json new file mode 100644 index 0000000..3b9afa3 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float64/instrumented/compiled-code.json @@ -0,0 +1,122 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + }, + { + "active": true, + "code_objects": [], + "name": "zz_oracle_queue_installer", + "order": 1000000, + "type": "QueueInstaller", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float64/instrumented/completeness.csv b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float64/instrumented/completeness.csv new file mode 100644 index 0000000..38343a0 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float64/instrumented/completeness.csv @@ -0,0 +1,4 @@ +global_neuron_idx,local_index +1197,0 +1381,1 +1511,2 diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float64/instrumented/generated-code.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float64/instrumented/generated-code.json new file mode 100644 index 0000000..f0ad23d --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float64/instrumented/generated-code.json @@ -0,0 +1,122 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject_16" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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_16" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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_1" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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_16" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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_16" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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_1" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + }, + { + "active": true, + "code_objects": [], + "name": "zz_oracle_queue_installer", + "order": 1000000, + "type": "QueueInstaller", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float64/instrumented/input-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float64/instrumented/input-audit.json new file mode 100644 index 0000000..3c50a9c --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float64/instrumented/input-audit.json @@ -0,0 +1,48 @@ +{ + "all_neurons_keep_original_rfc": true, + "completeness_sha256": "e8795d5efb2eebefaae419c6df6d18d3cea3c390d9df7987f55823f5a860169e", + "connectivity_sha256": "22570cdceb09128d4bde46fd75897af776f7d91d89b8581d13133f55779f1e91", + "dt_ms": 0.1, + "parameter_checks": { + "membrane_tau_ms": { + "author": 20.0, + "case": 20.0 + }, + "refractory_ms": { + "author": 2.2, + "case": 2.2 + }, + "reset_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "resting_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "synaptic_delay_ms": { + "author": 1.8, + "case": 1.8 + }, + "synaptic_tau_ms": { + "author": 5.0, + "case": 5.0 + }, + "threshold_mv": { + "author": -45.0, + "case": -45.0 + }, + "w_syn_mv_per_anatomical_synapse": { + "author": 0.275, + "case": 0.275 + } + }, + "poisson_helper_used": false, + "precision": "float64", + "queue_trace_enabled": true, + "request_interface": "before_thresholds; v=v_th+1mV only if not_refractory", + "source_parameters_modified": false, + "source_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "state_units": "SI volts, original dtype", + "steps": 1000 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float64/instrumented/queue-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float64/instrumented/queue-audit.json new file mode 100644 index 0000000..ae815bf --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float64/instrumented/queue-audit.json @@ -0,0 +1,14 @@ +{ + "accepted_due_events": 87, + "advance_calls": 1000, + "all_due_events_preserved": true, + "due_events": 88, + "installations": [ + "default_synapses_pre_codeobject", + "default_synapses_pre_codeobject_16" + ], + "ordering": "raw anatomical queue.peek local edge-index sequence; no sorting or filtering", + "peek_calls": 1000, + "proxy_contract": "peek returns original object; advance and all other methods forward unchanged", + "trace_enabled": true +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float64/instrumented/schedule.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float64/instrumented/schedule.json new file mode 100644 index 0000000..93e03d3 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float64/instrumented/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_common_requests (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 \nzz_oracle_queue_installer (QueueInstaller) | -- | 100. us (every step) | end | 1000000 | yes " +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float64/proxy-validation.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float64/proxy-validation.json new file mode 100644 index 0000000..50c684d --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float64/proxy-validation.json @@ -0,0 +1,33 @@ +{ + "arrival_arrays_excluded": "An unwrapped queue is deliberately not observed", + "exact_arrays": { + "applicable_count": true, + "coefficients": true, + "counts": true, + "external_accepted": true, + "external_step": true, + "external_target": true, + "external_weights": true, + "fired": true, + "g": true, + "history": true, + "initial_g": true, + "initial_v": true, + "local_idx": true, + "neuron_idx": true, + "nodes": true, + "not_refractory": true, + "ref": true, + "ref_history": true, + "rejected_count": true, + "request_accepted": true, + "request_attempted": true, + "request_count": true, + "request_rejected": true, + "step": true, + "v": true, + "weights": true + }, + "pass": true, + "performed": true +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float64/summary.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float64/summary.json new file mode 100644 index 0000000..abd5e00 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float64/summary.json @@ -0,0 +1,18 @@ +{ + "applicable_requests": 1, + "coefficient_file": "/data/digital-drosophila/experiments/phase4ae-author-runtime/oracle/motif_trio-float64/coefficients.json", + "complete": true, + "due_arrivals": 88, + "edges": 6, + "name": "motif_trio", + "nodes": 3, + "precision": "float64", + "queue_proxy_validated": true, + "queue_trace_enabled": true, + "rejected_requests": 0, + "requests": 1, + "source_unchanged": true, + "spikes": 45, + "state_file": "/data/digital-drosophila/experiments/phase4ae-author-runtime/oracle/motif_trio-float64/state.npz", + "steps": 1000 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float64/unwrapped-audit/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float64/unwrapped-audit/coefficients.json new file mode 100644 index 0000000..f191c81 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float64/unwrapped-audit/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_17", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_17", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_17", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_17", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_17", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_17", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float64/unwrapped-audit/compiled-code.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float64/unwrapped-audit/compiled-code.json new file mode 100644 index 0000000..9a4ea64 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float64/unwrapped-audit/compiled-code.json @@ -0,0 +1,114 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float64/unwrapped-audit/completeness.csv b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float64/unwrapped-audit/completeness.csv new file mode 100644 index 0000000..38343a0 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float64/unwrapped-audit/completeness.csv @@ -0,0 +1,4 @@ +global_neuron_idx,local_index +1197,0 +1381,1 +1511,2 diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float64/unwrapped-audit/generated-code.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float64/unwrapped-audit/generated-code.json new file mode 100644 index 0000000..defef36 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float64/unwrapped-audit/generated-code.json @@ -0,0 +1,114 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject_17" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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_17" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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_1" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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_17" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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_17" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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_1" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float64/unwrapped-audit/input-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float64/unwrapped-audit/input-audit.json new file mode 100644 index 0000000..9816c72 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float64/unwrapped-audit/input-audit.json @@ -0,0 +1,48 @@ +{ + "all_neurons_keep_original_rfc": true, + "completeness_sha256": "e8795d5efb2eebefaae419c6df6d18d3cea3c390d9df7987f55823f5a860169e", + "connectivity_sha256": "22570cdceb09128d4bde46fd75897af776f7d91d89b8581d13133f55779f1e91", + "dt_ms": 0.1, + "parameter_checks": { + "membrane_tau_ms": { + "author": 20.0, + "case": 20.0 + }, + "refractory_ms": { + "author": 2.2, + "case": 2.2 + }, + "reset_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "resting_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "synaptic_delay_ms": { + "author": 1.8, + "case": 1.8 + }, + "synaptic_tau_ms": { + "author": 5.0, + "case": 5.0 + }, + "threshold_mv": { + "author": -45.0, + "case": -45.0 + }, + "w_syn_mv_per_anatomical_synapse": { + "author": 0.275, + "case": 0.275 + } + }, + "poisson_helper_used": false, + "precision": "float64", + "queue_trace_enabled": false, + "request_interface": "before_thresholds; v=v_th+1mV only if not_refractory", + "source_parameters_modified": false, + "source_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "state_units": "SI volts, original dtype", + "steps": 1000 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float64/unwrapped-audit/queue-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float64/unwrapped-audit/queue-audit.json new file mode 100644 index 0000000..6d2ed14 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float64/unwrapped-audit/queue-audit.json @@ -0,0 +1,11 @@ +{ + "accepted_due_events": 0, + "advance_calls": 0, + "all_due_events_preserved": null, + "due_events": 0, + "installations": [], + "ordering": "raw anatomical queue.peek local edge-index sequence; no sorting or filtering", + "peek_calls": 0, + "proxy_contract": "peek returns original object; advance and all other methods forward unchanged", + "trace_enabled": false +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float64/unwrapped-audit/schedule.json b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float64/unwrapped-audit/schedule.json new file mode 100644 index 0000000..4202f07 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/motif_trio-float64/unwrapped-audit/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_common_requests (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 " +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float32/case.json b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float32/case.json new file mode 100644 index 0000000..f075545 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float32/case.json @@ -0,0 +1,35 @@ +{ + "author_commit": "91bdd1e7dcf193f3e7ca5a8933497fcef63b7960", + "author_path": "/data/digital-drosophila/experiments/phase4ad-author-semantics/external-resources/model.py", + "author_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "case_arrays_sha256": "97e033aaacc5703bca141b03a1db1d33522a3bf8c7ae182bafd15cafcb4c1e23", + "case_spec_sha256": "1866003021cc39ad50858fe0d9f56d74e8dd16bd574eef15c0625b604cd987b2", + "common_interface_preserved": true, + "learning": false, + "original_poi_interface_adopted": false, + "precision": "float32", + "spec": { + "description": "Pure synthetic numerical cancellation; huge counts are nonphysiological; nonzero initial g.", + "dt_ms": 0.1, + "duration_ms": 16.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 + }, + "name": "ordered_cancellation", + "selection": null, + "steps": 160, + "trace_queue": true, + "validate_queue_proxy": true + }, + "trace_queue": true, + "validate_queue_proxy": true, + "whole_brain": false +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float32/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float32/coefficients.json new file mode 100644 index 0000000..053d280 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float32/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_19", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_19", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_19", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_19", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_19", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_19", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float32/environment.json b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float32/environment.json new file mode 100644 index 0000000..7b43f4f --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float32/environment.json @@ -0,0 +1,14 @@ +{ + "backend": "Brian2 numpy runtime", + "packages": { + "brian2": "2.5.1", + "cython": "0.29.33", + "numpy": "1.22.3", + "pandas": "1.4.3", + "pyarrow": "11.0.0", + "scipy": "1.8.1", + "sympy": "1.12" + }, + "platform": "Linux-5.15.0-194-generic-x86_64-with-glibc2.35", + "python": "3.10.12 (main, Aug 31 2026, 10:18:17) [GCC 11.4.0]" +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float32/instrumented/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float32/instrumented/coefficients.json new file mode 100644 index 0000000..053d280 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float32/instrumented/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_19", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_19", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_19", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_19", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_19", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_19", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float32/instrumented/compiled-code.json b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float32/instrumented/compiled-code.json new file mode 100644 index 0000000..3b9afa3 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float32/instrumented/compiled-code.json @@ -0,0 +1,122 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + }, + { + "active": true, + "code_objects": [], + "name": "zz_oracle_queue_installer", + "order": 1000000, + "type": "QueueInstaller", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float32/instrumented/completeness.csv b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float32/instrumented/completeness.csv new file mode 100644 index 0000000..8079dd9 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float32/instrumented/completeness.csv @@ -0,0 +1,34 @@ +global_neuron_idx,local_index +-33,0 +-32,1 +-31,2 +-30,3 +-29,4 +-28,5 +-27,6 +-26,7 +-25,8 +-24,9 +-23,10 +-22,11 +-21,12 +-20,13 +-19,14 +-18,15 +-17,16 +-16,17 +-15,18 +-14,19 +-13,20 +-12,21 +-11,22 +-10,23 +-9,24 +-8,25 +-7,26 +-6,27 +-5,28 +-4,29 +-3,30 +-2,31 +-1,32 diff --git a/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float32/instrumented/generated-code.json b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float32/instrumented/generated-code.json new file mode 100644 index 0000000..9c7604d --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float32/instrumented/generated-code.json @@ -0,0 +1,122 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject_19" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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_19" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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_1" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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_19" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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_19" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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_1" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + }, + { + "active": true, + "code_objects": [], + "name": "zz_oracle_queue_installer", + "order": 1000000, + "type": "QueueInstaller", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float32/instrumented/input-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float32/instrumented/input-audit.json new file mode 100644 index 0000000..e80603f --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float32/instrumented/input-audit.json @@ -0,0 +1,48 @@ +{ + "all_neurons_keep_original_rfc": true, + "completeness_sha256": "d861bdcdccde99f4c49e489f5f22e274a3e810fa365d0858513d91092f6ddeed", + "connectivity_sha256": "5fd8201a0e8f908045308387d8b87bff1efc86f643b0ab2808623110949b7923", + "dt_ms": 0.1, + "parameter_checks": { + "membrane_tau_ms": { + "author": 20.0, + "case": 20.0 + }, + "refractory_ms": { + "author": 2.2, + "case": 2.2 + }, + "reset_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "resting_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "synaptic_delay_ms": { + "author": 1.8, + "case": 1.8 + }, + "synaptic_tau_ms": { + "author": 5.0, + "case": 5.0 + }, + "threshold_mv": { + "author": -45.0, + "case": -45.0 + }, + "w_syn_mv_per_anatomical_synapse": { + "author": 0.275, + "case": 0.275 + } + }, + "poisson_helper_used": false, + "precision": "float32", + "queue_trace_enabled": true, + "request_interface": "before_thresholds; v=v_th+1mV only if not_refractory", + "source_parameters_modified": false, + "source_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "state_units": "SI volts, original dtype", + "steps": 160 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float32/instrumented/queue-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float32/instrumented/queue-audit.json new file mode 100644 index 0000000..da9a81f --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float32/instrumented/queue-audit.json @@ -0,0 +1,14 @@ +{ + "accepted_due_events": 32, + "advance_calls": 160, + "all_due_events_preserved": true, + "due_events": 32, + "installations": [ + "default_synapses_pre_codeobject", + "default_synapses_pre_codeobject_19" + ], + "ordering": "raw anatomical queue.peek local edge-index sequence; no sorting or filtering", + "peek_calls": 160, + "proxy_contract": "peek returns original object; advance and all other methods forward unchanged", + "trace_enabled": true +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float32/instrumented/schedule.json b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float32/instrumented/schedule.json new file mode 100644 index 0000000..93e03d3 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float32/instrumented/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_common_requests (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 \nzz_oracle_queue_installer (QueueInstaller) | -- | 100. us (every step) | end | 1000000 | yes " +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float32/proxy-validation.json b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float32/proxy-validation.json new file mode 100644 index 0000000..50c684d --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float32/proxy-validation.json @@ -0,0 +1,33 @@ +{ + "arrival_arrays_excluded": "An unwrapped queue is deliberately not observed", + "exact_arrays": { + "applicable_count": true, + "coefficients": true, + "counts": true, + "external_accepted": true, + "external_step": true, + "external_target": true, + "external_weights": true, + "fired": true, + "g": true, + "history": true, + "initial_g": true, + "initial_v": true, + "local_idx": true, + "neuron_idx": true, + "nodes": true, + "not_refractory": true, + "ref": true, + "ref_history": true, + "rejected_count": true, + "request_accepted": true, + "request_attempted": true, + "request_count": true, + "request_rejected": true, + "step": true, + "v": true, + "weights": true + }, + "pass": true, + "performed": true +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float32/summary.json b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float32/summary.json new file mode 100644 index 0000000..2d57845 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float32/summary.json @@ -0,0 +1,18 @@ +{ + "applicable_requests": 32, + "coefficient_file": "/data/digital-drosophila/experiments/phase4ae-author-runtime/oracle/ordered_cancellation-float32/coefficients.json", + "complete": true, + "due_arrivals": 32, + "edges": 32, + "name": "ordered_cancellation", + "nodes": 33, + "precision": "float32", + "queue_proxy_validated": true, + "queue_trace_enabled": true, + "rejected_requests": 0, + "requests": 32, + "source_unchanged": true, + "spikes": 32, + "state_file": "/data/digital-drosophila/experiments/phase4ae-author-runtime/oracle/ordered_cancellation-float32/state.npz", + "steps": 160 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float32/unwrapped-audit/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float32/unwrapped-audit/coefficients.json new file mode 100644 index 0000000..ff21840 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float32/unwrapped-audit/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_20", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_20", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_20", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_20", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_20", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_20", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float32/unwrapped-audit/compiled-code.json b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float32/unwrapped-audit/compiled-code.json new file mode 100644 index 0000000..9a4ea64 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float32/unwrapped-audit/compiled-code.json @@ -0,0 +1,114 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float32/unwrapped-audit/completeness.csv b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float32/unwrapped-audit/completeness.csv new file mode 100644 index 0000000..8079dd9 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float32/unwrapped-audit/completeness.csv @@ -0,0 +1,34 @@ +global_neuron_idx,local_index +-33,0 +-32,1 +-31,2 +-30,3 +-29,4 +-28,5 +-27,6 +-26,7 +-25,8 +-24,9 +-23,10 +-22,11 +-21,12 +-20,13 +-19,14 +-18,15 +-17,16 +-16,17 +-15,18 +-14,19 +-13,20 +-12,21 +-11,22 +-10,23 +-9,24 +-8,25 +-7,26 +-6,27 +-5,28 +-4,29 +-3,30 +-2,31 +-1,32 diff --git a/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float32/unwrapped-audit/generated-code.json b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float32/unwrapped-audit/generated-code.json new file mode 100644 index 0000000..43a7ee2 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float32/unwrapped-audit/generated-code.json @@ -0,0 +1,114 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject_20" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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_20" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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_1" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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_20" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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_20" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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_1" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float32/unwrapped-audit/input-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float32/unwrapped-audit/input-audit.json new file mode 100644 index 0000000..f1f203a --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float32/unwrapped-audit/input-audit.json @@ -0,0 +1,48 @@ +{ + "all_neurons_keep_original_rfc": true, + "completeness_sha256": "d861bdcdccde99f4c49e489f5f22e274a3e810fa365d0858513d91092f6ddeed", + "connectivity_sha256": "5fd8201a0e8f908045308387d8b87bff1efc86f643b0ab2808623110949b7923", + "dt_ms": 0.1, + "parameter_checks": { + "membrane_tau_ms": { + "author": 20.0, + "case": 20.0 + }, + "refractory_ms": { + "author": 2.2, + "case": 2.2 + }, + "reset_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "resting_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "synaptic_delay_ms": { + "author": 1.8, + "case": 1.8 + }, + "synaptic_tau_ms": { + "author": 5.0, + "case": 5.0 + }, + "threshold_mv": { + "author": -45.0, + "case": -45.0 + }, + "w_syn_mv_per_anatomical_synapse": { + "author": 0.275, + "case": 0.275 + } + }, + "poisson_helper_used": false, + "precision": "float32", + "queue_trace_enabled": false, + "request_interface": "before_thresholds; v=v_th+1mV only if not_refractory", + "source_parameters_modified": false, + "source_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "state_units": "SI volts, original dtype", + "steps": 160 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float32/unwrapped-audit/queue-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float32/unwrapped-audit/queue-audit.json new file mode 100644 index 0000000..6d2ed14 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float32/unwrapped-audit/queue-audit.json @@ -0,0 +1,11 @@ +{ + "accepted_due_events": 0, + "advance_calls": 0, + "all_due_events_preserved": null, + "due_events": 0, + "installations": [], + "ordering": "raw anatomical queue.peek local edge-index sequence; no sorting or filtering", + "peek_calls": 0, + "proxy_contract": "peek returns original object; advance and all other methods forward unchanged", + "trace_enabled": false +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float32/unwrapped-audit/schedule.json b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float32/unwrapped-audit/schedule.json new file mode 100644 index 0000000..4202f07 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float32/unwrapped-audit/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_common_requests (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 " +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float64/case.json b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float64/case.json new file mode 100644 index 0000000..ae2206b --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float64/case.json @@ -0,0 +1,35 @@ +{ + "author_commit": "91bdd1e7dcf193f3e7ca5a8933497fcef63b7960", + "author_path": "/data/digital-drosophila/experiments/phase4ad-author-semantics/external-resources/model.py", + "author_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "case_arrays_sha256": "97e033aaacc5703bca141b03a1db1d33522a3bf8c7ae182bafd15cafcb4c1e23", + "case_spec_sha256": "1866003021cc39ad50858fe0d9f56d74e8dd16bd574eef15c0625b604cd987b2", + "common_interface_preserved": true, + "learning": false, + "original_poi_interface_adopted": false, + "precision": "float64", + "spec": { + "description": "Pure synthetic numerical cancellation; huge counts are nonphysiological; nonzero initial g.", + "dt_ms": 0.1, + "duration_ms": 16.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 + }, + "name": "ordered_cancellation", + "selection": null, + "steps": 160, + "trace_queue": true, + "validate_queue_proxy": true + }, + "trace_queue": true, + "validate_queue_proxy": true, + "whole_brain": false +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float64/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float64/coefficients.json new file mode 100644 index 0000000..ac12f58 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float64/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_18", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_18", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_18", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_18", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_18", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_18", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float64/environment.json b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float64/environment.json new file mode 100644 index 0000000..7b43f4f --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float64/environment.json @@ -0,0 +1,14 @@ +{ + "backend": "Brian2 numpy runtime", + "packages": { + "brian2": "2.5.1", + "cython": "0.29.33", + "numpy": "1.22.3", + "pandas": "1.4.3", + "pyarrow": "11.0.0", + "scipy": "1.8.1", + "sympy": "1.12" + }, + "platform": "Linux-5.15.0-194-generic-x86_64-with-glibc2.35", + "python": "3.10.12 (main, Aug 31 2026, 10:18:17) [GCC 11.4.0]" +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float64/instrumented/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float64/instrumented/coefficients.json new file mode 100644 index 0000000..ac12f58 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float64/instrumented/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_18", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_18", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_18", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_18", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_18", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_18", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float64/instrumented/compiled-code.json b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float64/instrumented/compiled-code.json new file mode 100644 index 0000000..3b9afa3 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float64/instrumented/compiled-code.json @@ -0,0 +1,122 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + }, + { + "active": true, + "code_objects": [], + "name": "zz_oracle_queue_installer", + "order": 1000000, + "type": "QueueInstaller", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float64/instrumented/completeness.csv b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float64/instrumented/completeness.csv new file mode 100644 index 0000000..8079dd9 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float64/instrumented/completeness.csv @@ -0,0 +1,34 @@ +global_neuron_idx,local_index +-33,0 +-32,1 +-31,2 +-30,3 +-29,4 +-28,5 +-27,6 +-26,7 +-25,8 +-24,9 +-23,10 +-22,11 +-21,12 +-20,13 +-19,14 +-18,15 +-17,16 +-16,17 +-15,18 +-14,19 +-13,20 +-12,21 +-11,22 +-10,23 +-9,24 +-8,25 +-7,26 +-6,27 +-5,28 +-4,29 +-3,30 +-2,31 +-1,32 diff --git a/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float64/instrumented/generated-code.json b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float64/instrumented/generated-code.json new file mode 100644 index 0000000..1588cb6 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float64/instrumented/generated-code.json @@ -0,0 +1,122 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject_18" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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_18" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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_1" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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_18" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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_18" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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_1" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + }, + { + "active": true, + "code_objects": [], + "name": "zz_oracle_queue_installer", + "order": 1000000, + "type": "QueueInstaller", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float64/instrumented/input-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float64/instrumented/input-audit.json new file mode 100644 index 0000000..1e51e10 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float64/instrumented/input-audit.json @@ -0,0 +1,48 @@ +{ + "all_neurons_keep_original_rfc": true, + "completeness_sha256": "d861bdcdccde99f4c49e489f5f22e274a3e810fa365d0858513d91092f6ddeed", + "connectivity_sha256": "5fd8201a0e8f908045308387d8b87bff1efc86f643b0ab2808623110949b7923", + "dt_ms": 0.1, + "parameter_checks": { + "membrane_tau_ms": { + "author": 20.0, + "case": 20.0 + }, + "refractory_ms": { + "author": 2.2, + "case": 2.2 + }, + "reset_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "resting_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "synaptic_delay_ms": { + "author": 1.8, + "case": 1.8 + }, + "synaptic_tau_ms": { + "author": 5.0, + "case": 5.0 + }, + "threshold_mv": { + "author": -45.0, + "case": -45.0 + }, + "w_syn_mv_per_anatomical_synapse": { + "author": 0.275, + "case": 0.275 + } + }, + "poisson_helper_used": false, + "precision": "float64", + "queue_trace_enabled": true, + "request_interface": "before_thresholds; v=v_th+1mV only if not_refractory", + "source_parameters_modified": false, + "source_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "state_units": "SI volts, original dtype", + "steps": 160 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float64/instrumented/queue-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float64/instrumented/queue-audit.json new file mode 100644 index 0000000..8d15e89 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float64/instrumented/queue-audit.json @@ -0,0 +1,14 @@ +{ + "accepted_due_events": 32, + "advance_calls": 160, + "all_due_events_preserved": true, + "due_events": 32, + "installations": [ + "default_synapses_pre_codeobject", + "default_synapses_pre_codeobject_18" + ], + "ordering": "raw anatomical queue.peek local edge-index sequence; no sorting or filtering", + "peek_calls": 160, + "proxy_contract": "peek returns original object; advance and all other methods forward unchanged", + "trace_enabled": true +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float64/instrumented/schedule.json b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float64/instrumented/schedule.json new file mode 100644 index 0000000..93e03d3 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float64/instrumented/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_common_requests (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 \nzz_oracle_queue_installer (QueueInstaller) | -- | 100. us (every step) | end | 1000000 | yes " +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float64/proxy-validation.json b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float64/proxy-validation.json new file mode 100644 index 0000000..50c684d --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float64/proxy-validation.json @@ -0,0 +1,33 @@ +{ + "arrival_arrays_excluded": "An unwrapped queue is deliberately not observed", + "exact_arrays": { + "applicable_count": true, + "coefficients": true, + "counts": true, + "external_accepted": true, + "external_step": true, + "external_target": true, + "external_weights": true, + "fired": true, + "g": true, + "history": true, + "initial_g": true, + "initial_v": true, + "local_idx": true, + "neuron_idx": true, + "nodes": true, + "not_refractory": true, + "ref": true, + "ref_history": true, + "rejected_count": true, + "request_accepted": true, + "request_attempted": true, + "request_count": true, + "request_rejected": true, + "step": true, + "v": true, + "weights": true + }, + "pass": true, + "performed": true +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float64/summary.json b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float64/summary.json new file mode 100644 index 0000000..61e2cc2 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float64/summary.json @@ -0,0 +1,18 @@ +{ + "applicable_requests": 32, + "coefficient_file": "/data/digital-drosophila/experiments/phase4ae-author-runtime/oracle/ordered_cancellation-float64/coefficients.json", + "complete": true, + "due_arrivals": 32, + "edges": 32, + "name": "ordered_cancellation", + "nodes": 33, + "precision": "float64", + "queue_proxy_validated": true, + "queue_trace_enabled": true, + "rejected_requests": 0, + "requests": 32, + "source_unchanged": true, + "spikes": 32, + "state_file": "/data/digital-drosophila/experiments/phase4ae-author-runtime/oracle/ordered_cancellation-float64/state.npz", + "steps": 160 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float64/unwrapped-audit/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float64/unwrapped-audit/coefficients.json new file mode 100644 index 0000000..053d280 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float64/unwrapped-audit/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_19", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_19", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_19", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_19", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_19", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_19", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float64/unwrapped-audit/compiled-code.json b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float64/unwrapped-audit/compiled-code.json new file mode 100644 index 0000000..9a4ea64 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float64/unwrapped-audit/compiled-code.json @@ -0,0 +1,114 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float64/unwrapped-audit/completeness.csv b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float64/unwrapped-audit/completeness.csv new file mode 100644 index 0000000..8079dd9 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float64/unwrapped-audit/completeness.csv @@ -0,0 +1,34 @@ +global_neuron_idx,local_index +-33,0 +-32,1 +-31,2 +-30,3 +-29,4 +-28,5 +-27,6 +-26,7 +-25,8 +-24,9 +-23,10 +-22,11 +-21,12 +-20,13 +-19,14 +-18,15 +-17,16 +-16,17 +-15,18 +-14,19 +-13,20 +-12,21 +-11,22 +-10,23 +-9,24 +-8,25 +-7,26 +-6,27 +-5,28 +-4,29 +-3,30 +-2,31 +-1,32 diff --git a/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float64/unwrapped-audit/generated-code.json b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float64/unwrapped-audit/generated-code.json new file mode 100644 index 0000000..c705fc8 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float64/unwrapped-audit/generated-code.json @@ -0,0 +1,114 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject_19" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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_19" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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_1" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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_19" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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_19" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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_1" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float64/unwrapped-audit/input-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float64/unwrapped-audit/input-audit.json new file mode 100644 index 0000000..152aecc --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float64/unwrapped-audit/input-audit.json @@ -0,0 +1,48 @@ +{ + "all_neurons_keep_original_rfc": true, + "completeness_sha256": "d861bdcdccde99f4c49e489f5f22e274a3e810fa365d0858513d91092f6ddeed", + "connectivity_sha256": "5fd8201a0e8f908045308387d8b87bff1efc86f643b0ab2808623110949b7923", + "dt_ms": 0.1, + "parameter_checks": { + "membrane_tau_ms": { + "author": 20.0, + "case": 20.0 + }, + "refractory_ms": { + "author": 2.2, + "case": 2.2 + }, + "reset_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "resting_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "synaptic_delay_ms": { + "author": 1.8, + "case": 1.8 + }, + "synaptic_tau_ms": { + "author": 5.0, + "case": 5.0 + }, + "threshold_mv": { + "author": -45.0, + "case": -45.0 + }, + "w_syn_mv_per_anatomical_synapse": { + "author": 0.275, + "case": 0.275 + } + }, + "poisson_helper_used": false, + "precision": "float64", + "queue_trace_enabled": false, + "request_interface": "before_thresholds; v=v_th+1mV only if not_refractory", + "source_parameters_modified": false, + "source_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "state_units": "SI volts, original dtype", + "steps": 160 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float64/unwrapped-audit/queue-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float64/unwrapped-audit/queue-audit.json new file mode 100644 index 0000000..6d2ed14 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float64/unwrapped-audit/queue-audit.json @@ -0,0 +1,11 @@ +{ + "accepted_due_events": 0, + "advance_calls": 0, + "all_due_events_preserved": null, + "due_events": 0, + "installations": [], + "ordering": "raw anatomical queue.peek local edge-index sequence; no sorting or filtering", + "peek_calls": 0, + "proxy_contract": "peek returns original object; advance and all other methods forward unchanged", + "trace_enabled": false +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float64/unwrapped-audit/schedule.json b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float64/unwrapped-audit/schedule.json new file mode 100644 index 0000000..4202f07 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/ordered_cancellation-float64/unwrapped-audit/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_common_requests (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 " +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float32/case.json b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float32/case.json new file mode 100644 index 0000000..f4c5300 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float32/case.json @@ -0,0 +1,35 @@ +{ + "author_commit": "91bdd1e7dcf193f3e7ca5a8933497fcef63b7960", + "author_path": "/data/digital-drosophila/experiments/phase4ad-author-semantics/external-resources/model.py", + "author_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "case_arrays_sha256": "aececf2fd48c52804d84852483e467b13d23b7b675c8b7b0d967c02aee960a5f", + "case_spec_sha256": "f63a2d3a4e99220a42944461a3223c459e3a1e7c02d22dc5e30cd129dd9452d1", + "common_interface_preserved": true, + "learning": false, + "original_poi_interface_adopted": false, + "precision": "float32", + "spec": { + "description": "Release at22 with same-tick force/arrival, loops and ring wraps.", + "dt_ms": 0.1, + "duration_ms": 16.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 + }, + "name": "release_selfloop", + "selection": null, + "steps": 160, + "trace_queue": true, + "validate_queue_proxy": true + }, + "trace_queue": true, + "validate_queue_proxy": true, + "whole_brain": false +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float32/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float32/coefficients.json new file mode 100644 index 0000000..af67540 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float32/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_21", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_21", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_21", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_21", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_21", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_21", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float32/environment.json b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float32/environment.json new file mode 100644 index 0000000..7b43f4f --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float32/environment.json @@ -0,0 +1,14 @@ +{ + "backend": "Brian2 numpy runtime", + "packages": { + "brian2": "2.5.1", + "cython": "0.29.33", + "numpy": "1.22.3", + "pandas": "1.4.3", + "pyarrow": "11.0.0", + "scipy": "1.8.1", + "sympy": "1.12" + }, + "platform": "Linux-5.15.0-194-generic-x86_64-with-glibc2.35", + "python": "3.10.12 (main, Aug 31 2026, 10:18:17) [GCC 11.4.0]" +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float32/instrumented/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float32/instrumented/coefficients.json new file mode 100644 index 0000000..af67540 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float32/instrumented/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_21", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_21", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_21", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_21", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_21", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_21", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float32/instrumented/compiled-code.json b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float32/instrumented/compiled-code.json new file mode 100644 index 0000000..759f6b7 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float32/instrumented/compiled-code.json @@ -0,0 +1,162 @@ +[ + { + "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" + }, + { + "active": true, + "code_objects": [], + "name": "zz_external_arrivals", + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "when": "thresholds" + }, + { + "abstract_code": "", + "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 _the_period = _array_zz_external_sources__period_bins[0]\n _timebin = _array_defaultclock_timestep[0]\n _n_spikes = 0\n _lastindex_before = _array_zz_external_sources__lastindex[0]\n if _the_period > 0:\n _timebin %= _the_period\n # If there is a periodicity in the SpikeGenerator, we need to reset the\n # lastindex when the period has passed\n if _lastindex_before > 0 and _array_zz_external_sources__timebins[_lastindex_before - 1] >= _timebin:\n _lastindex_before = 0\n _n_spikes = _numpy.searchsorted(_array_zz_external_sources__timebins[_lastindex_before:],\n _timebin, side='right')\n _array_zz_external_sources__lastindex[0] = _lastindex_before + _n_spikes\n _indices = _array_zz_external_sources_neuron_index[_lastindex_before:_lastindex_before+_n_spikes]\n _array_zz_external_sources__spikespace[:_n_spikes] = _indices\n _array_zz_external_sources__spikespace[-1] = _n_spikes\n", + "name": "zz_external_sources_codeobject" + } + ], + "name": "zz_external_sources", + "order": 0, + "type": "SpikeGeneratorGroup", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "when": "synapses" + }, + { + "abstract_code": "g_post += 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": "zz_external_arrivals_pre_push_spikes" + }, + { + "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_post += w\n _postsynaptic_idx = _array_zz_external_arrivals__synaptic_post[_idx]\n not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_zz_external_arrivals_w[_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": "zz_external_arrivals_pre_codeobject" + } + ], + "name": "zz_external_arrivals_pre", + "order": 0, + "type": "SynapticPathway", + "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" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + }, + { + "active": true, + "code_objects": [], + "name": "zz_oracle_queue_installer", + "order": 1000000, + "type": "QueueInstaller", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float32/instrumented/completeness.csv b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float32/instrumented/completeness.csv new file mode 100644 index 0000000..df47ae8 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float32/instrumented/completeness.csv @@ -0,0 +1,5 @@ +global_neuron_idx,local_index +-4,0 +-3,1 +-2,2 +-1,3 diff --git a/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float32/instrumented/generated-code.json b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float32/instrumented/generated-code.json new file mode 100644 index 0000000..ad4e743 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float32/instrumented/generated-code.json @@ -0,0 +1,162 @@ +[ + { + "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" + }, + { + "active": true, + "code_objects": [], + "name": "zz_external_arrivals", + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject_21" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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_21" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "when": "thresholds" + }, + { + "abstract_code": "", + "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 _the_period = _array_zz_external_sources__period_bins[0]\n _timebin = _array_defaultclock_timestep[0]\n _n_spikes = 0\n _lastindex_before = _array_zz_external_sources__lastindex[0]\n if _the_period > 0:\n _timebin %= _the_period\n # If there is a periodicity in the SpikeGenerator, we need to reset the\n # lastindex when the period has passed\n if _lastindex_before > 0 and _array_zz_external_sources__timebins[_lastindex_before - 1] >= _timebin:\n _lastindex_before = 0\n _n_spikes = _numpy.searchsorted(_array_zz_external_sources__timebins[_lastindex_before:],\n _timebin, side='right')\n _array_zz_external_sources__lastindex[0] = _lastindex_before + _n_spikes\n _indices = _array_zz_external_sources_neuron_index[_lastindex_before:_lastindex_before+_n_spikes]\n _array_zz_external_sources__spikespace[:_n_spikes] = _indices\n _array_zz_external_sources__spikespace[-1] = _n_spikes\n", + "name": "zz_external_sources_codeobject_2" + } + ], + "name": "zz_external_sources", + "order": 0, + "type": "SpikeGeneratorGroup", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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_1" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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_21" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "when": "synapses" + }, + { + "abstract_code": "g_post += 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": "zz_external_arrivals_pre_push_spikes" + }, + { + "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_post += w\n _postsynaptic_idx = _array_zz_external_arrivals__synaptic_post[_idx]\n not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_zz_external_arrivals_w[_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": "zz_external_arrivals_pre_codeobject_2" + } + ], + "name": "zz_external_arrivals_pre", + "order": 0, + "type": "SynapticPathway", + "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_21" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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_1" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + }, + { + "active": true, + "code_objects": [], + "name": "zz_oracle_queue_installer", + "order": 1000000, + "type": "QueueInstaller", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float32/instrumented/input-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float32/instrumented/input-audit.json new file mode 100644 index 0000000..9ee06e3 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float32/instrumented/input-audit.json @@ -0,0 +1,48 @@ +{ + "all_neurons_keep_original_rfc": true, + "completeness_sha256": "c79ddcee44e7786a8805ed8bd4685d8107764e5dff4952b204e5163f8630ce80", + "connectivity_sha256": "7dbc19bebd51061ac3272c69fe12a7a0a0d179ab21ff6d35193070c64db310f4", + "dt_ms": 0.1, + "parameter_checks": { + "membrane_tau_ms": { + "author": 20.0, + "case": 20.0 + }, + "refractory_ms": { + "author": 2.2, + "case": 2.2 + }, + "reset_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "resting_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "synaptic_delay_ms": { + "author": 1.8, + "case": 1.8 + }, + "synaptic_tau_ms": { + "author": 5.0, + "case": 5.0 + }, + "threshold_mv": { + "author": -45.0, + "case": -45.0 + }, + "w_syn_mv_per_anatomical_synapse": { + "author": 0.275, + "case": 0.275 + } + }, + "poisson_helper_used": false, + "precision": "float32", + "queue_trace_enabled": true, + "request_interface": "before_thresholds; v=v_th+1mV only if not_refractory", + "source_parameters_modified": false, + "source_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "state_units": "SI volts, original dtype", + "steps": 160 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float32/instrumented/queue-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float32/instrumented/queue-audit.json new file mode 100644 index 0000000..7c3e06b --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float32/instrumented/queue-audit.json @@ -0,0 +1,14 @@ +{ + "accepted_due_events": 4, + "advance_calls": 160, + "all_due_events_preserved": true, + "due_events": 11, + "installations": [ + "default_synapses_pre_codeobject", + "default_synapses_pre_codeobject_21" + ], + "ordering": "raw anatomical queue.peek local edge-index sequence; no sorting or filtering", + "peek_calls": 160, + "proxy_contract": "peek returns original object; advance and all other methods forward unchanged", + "trace_enabled": true +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float32/instrumented/schedule.json b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float32/instrumented/schedule.json new file mode 100644 index 0000000..445ab0c --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float32/instrumented/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_common_requests (NetworkOperation) | -- | 100. us (every step) | before_thresholds | 0 | yes \ndefault_neurons_spike_thresholder (Thresholder) | default_neurons (NeuronGroup) | 100. us (every step) | thresholds | 0 | yes \nzz_external_sources (SpikeGeneratorGroup) | zz_external_sources (SpikeGeneratorGroup) | 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 \nzz_external_arrivals_pre (SynapticPathway) | zz_external_arrivals (Synapses) | 100. us (every step) | synapses | 0 | 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 \nzz_oracle_queue_installer (QueueInstaller) | -- | 100. us (every step) | end | 1000000 | yes " +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float32/proxy-validation.json b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float32/proxy-validation.json new file mode 100644 index 0000000..50c684d --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float32/proxy-validation.json @@ -0,0 +1,33 @@ +{ + "arrival_arrays_excluded": "An unwrapped queue is deliberately not observed", + "exact_arrays": { + "applicable_count": true, + "coefficients": true, + "counts": true, + "external_accepted": true, + "external_step": true, + "external_target": true, + "external_weights": true, + "fired": true, + "g": true, + "history": true, + "initial_g": true, + "initial_v": true, + "local_idx": true, + "neuron_idx": true, + "nodes": true, + "not_refractory": true, + "ref": true, + "ref_history": true, + "rejected_count": true, + "request_accepted": true, + "request_attempted": true, + "request_count": true, + "request_rejected": true, + "step": true, + "v": true, + "weights": true + }, + "pass": true, + "performed": true +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float32/summary.json b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float32/summary.json new file mode 100644 index 0000000..7e2ab1f --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float32/summary.json @@ -0,0 +1,18 @@ +{ + "applicable_requests": 6, + "coefficient_file": "/data/digital-drosophila/experiments/phase4ae-author-runtime/oracle/release_selfloop-float32/coefficients.json", + "complete": true, + "due_arrivals": 11, + "edges": 5, + "name": "release_selfloop", + "nodes": 4, + "precision": "float32", + "queue_proxy_validated": true, + "queue_trace_enabled": true, + "rejected_requests": 0, + "requests": 6, + "source_unchanged": true, + "spikes": 8, + "state_file": "/data/digital-drosophila/experiments/phase4ae-author-runtime/oracle/release_selfloop-float32/state.npz", + "steps": 160 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float32/unwrapped-audit/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float32/unwrapped-audit/coefficients.json new file mode 100644 index 0000000..4350ac7 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float32/unwrapped-audit/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_22", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_22", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_22", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_22", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_22", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_22", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float32/unwrapped-audit/compiled-code.json b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float32/unwrapped-audit/compiled-code.json new file mode 100644 index 0000000..b323fd4 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float32/unwrapped-audit/compiled-code.json @@ -0,0 +1,154 @@ +[ + { + "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" + }, + { + "active": true, + "code_objects": [], + "name": "zz_external_arrivals", + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "when": "thresholds" + }, + { + "abstract_code": "", + "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 _the_period = _array_zz_external_sources__period_bins[0]\n _timebin = _array_defaultclock_timestep[0]\n _n_spikes = 0\n _lastindex_before = _array_zz_external_sources__lastindex[0]\n if _the_period > 0:\n _timebin %= _the_period\n # If there is a periodicity in the SpikeGenerator, we need to reset the\n # lastindex when the period has passed\n if _lastindex_before > 0 and _array_zz_external_sources__timebins[_lastindex_before - 1] >= _timebin:\n _lastindex_before = 0\n _n_spikes = _numpy.searchsorted(_array_zz_external_sources__timebins[_lastindex_before:],\n _timebin, side='right')\n _array_zz_external_sources__lastindex[0] = _lastindex_before + _n_spikes\n _indices = _array_zz_external_sources_neuron_index[_lastindex_before:_lastindex_before+_n_spikes]\n _array_zz_external_sources__spikespace[:_n_spikes] = _indices\n _array_zz_external_sources__spikespace[-1] = _n_spikes\n", + "name": "zz_external_sources_codeobject" + } + ], + "name": "zz_external_sources", + "order": 0, + "type": "SpikeGeneratorGroup", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "when": "synapses" + }, + { + "abstract_code": "g_post += 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": "zz_external_arrivals_pre_push_spikes" + }, + { + "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_post += w\n _postsynaptic_idx = _array_zz_external_arrivals__synaptic_post[_idx]\n not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_zz_external_arrivals_w[_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": "zz_external_arrivals_pre_codeobject" + } + ], + "name": "zz_external_arrivals_pre", + "order": 0, + "type": "SynapticPathway", + "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" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float32/unwrapped-audit/completeness.csv b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float32/unwrapped-audit/completeness.csv new file mode 100644 index 0000000..df47ae8 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float32/unwrapped-audit/completeness.csv @@ -0,0 +1,5 @@ +global_neuron_idx,local_index +-4,0 +-3,1 +-2,2 +-1,3 diff --git a/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float32/unwrapped-audit/generated-code.json b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float32/unwrapped-audit/generated-code.json new file mode 100644 index 0000000..2e2e925 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float32/unwrapped-audit/generated-code.json @@ -0,0 +1,154 @@ +[ + { + "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" + }, + { + "active": true, + "code_objects": [], + "name": "zz_external_arrivals", + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject_22" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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_22" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "when": "thresholds" + }, + { + "abstract_code": "", + "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 _the_period = _array_zz_external_sources__period_bins[0]\n _timebin = _array_defaultclock_timestep[0]\n _n_spikes = 0\n _lastindex_before = _array_zz_external_sources__lastindex[0]\n if _the_period > 0:\n _timebin %= _the_period\n # If there is a periodicity in the SpikeGenerator, we need to reset the\n # lastindex when the period has passed\n if _lastindex_before > 0 and _array_zz_external_sources__timebins[_lastindex_before - 1] >= _timebin:\n _lastindex_before = 0\n _n_spikes = _numpy.searchsorted(_array_zz_external_sources__timebins[_lastindex_before:],\n _timebin, side='right')\n _array_zz_external_sources__lastindex[0] = _lastindex_before + _n_spikes\n _indices = _array_zz_external_sources_neuron_index[_lastindex_before:_lastindex_before+_n_spikes]\n _array_zz_external_sources__spikespace[:_n_spikes] = _indices\n _array_zz_external_sources__spikespace[-1] = _n_spikes\n", + "name": "zz_external_sources_codeobject_3" + } + ], + "name": "zz_external_sources", + "order": 0, + "type": "SpikeGeneratorGroup", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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_1" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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_22" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "when": "synapses" + }, + { + "abstract_code": "g_post += 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": "zz_external_arrivals_pre_push_spikes" + }, + { + "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_post += w\n _postsynaptic_idx = _array_zz_external_arrivals__synaptic_post[_idx]\n not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_zz_external_arrivals_w[_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": "zz_external_arrivals_pre_codeobject_3" + } + ], + "name": "zz_external_arrivals_pre", + "order": 0, + "type": "SynapticPathway", + "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_22" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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_1" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float32/unwrapped-audit/input-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float32/unwrapped-audit/input-audit.json new file mode 100644 index 0000000..2458270 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float32/unwrapped-audit/input-audit.json @@ -0,0 +1,48 @@ +{ + "all_neurons_keep_original_rfc": true, + "completeness_sha256": "c79ddcee44e7786a8805ed8bd4685d8107764e5dff4952b204e5163f8630ce80", + "connectivity_sha256": "7dbc19bebd51061ac3272c69fe12a7a0a0d179ab21ff6d35193070c64db310f4", + "dt_ms": 0.1, + "parameter_checks": { + "membrane_tau_ms": { + "author": 20.0, + "case": 20.0 + }, + "refractory_ms": { + "author": 2.2, + "case": 2.2 + }, + "reset_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "resting_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "synaptic_delay_ms": { + "author": 1.8, + "case": 1.8 + }, + "synaptic_tau_ms": { + "author": 5.0, + "case": 5.0 + }, + "threshold_mv": { + "author": -45.0, + "case": -45.0 + }, + "w_syn_mv_per_anatomical_synapse": { + "author": 0.275, + "case": 0.275 + } + }, + "poisson_helper_used": false, + "precision": "float32", + "queue_trace_enabled": false, + "request_interface": "before_thresholds; v=v_th+1mV only if not_refractory", + "source_parameters_modified": false, + "source_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "state_units": "SI volts, original dtype", + "steps": 160 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float32/unwrapped-audit/queue-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float32/unwrapped-audit/queue-audit.json new file mode 100644 index 0000000..6d2ed14 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float32/unwrapped-audit/queue-audit.json @@ -0,0 +1,11 @@ +{ + "accepted_due_events": 0, + "advance_calls": 0, + "all_due_events_preserved": null, + "due_events": 0, + "installations": [], + "ordering": "raw anatomical queue.peek local edge-index sequence; no sorting or filtering", + "peek_calls": 0, + "proxy_contract": "peek returns original object; advance and all other methods forward unchanged", + "trace_enabled": false +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float32/unwrapped-audit/schedule.json b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float32/unwrapped-audit/schedule.json new file mode 100644 index 0000000..30bc294 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float32/unwrapped-audit/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_common_requests (NetworkOperation) | -- | 100. us (every step) | before_thresholds | 0 | yes \ndefault_neurons_spike_thresholder (Thresholder) | default_neurons (NeuronGroup) | 100. us (every step) | thresholds | 0 | yes \nzz_external_sources (SpikeGeneratorGroup) | zz_external_sources (SpikeGeneratorGroup) | 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 \nzz_external_arrivals_pre (SynapticPathway) | zz_external_arrivals (Synapses) | 100. us (every step) | synapses | 0 | 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 " +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float64/case.json b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float64/case.json new file mode 100644 index 0000000..2b5bcdb --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float64/case.json @@ -0,0 +1,35 @@ +{ + "author_commit": "91bdd1e7dcf193f3e7ca5a8933497fcef63b7960", + "author_path": "/data/digital-drosophila/experiments/phase4ad-author-semantics/external-resources/model.py", + "author_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "case_arrays_sha256": "aececf2fd48c52804d84852483e467b13d23b7b675c8b7b0d967c02aee960a5f", + "case_spec_sha256": "f63a2d3a4e99220a42944461a3223c459e3a1e7c02d22dc5e30cd129dd9452d1", + "common_interface_preserved": true, + "learning": false, + "original_poi_interface_adopted": false, + "precision": "float64", + "spec": { + "description": "Release at22 with same-tick force/arrival, loops and ring wraps.", + "dt_ms": 0.1, + "duration_ms": 16.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 + }, + "name": "release_selfloop", + "selection": null, + "steps": 160, + "trace_queue": true, + "validate_queue_proxy": true + }, + "trace_queue": true, + "validate_queue_proxy": true, + "whole_brain": false +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float64/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float64/coefficients.json new file mode 100644 index 0000000..ff21840 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float64/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_20", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_20", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_20", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_20", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_20", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_20", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float64/environment.json b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float64/environment.json new file mode 100644 index 0000000..7b43f4f --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float64/environment.json @@ -0,0 +1,14 @@ +{ + "backend": "Brian2 numpy runtime", + "packages": { + "brian2": "2.5.1", + "cython": "0.29.33", + "numpy": "1.22.3", + "pandas": "1.4.3", + "pyarrow": "11.0.0", + "scipy": "1.8.1", + "sympy": "1.12" + }, + "platform": "Linux-5.15.0-194-generic-x86_64-with-glibc2.35", + "python": "3.10.12 (main, Aug 31 2026, 10:18:17) [GCC 11.4.0]" +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float64/instrumented/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float64/instrumented/coefficients.json new file mode 100644 index 0000000..ff21840 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float64/instrumented/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_20", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_20", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_20", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_20", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_20", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_20", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float64/instrumented/compiled-code.json b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float64/instrumented/compiled-code.json new file mode 100644 index 0000000..759f6b7 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float64/instrumented/compiled-code.json @@ -0,0 +1,162 @@ +[ + { + "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" + }, + { + "active": true, + "code_objects": [], + "name": "zz_external_arrivals", + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "when": "thresholds" + }, + { + "abstract_code": "", + "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 _the_period = _array_zz_external_sources__period_bins[0]\n _timebin = _array_defaultclock_timestep[0]\n _n_spikes = 0\n _lastindex_before = _array_zz_external_sources__lastindex[0]\n if _the_period > 0:\n _timebin %= _the_period\n # If there is a periodicity in the SpikeGenerator, we need to reset the\n # lastindex when the period has passed\n if _lastindex_before > 0 and _array_zz_external_sources__timebins[_lastindex_before - 1] >= _timebin:\n _lastindex_before = 0\n _n_spikes = _numpy.searchsorted(_array_zz_external_sources__timebins[_lastindex_before:],\n _timebin, side='right')\n _array_zz_external_sources__lastindex[0] = _lastindex_before + _n_spikes\n _indices = _array_zz_external_sources_neuron_index[_lastindex_before:_lastindex_before+_n_spikes]\n _array_zz_external_sources__spikespace[:_n_spikes] = _indices\n _array_zz_external_sources__spikespace[-1] = _n_spikes\n", + "name": "zz_external_sources_codeobject" + } + ], + "name": "zz_external_sources", + "order": 0, + "type": "SpikeGeneratorGroup", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "when": "synapses" + }, + { + "abstract_code": "g_post += 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": "zz_external_arrivals_pre_push_spikes" + }, + { + "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_post += w\n _postsynaptic_idx = _array_zz_external_arrivals__synaptic_post[_idx]\n not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_zz_external_arrivals_w[_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": "zz_external_arrivals_pre_codeobject" + } + ], + "name": "zz_external_arrivals_pre", + "order": 0, + "type": "SynapticPathway", + "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" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + }, + { + "active": true, + "code_objects": [], + "name": "zz_oracle_queue_installer", + "order": 1000000, + "type": "QueueInstaller", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float64/instrumented/completeness.csv b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float64/instrumented/completeness.csv new file mode 100644 index 0000000..df47ae8 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float64/instrumented/completeness.csv @@ -0,0 +1,5 @@ +global_neuron_idx,local_index +-4,0 +-3,1 +-2,2 +-1,3 diff --git a/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float64/instrumented/generated-code.json b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float64/instrumented/generated-code.json new file mode 100644 index 0000000..ff342ac --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float64/instrumented/generated-code.json @@ -0,0 +1,162 @@ +[ + { + "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" + }, + { + "active": true, + "code_objects": [], + "name": "zz_external_arrivals", + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject_20" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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_20" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "when": "thresholds" + }, + { + "abstract_code": "", + "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 _the_period = _array_zz_external_sources__period_bins[0]\n _timebin = _array_defaultclock_timestep[0]\n _n_spikes = 0\n _lastindex_before = _array_zz_external_sources__lastindex[0]\n if _the_period > 0:\n _timebin %= _the_period\n # If there is a periodicity in the SpikeGenerator, we need to reset the\n # lastindex when the period has passed\n if _lastindex_before > 0 and _array_zz_external_sources__timebins[_lastindex_before - 1] >= _timebin:\n _lastindex_before = 0\n _n_spikes = _numpy.searchsorted(_array_zz_external_sources__timebins[_lastindex_before:],\n _timebin, side='right')\n _array_zz_external_sources__lastindex[0] = _lastindex_before + _n_spikes\n _indices = _array_zz_external_sources_neuron_index[_lastindex_before:_lastindex_before+_n_spikes]\n _array_zz_external_sources__spikespace[:_n_spikes] = _indices\n _array_zz_external_sources__spikespace[-1] = _n_spikes\n", + "name": "zz_external_sources_codeobject_1" + } + ], + "name": "zz_external_sources", + "order": 0, + "type": "SpikeGeneratorGroup", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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_1" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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_20" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "when": "synapses" + }, + { + "abstract_code": "g_post += 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": "zz_external_arrivals_pre_push_spikes" + }, + { + "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_post += w\n _postsynaptic_idx = _array_zz_external_arrivals__synaptic_post[_idx]\n not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_zz_external_arrivals_w[_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": "zz_external_arrivals_pre_codeobject_1" + } + ], + "name": "zz_external_arrivals_pre", + "order": 0, + "type": "SynapticPathway", + "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_20" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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_1" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + }, + { + "active": true, + "code_objects": [], + "name": "zz_oracle_queue_installer", + "order": 1000000, + "type": "QueueInstaller", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float64/instrumented/input-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float64/instrumented/input-audit.json new file mode 100644 index 0000000..ab3eac0 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float64/instrumented/input-audit.json @@ -0,0 +1,48 @@ +{ + "all_neurons_keep_original_rfc": true, + "completeness_sha256": "c79ddcee44e7786a8805ed8bd4685d8107764e5dff4952b204e5163f8630ce80", + "connectivity_sha256": "7dbc19bebd51061ac3272c69fe12a7a0a0d179ab21ff6d35193070c64db310f4", + "dt_ms": 0.1, + "parameter_checks": { + "membrane_tau_ms": { + "author": 20.0, + "case": 20.0 + }, + "refractory_ms": { + "author": 2.2, + "case": 2.2 + }, + "reset_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "resting_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "synaptic_delay_ms": { + "author": 1.8, + "case": 1.8 + }, + "synaptic_tau_ms": { + "author": 5.0, + "case": 5.0 + }, + "threshold_mv": { + "author": -45.0, + "case": -45.0 + }, + "w_syn_mv_per_anatomical_synapse": { + "author": 0.275, + "case": 0.275 + } + }, + "poisson_helper_used": false, + "precision": "float64", + "queue_trace_enabled": true, + "request_interface": "before_thresholds; v=v_th+1mV only if not_refractory", + "source_parameters_modified": false, + "source_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "state_units": "SI volts, original dtype", + "steps": 160 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float64/instrumented/queue-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float64/instrumented/queue-audit.json new file mode 100644 index 0000000..540434a --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float64/instrumented/queue-audit.json @@ -0,0 +1,14 @@ +{ + "accepted_due_events": 4, + "advance_calls": 160, + "all_due_events_preserved": true, + "due_events": 11, + "installations": [ + "default_synapses_pre_codeobject", + "default_synapses_pre_codeobject_20" + ], + "ordering": "raw anatomical queue.peek local edge-index sequence; no sorting or filtering", + "peek_calls": 160, + "proxy_contract": "peek returns original object; advance and all other methods forward unchanged", + "trace_enabled": true +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float64/instrumented/schedule.json b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float64/instrumented/schedule.json new file mode 100644 index 0000000..445ab0c --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float64/instrumented/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_common_requests (NetworkOperation) | -- | 100. us (every step) | before_thresholds | 0 | yes \ndefault_neurons_spike_thresholder (Thresholder) | default_neurons (NeuronGroup) | 100. us (every step) | thresholds | 0 | yes \nzz_external_sources (SpikeGeneratorGroup) | zz_external_sources (SpikeGeneratorGroup) | 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 \nzz_external_arrivals_pre (SynapticPathway) | zz_external_arrivals (Synapses) | 100. us (every step) | synapses | 0 | 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 \nzz_oracle_queue_installer (QueueInstaller) | -- | 100. us (every step) | end | 1000000 | yes " +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float64/proxy-validation.json b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float64/proxy-validation.json new file mode 100644 index 0000000..50c684d --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float64/proxy-validation.json @@ -0,0 +1,33 @@ +{ + "arrival_arrays_excluded": "An unwrapped queue is deliberately not observed", + "exact_arrays": { + "applicable_count": true, + "coefficients": true, + "counts": true, + "external_accepted": true, + "external_step": true, + "external_target": true, + "external_weights": true, + "fired": true, + "g": true, + "history": true, + "initial_g": true, + "initial_v": true, + "local_idx": true, + "neuron_idx": true, + "nodes": true, + "not_refractory": true, + "ref": true, + "ref_history": true, + "rejected_count": true, + "request_accepted": true, + "request_attempted": true, + "request_count": true, + "request_rejected": true, + "step": true, + "v": true, + "weights": true + }, + "pass": true, + "performed": true +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float64/summary.json b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float64/summary.json new file mode 100644 index 0000000..91c788c --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float64/summary.json @@ -0,0 +1,18 @@ +{ + "applicable_requests": 6, + "coefficient_file": "/data/digital-drosophila/experiments/phase4ae-author-runtime/oracle/release_selfloop-float64/coefficients.json", + "complete": true, + "due_arrivals": 11, + "edges": 5, + "name": "release_selfloop", + "nodes": 4, + "precision": "float64", + "queue_proxy_validated": true, + "queue_trace_enabled": true, + "rejected_requests": 0, + "requests": 6, + "source_unchanged": true, + "spikes": 8, + "state_file": "/data/digital-drosophila/experiments/phase4ae-author-runtime/oracle/release_selfloop-float64/state.npz", + "steps": 160 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float64/unwrapped-audit/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float64/unwrapped-audit/coefficients.json new file mode 100644 index 0000000..af67540 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float64/unwrapped-audit/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_21", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_21", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_21", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_21", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_21", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_21", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float64/unwrapped-audit/compiled-code.json b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float64/unwrapped-audit/compiled-code.json new file mode 100644 index 0000000..b323fd4 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float64/unwrapped-audit/compiled-code.json @@ -0,0 +1,154 @@ +[ + { + "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" + }, + { + "active": true, + "code_objects": [], + "name": "zz_external_arrivals", + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "when": "thresholds" + }, + { + "abstract_code": "", + "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 _the_period = _array_zz_external_sources__period_bins[0]\n _timebin = _array_defaultclock_timestep[0]\n _n_spikes = 0\n _lastindex_before = _array_zz_external_sources__lastindex[0]\n if _the_period > 0:\n _timebin %= _the_period\n # If there is a periodicity in the SpikeGenerator, we need to reset the\n # lastindex when the period has passed\n if _lastindex_before > 0 and _array_zz_external_sources__timebins[_lastindex_before - 1] >= _timebin:\n _lastindex_before = 0\n _n_spikes = _numpy.searchsorted(_array_zz_external_sources__timebins[_lastindex_before:],\n _timebin, side='right')\n _array_zz_external_sources__lastindex[0] = _lastindex_before + _n_spikes\n _indices = _array_zz_external_sources_neuron_index[_lastindex_before:_lastindex_before+_n_spikes]\n _array_zz_external_sources__spikespace[:_n_spikes] = _indices\n _array_zz_external_sources__spikespace[-1] = _n_spikes\n", + "name": "zz_external_sources_codeobject" + } + ], + "name": "zz_external_sources", + "order": 0, + "type": "SpikeGeneratorGroup", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "when": "synapses" + }, + { + "abstract_code": "g_post += 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": "zz_external_arrivals_pre_push_spikes" + }, + { + "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_post += w\n _postsynaptic_idx = _array_zz_external_arrivals__synaptic_post[_idx]\n not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_zz_external_arrivals_w[_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": "zz_external_arrivals_pre_codeobject" + } + ], + "name": "zz_external_arrivals_pre", + "order": 0, + "type": "SynapticPathway", + "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" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float64/unwrapped-audit/completeness.csv b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float64/unwrapped-audit/completeness.csv new file mode 100644 index 0000000..df47ae8 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float64/unwrapped-audit/completeness.csv @@ -0,0 +1,5 @@ +global_neuron_idx,local_index +-4,0 +-3,1 +-2,2 +-1,3 diff --git a/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float64/unwrapped-audit/generated-code.json b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float64/unwrapped-audit/generated-code.json new file mode 100644 index 0000000..7014eeb --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float64/unwrapped-audit/generated-code.json @@ -0,0 +1,154 @@ +[ + { + "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" + }, + { + "active": true, + "code_objects": [], + "name": "zz_external_arrivals", + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject_21" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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_21" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "when": "thresholds" + }, + { + "abstract_code": "", + "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 _the_period = _array_zz_external_sources__period_bins[0]\n _timebin = _array_defaultclock_timestep[0]\n _n_spikes = 0\n _lastindex_before = _array_zz_external_sources__lastindex[0]\n if _the_period > 0:\n _timebin %= _the_period\n # If there is a periodicity in the SpikeGenerator, we need to reset the\n # lastindex when the period has passed\n if _lastindex_before > 0 and _array_zz_external_sources__timebins[_lastindex_before - 1] >= _timebin:\n _lastindex_before = 0\n _n_spikes = _numpy.searchsorted(_array_zz_external_sources__timebins[_lastindex_before:],\n _timebin, side='right')\n _array_zz_external_sources__lastindex[0] = _lastindex_before + _n_spikes\n _indices = _array_zz_external_sources_neuron_index[_lastindex_before:_lastindex_before+_n_spikes]\n _array_zz_external_sources__spikespace[:_n_spikes] = _indices\n _array_zz_external_sources__spikespace[-1] = _n_spikes\n", + "name": "zz_external_sources_codeobject_2" + } + ], + "name": "zz_external_sources", + "order": 0, + "type": "SpikeGeneratorGroup", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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_1" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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_21" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "when": "synapses" + }, + { + "abstract_code": "g_post += 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": "zz_external_arrivals_pre_push_spikes" + }, + { + "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_post += w\n _postsynaptic_idx = _array_zz_external_arrivals__synaptic_post[_idx]\n not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_zz_external_arrivals_w[_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": "zz_external_arrivals_pre_codeobject_2" + } + ], + "name": "zz_external_arrivals_pre", + "order": 0, + "type": "SynapticPathway", + "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_21" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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_1" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float64/unwrapped-audit/input-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float64/unwrapped-audit/input-audit.json new file mode 100644 index 0000000..22651b4 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float64/unwrapped-audit/input-audit.json @@ -0,0 +1,48 @@ +{ + "all_neurons_keep_original_rfc": true, + "completeness_sha256": "c79ddcee44e7786a8805ed8bd4685d8107764e5dff4952b204e5163f8630ce80", + "connectivity_sha256": "7dbc19bebd51061ac3272c69fe12a7a0a0d179ab21ff6d35193070c64db310f4", + "dt_ms": 0.1, + "parameter_checks": { + "membrane_tau_ms": { + "author": 20.0, + "case": 20.0 + }, + "refractory_ms": { + "author": 2.2, + "case": 2.2 + }, + "reset_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "resting_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "synaptic_delay_ms": { + "author": 1.8, + "case": 1.8 + }, + "synaptic_tau_ms": { + "author": 5.0, + "case": 5.0 + }, + "threshold_mv": { + "author": -45.0, + "case": -45.0 + }, + "w_syn_mv_per_anatomical_synapse": { + "author": 0.275, + "case": 0.275 + } + }, + "poisson_helper_used": false, + "precision": "float64", + "queue_trace_enabled": false, + "request_interface": "before_thresholds; v=v_th+1mV only if not_refractory", + "source_parameters_modified": false, + "source_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "state_units": "SI volts, original dtype", + "steps": 160 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float64/unwrapped-audit/queue-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float64/unwrapped-audit/queue-audit.json new file mode 100644 index 0000000..6d2ed14 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float64/unwrapped-audit/queue-audit.json @@ -0,0 +1,11 @@ +{ + "accepted_due_events": 0, + "advance_calls": 0, + "all_due_events_preserved": null, + "due_events": 0, + "installations": [], + "ordering": "raw anatomical queue.peek local edge-index sequence; no sorting or filtering", + "peek_calls": 0, + "proxy_contract": "peek returns original object; advance and all other methods forward unchanged", + "trace_enabled": false +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float64/unwrapped-audit/schedule.json b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float64/unwrapped-audit/schedule.json new file mode 100644 index 0000000..30bc294 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/release_selfloop-float64/unwrapped-audit/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_common_requests (NetworkOperation) | -- | 100. us (every step) | before_thresholds | 0 | yes \ndefault_neurons_spike_thresholder (Thresholder) | default_neurons (NeuronGroup) | 100. us (every step) | thresholds | 0 | yes \nzz_external_sources (SpikeGeneratorGroup) | zz_external_sources (SpikeGeneratorGroup) | 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 \nzz_external_arrivals_pre (SynapticPathway) | zz_external_arrivals (Synapses) | 100. us (every step) | synapses | 0 | 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 " +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float32/case.json b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float32/case.json new file mode 100644 index 0000000..b656ce2 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float32/case.json @@ -0,0 +1,35 @@ +{ + "author_commit": "91bdd1e7dcf193f3e7ca5a8933497fcef63b7960", + "author_path": "/data/digital-drosophila/experiments/phase4ad-author-semantics/external-resources/model.py", + "author_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "case_arrays_sha256": "b29ac37913a97f3e3a9a3136b0949e9cbaf3a42ddcd1c7cec1e5b356a5da1ac7", + "case_spec_sha256": "7c6af1bf5fd8f68c84fe000ec6b4977d05f6db17f4b9338d8ad49376036cbf32", + "common_interface_preserved": true, + "learning": false, + "original_poi_interface_adopted": false, + "precision": "float32", + "spec": { + "description": "Fixed seed128-cell signed random fixture; forcing stops at20ms; signs assigned per synthetic source.", + "dt_ms": 0.1, + "duration_ms": 40.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 + }, + "name": "signed_random", + "selection": null, + "steps": 400, + "trace_queue": true, + "validate_queue_proxy": true + }, + "trace_queue": true, + "validate_queue_proxy": true, + "whole_brain": false +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float32/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float32/coefficients.json new file mode 100644 index 0000000..4350ac7 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float32/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_22", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_22", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_22", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_22", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_22", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_22", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float32/environment.json b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float32/environment.json new file mode 100644 index 0000000..7b43f4f --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float32/environment.json @@ -0,0 +1,14 @@ +{ + "backend": "Brian2 numpy runtime", + "packages": { + "brian2": "2.5.1", + "cython": "0.29.33", + "numpy": "1.22.3", + "pandas": "1.4.3", + "pyarrow": "11.0.0", + "scipy": "1.8.1", + "sympy": "1.12" + }, + "platform": "Linux-5.15.0-194-generic-x86_64-with-glibc2.35", + "python": "3.10.12 (main, Aug 31 2026, 10:18:17) [GCC 11.4.0]" +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float32/instrumented/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float32/instrumented/coefficients.json new file mode 100644 index 0000000..4350ac7 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float32/instrumented/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_22", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_22", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_22", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_22", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_22", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_22", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float32/instrumented/compiled-code.json b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float32/instrumented/compiled-code.json new file mode 100644 index 0000000..759f6b7 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float32/instrumented/compiled-code.json @@ -0,0 +1,162 @@ +[ + { + "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" + }, + { + "active": true, + "code_objects": [], + "name": "zz_external_arrivals", + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "when": "thresholds" + }, + { + "abstract_code": "", + "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 _the_period = _array_zz_external_sources__period_bins[0]\n _timebin = _array_defaultclock_timestep[0]\n _n_spikes = 0\n _lastindex_before = _array_zz_external_sources__lastindex[0]\n if _the_period > 0:\n _timebin %= _the_period\n # If there is a periodicity in the SpikeGenerator, we need to reset the\n # lastindex when the period has passed\n if _lastindex_before > 0 and _array_zz_external_sources__timebins[_lastindex_before - 1] >= _timebin:\n _lastindex_before = 0\n _n_spikes = _numpy.searchsorted(_array_zz_external_sources__timebins[_lastindex_before:],\n _timebin, side='right')\n _array_zz_external_sources__lastindex[0] = _lastindex_before + _n_spikes\n _indices = _array_zz_external_sources_neuron_index[_lastindex_before:_lastindex_before+_n_spikes]\n _array_zz_external_sources__spikespace[:_n_spikes] = _indices\n _array_zz_external_sources__spikespace[-1] = _n_spikes\n", + "name": "zz_external_sources_codeobject" + } + ], + "name": "zz_external_sources", + "order": 0, + "type": "SpikeGeneratorGroup", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "when": "synapses" + }, + { + "abstract_code": "g_post += 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": "zz_external_arrivals_pre_push_spikes" + }, + { + "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_post += w\n _postsynaptic_idx = _array_zz_external_arrivals__synaptic_post[_idx]\n not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_zz_external_arrivals_w[_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": "zz_external_arrivals_pre_codeobject" + } + ], + "name": "zz_external_arrivals_pre", + "order": 0, + "type": "SynapticPathway", + "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" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + }, + { + "active": true, + "code_objects": [], + "name": "zz_oracle_queue_installer", + "order": 1000000, + "type": "QueueInstaller", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float32/instrumented/completeness.csv b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float32/instrumented/completeness.csv new file mode 100644 index 0000000..e654d89 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float32/instrumented/completeness.csv @@ -0,0 +1,129 @@ +global_neuron_idx,local_index +-128,0 +-127,1 +-126,2 +-125,3 +-124,4 +-123,5 +-122,6 +-121,7 +-120,8 +-119,9 +-118,10 +-117,11 +-116,12 +-115,13 +-114,14 +-113,15 +-112,16 +-111,17 +-110,18 +-109,19 +-108,20 +-107,21 +-106,22 +-105,23 +-104,24 +-103,25 +-102,26 +-101,27 +-100,28 +-99,29 +-98,30 +-97,31 +-96,32 +-95,33 +-94,34 +-93,35 +-92,36 +-91,37 +-90,38 +-89,39 +-88,40 +-87,41 +-86,42 +-85,43 +-84,44 +-83,45 +-82,46 +-81,47 +-80,48 +-79,49 +-78,50 +-77,51 +-76,52 +-75,53 +-74,54 +-73,55 +-72,56 +-71,57 +-70,58 +-69,59 +-68,60 +-67,61 +-66,62 +-65,63 +-64,64 +-63,65 +-62,66 +-61,67 +-60,68 +-59,69 +-58,70 +-57,71 +-56,72 +-55,73 +-54,74 +-53,75 +-52,76 +-51,77 +-50,78 +-49,79 +-48,80 +-47,81 +-46,82 +-45,83 +-44,84 +-43,85 +-42,86 +-41,87 +-40,88 +-39,89 +-38,90 +-37,91 +-36,92 +-35,93 +-34,94 +-33,95 +-32,96 +-31,97 +-30,98 +-29,99 +-28,100 +-27,101 +-26,102 +-25,103 +-24,104 +-23,105 +-22,106 +-21,107 +-20,108 +-19,109 +-18,110 +-17,111 +-16,112 +-15,113 +-14,114 +-13,115 +-12,116 +-11,117 +-10,118 +-9,119 +-8,120 +-7,121 +-6,122 +-5,123 +-4,124 +-3,125 +-2,126 +-1,127 diff --git a/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float32/instrumented/generated-code.json b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float32/instrumented/generated-code.json new file mode 100644 index 0000000..93981a1 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float32/instrumented/generated-code.json @@ -0,0 +1,162 @@ +[ + { + "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" + }, + { + "active": true, + "code_objects": [], + "name": "zz_external_arrivals", + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject_22" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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_22" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "when": "thresholds" + }, + { + "abstract_code": "", + "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 _the_period = _array_zz_external_sources__period_bins[0]\n _timebin = _array_defaultclock_timestep[0]\n _n_spikes = 0\n _lastindex_before = _array_zz_external_sources__lastindex[0]\n if _the_period > 0:\n _timebin %= _the_period\n # If there is a periodicity in the SpikeGenerator, we need to reset the\n # lastindex when the period has passed\n if _lastindex_before > 0 and _array_zz_external_sources__timebins[_lastindex_before - 1] >= _timebin:\n _lastindex_before = 0\n _n_spikes = _numpy.searchsorted(_array_zz_external_sources__timebins[_lastindex_before:],\n _timebin, side='right')\n _array_zz_external_sources__lastindex[0] = _lastindex_before + _n_spikes\n _indices = _array_zz_external_sources_neuron_index[_lastindex_before:_lastindex_before+_n_spikes]\n _array_zz_external_sources__spikespace[:_n_spikes] = _indices\n _array_zz_external_sources__spikespace[-1] = _n_spikes\n", + "name": "zz_external_sources_codeobject_3" + } + ], + "name": "zz_external_sources", + "order": 0, + "type": "SpikeGeneratorGroup", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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_1" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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_22" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "when": "synapses" + }, + { + "abstract_code": "g_post += 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": "zz_external_arrivals_pre_push_spikes" + }, + { + "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_post += w\n _postsynaptic_idx = _array_zz_external_arrivals__synaptic_post[_idx]\n not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_zz_external_arrivals_w[_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": "zz_external_arrivals_pre_codeobject_3" + } + ], + "name": "zz_external_arrivals_pre", + "order": 0, + "type": "SynapticPathway", + "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_22" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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_1" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + }, + { + "active": true, + "code_objects": [], + "name": "zz_oracle_queue_installer", + "order": 1000000, + "type": "QueueInstaller", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float32/instrumented/input-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float32/instrumented/input-audit.json new file mode 100644 index 0000000..5573503 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float32/instrumented/input-audit.json @@ -0,0 +1,48 @@ +{ + "all_neurons_keep_original_rfc": true, + "completeness_sha256": "847d1cf9168f7309567f41a98b9258003eb1174f46d3b61f19fab79c8a629c4f", + "connectivity_sha256": "8e5386c56312953312d0aaef7f5d816544d859fbe66b0583ddcc2093f33c062d", + "dt_ms": 0.1, + "parameter_checks": { + "membrane_tau_ms": { + "author": 20.0, + "case": 20.0 + }, + "refractory_ms": { + "author": 2.2, + "case": 2.2 + }, + "reset_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "resting_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "synaptic_delay_ms": { + "author": 1.8, + "case": 1.8 + }, + "synaptic_tau_ms": { + "author": 5.0, + "case": 5.0 + }, + "threshold_mv": { + "author": -45.0, + "case": -45.0 + }, + "w_syn_mv_per_anatomical_synapse": { + "author": 0.275, + "case": 0.275 + } + }, + "poisson_helper_used": false, + "precision": "float32", + "queue_trace_enabled": true, + "request_interface": "before_thresholds; v=v_th+1mV only if not_refractory", + "source_parameters_modified": false, + "source_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "state_units": "SI volts, original dtype", + "steps": 400 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float32/instrumented/queue-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float32/instrumented/queue-audit.json new file mode 100644 index 0000000..c1827e5 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float32/instrumented/queue-audit.json @@ -0,0 +1,14 @@ +{ + "accepted_due_events": 2517, + "advance_calls": 400, + "all_due_events_preserved": true, + "due_events": 3072, + "installations": [ + "default_synapses_pre_codeobject", + "default_synapses_pre_codeobject_22" + ], + "ordering": "raw anatomical queue.peek local edge-index sequence; no sorting or filtering", + "peek_calls": 400, + "proxy_contract": "peek returns original object; advance and all other methods forward unchanged", + "trace_enabled": true +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float32/instrumented/schedule.json b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float32/instrumented/schedule.json new file mode 100644 index 0000000..445ab0c --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float32/instrumented/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_common_requests (NetworkOperation) | -- | 100. us (every step) | before_thresholds | 0 | yes \ndefault_neurons_spike_thresholder (Thresholder) | default_neurons (NeuronGroup) | 100. us (every step) | thresholds | 0 | yes \nzz_external_sources (SpikeGeneratorGroup) | zz_external_sources (SpikeGeneratorGroup) | 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 \nzz_external_arrivals_pre (SynapticPathway) | zz_external_arrivals (Synapses) | 100. us (every step) | synapses | 0 | 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 \nzz_oracle_queue_installer (QueueInstaller) | -- | 100. us (every step) | end | 1000000 | yes " +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float32/proxy-validation.json b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float32/proxy-validation.json new file mode 100644 index 0000000..50c684d --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float32/proxy-validation.json @@ -0,0 +1,33 @@ +{ + "arrival_arrays_excluded": "An unwrapped queue is deliberately not observed", + "exact_arrays": { + "applicable_count": true, + "coefficients": true, + "counts": true, + "external_accepted": true, + "external_step": true, + "external_target": true, + "external_weights": true, + "fired": true, + "g": true, + "history": true, + "initial_g": true, + "initial_v": true, + "local_idx": true, + "neuron_idx": true, + "nodes": true, + "not_refractory": true, + "ref": true, + "ref_history": true, + "rejected_count": true, + "request_accepted": true, + "request_attempted": true, + "request_count": true, + "request_rejected": true, + "step": true, + "v": true, + "weights": true + }, + "pass": true, + "performed": true +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float32/summary.json b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float32/summary.json new file mode 100644 index 0000000..b448630 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float32/summary.json @@ -0,0 +1,18 @@ +{ + "applicable_requests": 23, + "coefficient_file": "/data/digital-drosophila/experiments/phase4ae-author-runtime/oracle/signed_random-float32/coefficients.json", + "complete": true, + "due_arrivals": 3072, + "edges": 1024, + "name": "signed_random", + "nodes": 128, + "precision": "float32", + "queue_proxy_validated": true, + "queue_trace_enabled": true, + "rejected_requests": 4, + "requests": 27, + "source_unchanged": true, + "spikes": 400, + "state_file": "/data/digital-drosophila/experiments/phase4ae-author-runtime/oracle/signed_random-float32/state.npz", + "steps": 400 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float32/unwrapped-audit/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float32/unwrapped-audit/coefficients.json new file mode 100644 index 0000000..493550a --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float32/unwrapped-audit/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_24", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_24", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_24", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_24", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_24", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_24", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float32/unwrapped-audit/compiled-code.json b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float32/unwrapped-audit/compiled-code.json new file mode 100644 index 0000000..b323fd4 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float32/unwrapped-audit/compiled-code.json @@ -0,0 +1,154 @@ +[ + { + "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" + }, + { + "active": true, + "code_objects": [], + "name": "zz_external_arrivals", + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "when": "thresholds" + }, + { + "abstract_code": "", + "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 _the_period = _array_zz_external_sources__period_bins[0]\n _timebin = _array_defaultclock_timestep[0]\n _n_spikes = 0\n _lastindex_before = _array_zz_external_sources__lastindex[0]\n if _the_period > 0:\n _timebin %= _the_period\n # If there is a periodicity in the SpikeGenerator, we need to reset the\n # lastindex when the period has passed\n if _lastindex_before > 0 and _array_zz_external_sources__timebins[_lastindex_before - 1] >= _timebin:\n _lastindex_before = 0\n _n_spikes = _numpy.searchsorted(_array_zz_external_sources__timebins[_lastindex_before:],\n _timebin, side='right')\n _array_zz_external_sources__lastindex[0] = _lastindex_before + _n_spikes\n _indices = _array_zz_external_sources_neuron_index[_lastindex_before:_lastindex_before+_n_spikes]\n _array_zz_external_sources__spikespace[:_n_spikes] = _indices\n _array_zz_external_sources__spikespace[-1] = _n_spikes\n", + "name": "zz_external_sources_codeobject" + } + ], + "name": "zz_external_sources", + "order": 0, + "type": "SpikeGeneratorGroup", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "when": "synapses" + }, + { + "abstract_code": "g_post += 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": "zz_external_arrivals_pre_push_spikes" + }, + { + "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_post += w\n _postsynaptic_idx = _array_zz_external_arrivals__synaptic_post[_idx]\n not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_zz_external_arrivals_w[_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": "zz_external_arrivals_pre_codeobject" + } + ], + "name": "zz_external_arrivals_pre", + "order": 0, + "type": "SynapticPathway", + "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" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float32/unwrapped-audit/completeness.csv b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float32/unwrapped-audit/completeness.csv new file mode 100644 index 0000000..e654d89 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float32/unwrapped-audit/completeness.csv @@ -0,0 +1,129 @@ +global_neuron_idx,local_index +-128,0 +-127,1 +-126,2 +-125,3 +-124,4 +-123,5 +-122,6 +-121,7 +-120,8 +-119,9 +-118,10 +-117,11 +-116,12 +-115,13 +-114,14 +-113,15 +-112,16 +-111,17 +-110,18 +-109,19 +-108,20 +-107,21 +-106,22 +-105,23 +-104,24 +-103,25 +-102,26 +-101,27 +-100,28 +-99,29 +-98,30 +-97,31 +-96,32 +-95,33 +-94,34 +-93,35 +-92,36 +-91,37 +-90,38 +-89,39 +-88,40 +-87,41 +-86,42 +-85,43 +-84,44 +-83,45 +-82,46 +-81,47 +-80,48 +-79,49 +-78,50 +-77,51 +-76,52 +-75,53 +-74,54 +-73,55 +-72,56 +-71,57 +-70,58 +-69,59 +-68,60 +-67,61 +-66,62 +-65,63 +-64,64 +-63,65 +-62,66 +-61,67 +-60,68 +-59,69 +-58,70 +-57,71 +-56,72 +-55,73 +-54,74 +-53,75 +-52,76 +-51,77 +-50,78 +-49,79 +-48,80 +-47,81 +-46,82 +-45,83 +-44,84 +-43,85 +-42,86 +-41,87 +-40,88 +-39,89 +-38,90 +-37,91 +-36,92 +-35,93 +-34,94 +-33,95 +-32,96 +-31,97 +-30,98 +-29,99 +-28,100 +-27,101 +-26,102 +-25,103 +-24,104 +-23,105 +-22,106 +-21,107 +-20,108 +-19,109 +-18,110 +-17,111 +-16,112 +-15,113 +-14,114 +-13,115 +-12,116 +-11,117 +-10,118 +-9,119 +-8,120 +-7,121 +-6,122 +-5,123 +-4,124 +-3,125 +-2,126 +-1,127 diff --git a/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float32/unwrapped-audit/generated-code.json b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float32/unwrapped-audit/generated-code.json new file mode 100644 index 0000000..3f7179b --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float32/unwrapped-audit/generated-code.json @@ -0,0 +1,154 @@ +[ + { + "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" + }, + { + "active": true, + "code_objects": [], + "name": "zz_external_arrivals", + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject_24" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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_24" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "when": "thresholds" + }, + { + "abstract_code": "", + "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 _the_period = _array_zz_external_sources__period_bins[0]\n _timebin = _array_defaultclock_timestep[0]\n _n_spikes = 0\n _lastindex_before = _array_zz_external_sources__lastindex[0]\n if _the_period > 0:\n _timebin %= _the_period\n # If there is a periodicity in the SpikeGenerator, we need to reset the\n # lastindex when the period has passed\n if _lastindex_before > 0 and _array_zz_external_sources__timebins[_lastindex_before - 1] >= _timebin:\n _lastindex_before = 0\n _n_spikes = _numpy.searchsorted(_array_zz_external_sources__timebins[_lastindex_before:],\n _timebin, side='right')\n _array_zz_external_sources__lastindex[0] = _lastindex_before + _n_spikes\n _indices = _array_zz_external_sources_neuron_index[_lastindex_before:_lastindex_before+_n_spikes]\n _array_zz_external_sources__spikespace[:_n_spikes] = _indices\n _array_zz_external_sources__spikespace[-1] = _n_spikes\n", + "name": "zz_external_sources_codeobject_4" + } + ], + "name": "zz_external_sources", + "order": 0, + "type": "SpikeGeneratorGroup", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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_1" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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_24" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "when": "synapses" + }, + { + "abstract_code": "g_post += 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": "zz_external_arrivals_pre_push_spikes" + }, + { + "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_post += w\n _postsynaptic_idx = _array_zz_external_arrivals__synaptic_post[_idx]\n not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_zz_external_arrivals_w[_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": "zz_external_arrivals_pre_codeobject_4" + } + ], + "name": "zz_external_arrivals_pre", + "order": 0, + "type": "SynapticPathway", + "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_24" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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_1" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float32/unwrapped-audit/input-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float32/unwrapped-audit/input-audit.json new file mode 100644 index 0000000..05bae9e --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float32/unwrapped-audit/input-audit.json @@ -0,0 +1,48 @@ +{ + "all_neurons_keep_original_rfc": true, + "completeness_sha256": "847d1cf9168f7309567f41a98b9258003eb1174f46d3b61f19fab79c8a629c4f", + "connectivity_sha256": "8e5386c56312953312d0aaef7f5d816544d859fbe66b0583ddcc2093f33c062d", + "dt_ms": 0.1, + "parameter_checks": { + "membrane_tau_ms": { + "author": 20.0, + "case": 20.0 + }, + "refractory_ms": { + "author": 2.2, + "case": 2.2 + }, + "reset_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "resting_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "synaptic_delay_ms": { + "author": 1.8, + "case": 1.8 + }, + "synaptic_tau_ms": { + "author": 5.0, + "case": 5.0 + }, + "threshold_mv": { + "author": -45.0, + "case": -45.0 + }, + "w_syn_mv_per_anatomical_synapse": { + "author": 0.275, + "case": 0.275 + } + }, + "poisson_helper_used": false, + "precision": "float32", + "queue_trace_enabled": false, + "request_interface": "before_thresholds; v=v_th+1mV only if not_refractory", + "source_parameters_modified": false, + "source_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "state_units": "SI volts, original dtype", + "steps": 400 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float32/unwrapped-audit/queue-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float32/unwrapped-audit/queue-audit.json new file mode 100644 index 0000000..6d2ed14 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float32/unwrapped-audit/queue-audit.json @@ -0,0 +1,11 @@ +{ + "accepted_due_events": 0, + "advance_calls": 0, + "all_due_events_preserved": null, + "due_events": 0, + "installations": [], + "ordering": "raw anatomical queue.peek local edge-index sequence; no sorting or filtering", + "peek_calls": 0, + "proxy_contract": "peek returns original object; advance and all other methods forward unchanged", + "trace_enabled": false +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float32/unwrapped-audit/schedule.json b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float32/unwrapped-audit/schedule.json new file mode 100644 index 0000000..30bc294 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float32/unwrapped-audit/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_common_requests (NetworkOperation) | -- | 100. us (every step) | before_thresholds | 0 | yes \ndefault_neurons_spike_thresholder (Thresholder) | default_neurons (NeuronGroup) | 100. us (every step) | thresholds | 0 | yes \nzz_external_sources (SpikeGeneratorGroup) | zz_external_sources (SpikeGeneratorGroup) | 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 \nzz_external_arrivals_pre (SynapticPathway) | zz_external_arrivals (Synapses) | 100. us (every step) | synapses | 0 | 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 " +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float64/case.json b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float64/case.json new file mode 100644 index 0000000..1f3a4d0 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float64/case.json @@ -0,0 +1,35 @@ +{ + "author_commit": "91bdd1e7dcf193f3e7ca5a8933497fcef63b7960", + "author_path": "/data/digital-drosophila/experiments/phase4ad-author-semantics/external-resources/model.py", + "author_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "case_arrays_sha256": "b29ac37913a97f3e3a9a3136b0949e9cbaf3a42ddcd1c7cec1e5b356a5da1ac7", + "case_spec_sha256": "7c6af1bf5fd8f68c84fe000ec6b4977d05f6db17f4b9338d8ad49376036cbf32", + "common_interface_preserved": true, + "learning": false, + "original_poi_interface_adopted": false, + "precision": "float64", + "spec": { + "description": "Fixed seed128-cell signed random fixture; forcing stops at20ms; signs assigned per synthetic source.", + "dt_ms": 0.1, + "duration_ms": 40.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 + }, + "name": "signed_random", + "selection": null, + "steps": 400, + "trace_queue": true, + "validate_queue_proxy": true + }, + "trace_queue": true, + "validate_queue_proxy": true, + "whole_brain": false +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float64/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float64/coefficients.json new file mode 100644 index 0000000..1151f99 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float64/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_23", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_23", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_23", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_23", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_23", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_23", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float64/environment.json b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float64/environment.json new file mode 100644 index 0000000..7b43f4f --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float64/environment.json @@ -0,0 +1,14 @@ +{ + "backend": "Brian2 numpy runtime", + "packages": { + "brian2": "2.5.1", + "cython": "0.29.33", + "numpy": "1.22.3", + "pandas": "1.4.3", + "pyarrow": "11.0.0", + "scipy": "1.8.1", + "sympy": "1.12" + }, + "platform": "Linux-5.15.0-194-generic-x86_64-with-glibc2.35", + "python": "3.10.12 (main, Aug 31 2026, 10:18:17) [GCC 11.4.0]" +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float64/instrumented/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float64/instrumented/coefficients.json new file mode 100644 index 0000000..1151f99 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float64/instrumented/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_23", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_23", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_23", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_23", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_23", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_23", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float64/instrumented/compiled-code.json b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float64/instrumented/compiled-code.json new file mode 100644 index 0000000..759f6b7 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float64/instrumented/compiled-code.json @@ -0,0 +1,162 @@ +[ + { + "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" + }, + { + "active": true, + "code_objects": [], + "name": "zz_external_arrivals", + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "when": "thresholds" + }, + { + "abstract_code": "", + "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 _the_period = _array_zz_external_sources__period_bins[0]\n _timebin = _array_defaultclock_timestep[0]\n _n_spikes = 0\n _lastindex_before = _array_zz_external_sources__lastindex[0]\n if _the_period > 0:\n _timebin %= _the_period\n # If there is a periodicity in the SpikeGenerator, we need to reset the\n # lastindex when the period has passed\n if _lastindex_before > 0 and _array_zz_external_sources__timebins[_lastindex_before - 1] >= _timebin:\n _lastindex_before = 0\n _n_spikes = _numpy.searchsorted(_array_zz_external_sources__timebins[_lastindex_before:],\n _timebin, side='right')\n _array_zz_external_sources__lastindex[0] = _lastindex_before + _n_spikes\n _indices = _array_zz_external_sources_neuron_index[_lastindex_before:_lastindex_before+_n_spikes]\n _array_zz_external_sources__spikespace[:_n_spikes] = _indices\n _array_zz_external_sources__spikespace[-1] = _n_spikes\n", + "name": "zz_external_sources_codeobject" + } + ], + "name": "zz_external_sources", + "order": 0, + "type": "SpikeGeneratorGroup", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "when": "synapses" + }, + { + "abstract_code": "g_post += 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": "zz_external_arrivals_pre_push_spikes" + }, + { + "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_post += w\n _postsynaptic_idx = _array_zz_external_arrivals__synaptic_post[_idx]\n not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_zz_external_arrivals_w[_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": "zz_external_arrivals_pre_codeobject" + } + ], + "name": "zz_external_arrivals_pre", + "order": 0, + "type": "SynapticPathway", + "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" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + }, + { + "active": true, + "code_objects": [], + "name": "zz_oracle_queue_installer", + "order": 1000000, + "type": "QueueInstaller", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float64/instrumented/completeness.csv b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float64/instrumented/completeness.csv new file mode 100644 index 0000000..e654d89 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float64/instrumented/completeness.csv @@ -0,0 +1,129 @@ +global_neuron_idx,local_index +-128,0 +-127,1 +-126,2 +-125,3 +-124,4 +-123,5 +-122,6 +-121,7 +-120,8 +-119,9 +-118,10 +-117,11 +-116,12 +-115,13 +-114,14 +-113,15 +-112,16 +-111,17 +-110,18 +-109,19 +-108,20 +-107,21 +-106,22 +-105,23 +-104,24 +-103,25 +-102,26 +-101,27 +-100,28 +-99,29 +-98,30 +-97,31 +-96,32 +-95,33 +-94,34 +-93,35 +-92,36 +-91,37 +-90,38 +-89,39 +-88,40 +-87,41 +-86,42 +-85,43 +-84,44 +-83,45 +-82,46 +-81,47 +-80,48 +-79,49 +-78,50 +-77,51 +-76,52 +-75,53 +-74,54 +-73,55 +-72,56 +-71,57 +-70,58 +-69,59 +-68,60 +-67,61 +-66,62 +-65,63 +-64,64 +-63,65 +-62,66 +-61,67 +-60,68 +-59,69 +-58,70 +-57,71 +-56,72 +-55,73 +-54,74 +-53,75 +-52,76 +-51,77 +-50,78 +-49,79 +-48,80 +-47,81 +-46,82 +-45,83 +-44,84 +-43,85 +-42,86 +-41,87 +-40,88 +-39,89 +-38,90 +-37,91 +-36,92 +-35,93 +-34,94 +-33,95 +-32,96 +-31,97 +-30,98 +-29,99 +-28,100 +-27,101 +-26,102 +-25,103 +-24,104 +-23,105 +-22,106 +-21,107 +-20,108 +-19,109 +-18,110 +-17,111 +-16,112 +-15,113 +-14,114 +-13,115 +-12,116 +-11,117 +-10,118 +-9,119 +-8,120 +-7,121 +-6,122 +-5,123 +-4,124 +-3,125 +-2,126 +-1,127 diff --git a/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float64/instrumented/generated-code.json b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float64/instrumented/generated-code.json new file mode 100644 index 0000000..80ee966 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float64/instrumented/generated-code.json @@ -0,0 +1,162 @@ +[ + { + "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" + }, + { + "active": true, + "code_objects": [], + "name": "zz_external_arrivals", + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject_23" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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_23" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "when": "thresholds" + }, + { + "abstract_code": "", + "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 _the_period = _array_zz_external_sources__period_bins[0]\n _timebin = _array_defaultclock_timestep[0]\n _n_spikes = 0\n _lastindex_before = _array_zz_external_sources__lastindex[0]\n if _the_period > 0:\n _timebin %= _the_period\n # If there is a periodicity in the SpikeGenerator, we need to reset the\n # lastindex when the period has passed\n if _lastindex_before > 0 and _array_zz_external_sources__timebins[_lastindex_before - 1] >= _timebin:\n _lastindex_before = 0\n _n_spikes = _numpy.searchsorted(_array_zz_external_sources__timebins[_lastindex_before:],\n _timebin, side='right')\n _array_zz_external_sources__lastindex[0] = _lastindex_before + _n_spikes\n _indices = _array_zz_external_sources_neuron_index[_lastindex_before:_lastindex_before+_n_spikes]\n _array_zz_external_sources__spikespace[:_n_spikes] = _indices\n _array_zz_external_sources__spikespace[-1] = _n_spikes\n", + "name": "zz_external_sources_codeobject_4" + } + ], + "name": "zz_external_sources", + "order": 0, + "type": "SpikeGeneratorGroup", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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_1" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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_23" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "when": "synapses" + }, + { + "abstract_code": "g_post += 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": "zz_external_arrivals_pre_push_spikes" + }, + { + "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_post += w\n _postsynaptic_idx = _array_zz_external_arrivals__synaptic_post[_idx]\n not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_zz_external_arrivals_w[_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": "zz_external_arrivals_pre_codeobject_4" + } + ], + "name": "zz_external_arrivals_pre", + "order": 0, + "type": "SynapticPathway", + "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_23" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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_1" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + }, + { + "active": true, + "code_objects": [], + "name": "zz_oracle_queue_installer", + "order": 1000000, + "type": "QueueInstaller", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float64/instrumented/input-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float64/instrumented/input-audit.json new file mode 100644 index 0000000..bb2c519 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float64/instrumented/input-audit.json @@ -0,0 +1,48 @@ +{ + "all_neurons_keep_original_rfc": true, + "completeness_sha256": "847d1cf9168f7309567f41a98b9258003eb1174f46d3b61f19fab79c8a629c4f", + "connectivity_sha256": "8e5386c56312953312d0aaef7f5d816544d859fbe66b0583ddcc2093f33c062d", + "dt_ms": 0.1, + "parameter_checks": { + "membrane_tau_ms": { + "author": 20.0, + "case": 20.0 + }, + "refractory_ms": { + "author": 2.2, + "case": 2.2 + }, + "reset_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "resting_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "synaptic_delay_ms": { + "author": 1.8, + "case": 1.8 + }, + "synaptic_tau_ms": { + "author": 5.0, + "case": 5.0 + }, + "threshold_mv": { + "author": -45.0, + "case": -45.0 + }, + "w_syn_mv_per_anatomical_synapse": { + "author": 0.275, + "case": 0.275 + } + }, + "poisson_helper_used": false, + "precision": "float64", + "queue_trace_enabled": true, + "request_interface": "before_thresholds; v=v_th+1mV only if not_refractory", + "source_parameters_modified": false, + "source_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "state_units": "SI volts, original dtype", + "steps": 400 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float64/instrumented/queue-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float64/instrumented/queue-audit.json new file mode 100644 index 0000000..b2facf9 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float64/instrumented/queue-audit.json @@ -0,0 +1,14 @@ +{ + "accepted_due_events": 2517, + "advance_calls": 400, + "all_due_events_preserved": true, + "due_events": 3072, + "installations": [ + "default_synapses_pre_codeobject", + "default_synapses_pre_codeobject_23" + ], + "ordering": "raw anatomical queue.peek local edge-index sequence; no sorting or filtering", + "peek_calls": 400, + "proxy_contract": "peek returns original object; advance and all other methods forward unchanged", + "trace_enabled": true +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float64/instrumented/schedule.json b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float64/instrumented/schedule.json new file mode 100644 index 0000000..445ab0c --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float64/instrumented/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_common_requests (NetworkOperation) | -- | 100. us (every step) | before_thresholds | 0 | yes \ndefault_neurons_spike_thresholder (Thresholder) | default_neurons (NeuronGroup) | 100. us (every step) | thresholds | 0 | yes \nzz_external_sources (SpikeGeneratorGroup) | zz_external_sources (SpikeGeneratorGroup) | 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 \nzz_external_arrivals_pre (SynapticPathway) | zz_external_arrivals (Synapses) | 100. us (every step) | synapses | 0 | 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 \nzz_oracle_queue_installer (QueueInstaller) | -- | 100. us (every step) | end | 1000000 | yes " +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float64/proxy-validation.json b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float64/proxy-validation.json new file mode 100644 index 0000000..50c684d --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float64/proxy-validation.json @@ -0,0 +1,33 @@ +{ + "arrival_arrays_excluded": "An unwrapped queue is deliberately not observed", + "exact_arrays": { + "applicable_count": true, + "coefficients": true, + "counts": true, + "external_accepted": true, + "external_step": true, + "external_target": true, + "external_weights": true, + "fired": true, + "g": true, + "history": true, + "initial_g": true, + "initial_v": true, + "local_idx": true, + "neuron_idx": true, + "nodes": true, + "not_refractory": true, + "ref": true, + "ref_history": true, + "rejected_count": true, + "request_accepted": true, + "request_attempted": true, + "request_count": true, + "request_rejected": true, + "step": true, + "v": true, + "weights": true + }, + "pass": true, + "performed": true +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float64/summary.json b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float64/summary.json new file mode 100644 index 0000000..fe683eb --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float64/summary.json @@ -0,0 +1,18 @@ +{ + "applicable_requests": 23, + "coefficient_file": "/data/digital-drosophila/experiments/phase4ae-author-runtime/oracle/signed_random-float64/coefficients.json", + "complete": true, + "due_arrivals": 3072, + "edges": 1024, + "name": "signed_random", + "nodes": 128, + "precision": "float64", + "queue_proxy_validated": true, + "queue_trace_enabled": true, + "rejected_requests": 4, + "requests": 27, + "source_unchanged": true, + "spikes": 400, + "state_file": "/data/digital-drosophila/experiments/phase4ae-author-runtime/oracle/signed_random-float64/state.npz", + "steps": 400 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float64/unwrapped-audit/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float64/unwrapped-audit/coefficients.json new file mode 100644 index 0000000..493550a --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float64/unwrapped-audit/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_24", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_24", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_24", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_24", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_24", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_24", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float64/unwrapped-audit/compiled-code.json b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float64/unwrapped-audit/compiled-code.json new file mode 100644 index 0000000..b323fd4 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float64/unwrapped-audit/compiled-code.json @@ -0,0 +1,154 @@ +[ + { + "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" + }, + { + "active": true, + "code_objects": [], + "name": "zz_external_arrivals", + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "when": "thresholds" + }, + { + "abstract_code": "", + "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 _the_period = _array_zz_external_sources__period_bins[0]\n _timebin = _array_defaultclock_timestep[0]\n _n_spikes = 0\n _lastindex_before = _array_zz_external_sources__lastindex[0]\n if _the_period > 0:\n _timebin %= _the_period\n # If there is a periodicity in the SpikeGenerator, we need to reset the\n # lastindex when the period has passed\n if _lastindex_before > 0 and _array_zz_external_sources__timebins[_lastindex_before - 1] >= _timebin:\n _lastindex_before = 0\n _n_spikes = _numpy.searchsorted(_array_zz_external_sources__timebins[_lastindex_before:],\n _timebin, side='right')\n _array_zz_external_sources__lastindex[0] = _lastindex_before + _n_spikes\n _indices = _array_zz_external_sources_neuron_index[_lastindex_before:_lastindex_before+_n_spikes]\n _array_zz_external_sources__spikespace[:_n_spikes] = _indices\n _array_zz_external_sources__spikespace[-1] = _n_spikes\n", + "name": "zz_external_sources_codeobject" + } + ], + "name": "zz_external_sources", + "order": 0, + "type": "SpikeGeneratorGroup", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "when": "synapses" + }, + { + "abstract_code": "g_post += 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": "zz_external_arrivals_pre_push_spikes" + }, + { + "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_post += w\n _postsynaptic_idx = _array_zz_external_arrivals__synaptic_post[_idx]\n not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_zz_external_arrivals_w[_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": "zz_external_arrivals_pre_codeobject" + } + ], + "name": "zz_external_arrivals_pre", + "order": 0, + "type": "SynapticPathway", + "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" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float64/unwrapped-audit/completeness.csv b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float64/unwrapped-audit/completeness.csv new file mode 100644 index 0000000..e654d89 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float64/unwrapped-audit/completeness.csv @@ -0,0 +1,129 @@ +global_neuron_idx,local_index +-128,0 +-127,1 +-126,2 +-125,3 +-124,4 +-123,5 +-122,6 +-121,7 +-120,8 +-119,9 +-118,10 +-117,11 +-116,12 +-115,13 +-114,14 +-113,15 +-112,16 +-111,17 +-110,18 +-109,19 +-108,20 +-107,21 +-106,22 +-105,23 +-104,24 +-103,25 +-102,26 +-101,27 +-100,28 +-99,29 +-98,30 +-97,31 +-96,32 +-95,33 +-94,34 +-93,35 +-92,36 +-91,37 +-90,38 +-89,39 +-88,40 +-87,41 +-86,42 +-85,43 +-84,44 +-83,45 +-82,46 +-81,47 +-80,48 +-79,49 +-78,50 +-77,51 +-76,52 +-75,53 +-74,54 +-73,55 +-72,56 +-71,57 +-70,58 +-69,59 +-68,60 +-67,61 +-66,62 +-65,63 +-64,64 +-63,65 +-62,66 +-61,67 +-60,68 +-59,69 +-58,70 +-57,71 +-56,72 +-55,73 +-54,74 +-53,75 +-52,76 +-51,77 +-50,78 +-49,79 +-48,80 +-47,81 +-46,82 +-45,83 +-44,84 +-43,85 +-42,86 +-41,87 +-40,88 +-39,89 +-38,90 +-37,91 +-36,92 +-35,93 +-34,94 +-33,95 +-32,96 +-31,97 +-30,98 +-29,99 +-28,100 +-27,101 +-26,102 +-25,103 +-24,104 +-23,105 +-22,106 +-21,107 +-20,108 +-19,109 +-18,110 +-17,111 +-16,112 +-15,113 +-14,114 +-13,115 +-12,116 +-11,117 +-10,118 +-9,119 +-8,120 +-7,121 +-6,122 +-5,123 +-4,124 +-3,125 +-2,126 +-1,127 diff --git a/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float64/unwrapped-audit/generated-code.json b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float64/unwrapped-audit/generated-code.json new file mode 100644 index 0000000..646ada3 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float64/unwrapped-audit/generated-code.json @@ -0,0 +1,154 @@ +[ + { + "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" + }, + { + "active": true, + "code_objects": [], + "name": "zz_external_arrivals", + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject_24" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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_24" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "when": "thresholds" + }, + { + "abstract_code": "", + "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 _the_period = _array_zz_external_sources__period_bins[0]\n _timebin = _array_defaultclock_timestep[0]\n _n_spikes = 0\n _lastindex_before = _array_zz_external_sources__lastindex[0]\n if _the_period > 0:\n _timebin %= _the_period\n # If there is a periodicity in the SpikeGenerator, we need to reset the\n # lastindex when the period has passed\n if _lastindex_before > 0 and _array_zz_external_sources__timebins[_lastindex_before - 1] >= _timebin:\n _lastindex_before = 0\n _n_spikes = _numpy.searchsorted(_array_zz_external_sources__timebins[_lastindex_before:],\n _timebin, side='right')\n _array_zz_external_sources__lastindex[0] = _lastindex_before + _n_spikes\n _indices = _array_zz_external_sources_neuron_index[_lastindex_before:_lastindex_before+_n_spikes]\n _array_zz_external_sources__spikespace[:_n_spikes] = _indices\n _array_zz_external_sources__spikespace[-1] = _n_spikes\n", + "name": "zz_external_sources_codeobject_5" + } + ], + "name": "zz_external_sources", + "order": 0, + "type": "SpikeGeneratorGroup", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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_1" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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_24" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "when": "synapses" + }, + { + "abstract_code": "g_post += 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": "zz_external_arrivals_pre_push_spikes" + }, + { + "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_post += w\n _postsynaptic_idx = _array_zz_external_arrivals__synaptic_post[_idx]\n not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_zz_external_arrivals_w[_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": "zz_external_arrivals_pre_codeobject_5" + } + ], + "name": "zz_external_arrivals_pre", + "order": 0, + "type": "SynapticPathway", + "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_24" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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_1" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float64/unwrapped-audit/input-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float64/unwrapped-audit/input-audit.json new file mode 100644 index 0000000..c496ee7 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float64/unwrapped-audit/input-audit.json @@ -0,0 +1,48 @@ +{ + "all_neurons_keep_original_rfc": true, + "completeness_sha256": "847d1cf9168f7309567f41a98b9258003eb1174f46d3b61f19fab79c8a629c4f", + "connectivity_sha256": "8e5386c56312953312d0aaef7f5d816544d859fbe66b0583ddcc2093f33c062d", + "dt_ms": 0.1, + "parameter_checks": { + "membrane_tau_ms": { + "author": 20.0, + "case": 20.0 + }, + "refractory_ms": { + "author": 2.2, + "case": 2.2 + }, + "reset_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "resting_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "synaptic_delay_ms": { + "author": 1.8, + "case": 1.8 + }, + "synaptic_tau_ms": { + "author": 5.0, + "case": 5.0 + }, + "threshold_mv": { + "author": -45.0, + "case": -45.0 + }, + "w_syn_mv_per_anatomical_synapse": { + "author": 0.275, + "case": 0.275 + } + }, + "poisson_helper_used": false, + "precision": "float64", + "queue_trace_enabled": false, + "request_interface": "before_thresholds; v=v_th+1mV only if not_refractory", + "source_parameters_modified": false, + "source_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "state_units": "SI volts, original dtype", + "steps": 400 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float64/unwrapped-audit/queue-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float64/unwrapped-audit/queue-audit.json new file mode 100644 index 0000000..6d2ed14 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float64/unwrapped-audit/queue-audit.json @@ -0,0 +1,11 @@ +{ + "accepted_due_events": 0, + "advance_calls": 0, + "all_due_events_preserved": null, + "due_events": 0, + "installations": [], + "ordering": "raw anatomical queue.peek local edge-index sequence; no sorting or filtering", + "peek_calls": 0, + "proxy_contract": "peek returns original object; advance and all other methods forward unchanged", + "trace_enabled": false +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float64/unwrapped-audit/schedule.json b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float64/unwrapped-audit/schedule.json new file mode 100644 index 0000000..30bc294 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/signed_random-float64/unwrapped-audit/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_common_requests (NetworkOperation) | -- | 100. us (every step) | before_thresholds | 0 | yes \ndefault_neurons_spike_thresholder (Thresholder) | default_neurons (NeuronGroup) | 100. us (every step) | thresholds | 0 | yes \nzz_external_sources (SpikeGeneratorGroup) | zz_external_sources (SpikeGeneratorGroup) | 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 \nzz_external_arrivals_pre (SynapticPathway) | zz_external_arrivals (Synapses) | 100. us (every step) | synapses | 0 | 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 " +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float32/case.json b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float32/case.json new file mode 100644 index 0000000..b5da262 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float32/case.json @@ -0,0 +1,35 @@ +{ + "author_commit": "91bdd1e7dcf193f3e7ca5a8933497fcef63b7960", + "author_path": "/data/digital-drosophila/experiments/phase4ad-author-semantics/external-resources/model.py", + "author_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "case_arrays_sha256": "4acb2f79684a0ffd1c9666da608f8b0ad4f5c150ba5b0d6a2d08e2778a20a298", + "case_spec_sha256": "8a000b9052226e0d4db020cc1dbfc839ac2aa98f01cb9361de2209dbe8706495", + "common_interface_preserved": true, + "learning": false, + "original_poi_interface_adopted": false, + "precision": "float32", + "spec": { + "description": "Preintegration voltages bracket strict-threshold landing in both precisions; inert zero fixture edge.", + "dt_ms": 0.1, + "duration_ms": 10.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 + }, + "name": "threshold_rounding", + "selection": null, + "steps": 100, + "trace_queue": true, + "validate_queue_proxy": true + }, + "trace_queue": true, + "validate_queue_proxy": true, + "whole_brain": false +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float32/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float32/coefficients.json new file mode 100644 index 0000000..d07ca16 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float32/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_25", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_25", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_25", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_25", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_25", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_25", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float32/environment.json b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float32/environment.json new file mode 100644 index 0000000..7b43f4f --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float32/environment.json @@ -0,0 +1,14 @@ +{ + "backend": "Brian2 numpy runtime", + "packages": { + "brian2": "2.5.1", + "cython": "0.29.33", + "numpy": "1.22.3", + "pandas": "1.4.3", + "pyarrow": "11.0.0", + "scipy": "1.8.1", + "sympy": "1.12" + }, + "platform": "Linux-5.15.0-194-generic-x86_64-with-glibc2.35", + "python": "3.10.12 (main, Aug 31 2026, 10:18:17) [GCC 11.4.0]" +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float32/instrumented/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float32/instrumented/coefficients.json new file mode 100644 index 0000000..d07ca16 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float32/instrumented/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_25", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_25", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_25", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_25", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_25", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_25", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float32/instrumented/compiled-code.json b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float32/instrumented/compiled-code.json new file mode 100644 index 0000000..3b9afa3 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float32/instrumented/compiled-code.json @@ -0,0 +1,122 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + }, + { + "active": true, + "code_objects": [], + "name": "zz_oracle_queue_installer", + "order": 1000000, + "type": "QueueInstaller", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float32/instrumented/completeness.csv b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float32/instrumented/completeness.csv new file mode 100644 index 0000000..7a9725f --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float32/instrumented/completeness.csv @@ -0,0 +1,11 @@ +global_neuron_idx,local_index +-10,0 +-9,1 +-8,2 +-7,3 +-6,4 +-5,5 +-4,6 +-3,7 +-2,8 +-1,9 diff --git a/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float32/instrumented/generated-code.json b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float32/instrumented/generated-code.json new file mode 100644 index 0000000..13d686d --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float32/instrumented/generated-code.json @@ -0,0 +1,122 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject_25" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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_25" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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_1" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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_25" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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_25" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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_1" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + }, + { + "active": true, + "code_objects": [], + "name": "zz_oracle_queue_installer", + "order": 1000000, + "type": "QueueInstaller", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float32/instrumented/input-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float32/instrumented/input-audit.json new file mode 100644 index 0000000..854b7f8 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float32/instrumented/input-audit.json @@ -0,0 +1,48 @@ +{ + "all_neurons_keep_original_rfc": true, + "completeness_sha256": "c391cd11c54130ce647d85f3b175256f1bfc2d5b50601ede4231cb7038cea401", + "connectivity_sha256": "abf150cbffed88d715f9282ad1f63a27652af8cef3e672bfbdaaa1f072a27355", + "dt_ms": 0.1, + "parameter_checks": { + "membrane_tau_ms": { + "author": 20.0, + "case": 20.0 + }, + "refractory_ms": { + "author": 2.2, + "case": 2.2 + }, + "reset_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "resting_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "synaptic_delay_ms": { + "author": 1.8, + "case": 1.8 + }, + "synaptic_tau_ms": { + "author": 5.0, + "case": 5.0 + }, + "threshold_mv": { + "author": -45.0, + "case": -45.0 + }, + "w_syn_mv_per_anatomical_synapse": { + "author": 0.275, + "case": 0.275 + } + }, + "poisson_helper_used": false, + "precision": "float32", + "queue_trace_enabled": true, + "request_interface": "before_thresholds; v=v_th+1mV only if not_refractory", + "source_parameters_modified": false, + "source_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "state_units": "SI volts, original dtype", + "steps": 100 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float32/instrumented/queue-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float32/instrumented/queue-audit.json new file mode 100644 index 0000000..fe5089a --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float32/instrumented/queue-audit.json @@ -0,0 +1,14 @@ +{ + "accepted_due_events": 0, + "advance_calls": 100, + "all_due_events_preserved": true, + "due_events": 0, + "installations": [ + "default_synapses_pre_codeobject", + "default_synapses_pre_codeobject_25" + ], + "ordering": "raw anatomical queue.peek local edge-index sequence; no sorting or filtering", + "peek_calls": 100, + "proxy_contract": "peek returns original object; advance and all other methods forward unchanged", + "trace_enabled": true +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float32/instrumented/schedule.json b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float32/instrumented/schedule.json new file mode 100644 index 0000000..93e03d3 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float32/instrumented/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_common_requests (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 \nzz_oracle_queue_installer (QueueInstaller) | -- | 100. us (every step) | end | 1000000 | yes " +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float32/proxy-validation.json b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float32/proxy-validation.json new file mode 100644 index 0000000..50c684d --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float32/proxy-validation.json @@ -0,0 +1,33 @@ +{ + "arrival_arrays_excluded": "An unwrapped queue is deliberately not observed", + "exact_arrays": { + "applicable_count": true, + "coefficients": true, + "counts": true, + "external_accepted": true, + "external_step": true, + "external_target": true, + "external_weights": true, + "fired": true, + "g": true, + "history": true, + "initial_g": true, + "initial_v": true, + "local_idx": true, + "neuron_idx": true, + "nodes": true, + "not_refractory": true, + "ref": true, + "ref_history": true, + "rejected_count": true, + "request_accepted": true, + "request_attempted": true, + "request_count": true, + "request_rejected": true, + "step": true, + "v": true, + "weights": true + }, + "pass": true, + "performed": true +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float32/summary.json b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float32/summary.json new file mode 100644 index 0000000..d26f1c8 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float32/summary.json @@ -0,0 +1,18 @@ +{ + "applicable_requests": 0, + "coefficient_file": "/data/digital-drosophila/experiments/phase4ae-author-runtime/oracle/threshold_rounding-float32/coefficients.json", + "complete": true, + "due_arrivals": 0, + "edges": 1, + "name": "threshold_rounding", + "nodes": 10, + "precision": "float32", + "queue_proxy_validated": true, + "queue_trace_enabled": true, + "rejected_requests": 0, + "requests": 0, + "source_unchanged": true, + "spikes": 3, + "state_file": "/data/digital-drosophila/experiments/phase4ae-author-runtime/oracle/threshold_rounding-float32/state.npz", + "steps": 100 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float32/unwrapped-audit/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float32/unwrapped-audit/coefficients.json new file mode 100644 index 0000000..b38b578 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float32/unwrapped-audit/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_26", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_26", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_26", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_26", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_26", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_26", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float32/unwrapped-audit/compiled-code.json b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float32/unwrapped-audit/compiled-code.json new file mode 100644 index 0000000..9a4ea64 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float32/unwrapped-audit/compiled-code.json @@ -0,0 +1,114 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float32/unwrapped-audit/completeness.csv b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float32/unwrapped-audit/completeness.csv new file mode 100644 index 0000000..7a9725f --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float32/unwrapped-audit/completeness.csv @@ -0,0 +1,11 @@ +global_neuron_idx,local_index +-10,0 +-9,1 +-8,2 +-7,3 +-6,4 +-5,5 +-4,6 +-3,7 +-2,8 +-1,9 diff --git a/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float32/unwrapped-audit/generated-code.json b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float32/unwrapped-audit/generated-code.json new file mode 100644 index 0000000..e1a68c7 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float32/unwrapped-audit/generated-code.json @@ -0,0 +1,114 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject_26" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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_26" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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_1" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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_26" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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_26" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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_1" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float32/unwrapped-audit/input-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float32/unwrapped-audit/input-audit.json new file mode 100644 index 0000000..d0f0be7 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float32/unwrapped-audit/input-audit.json @@ -0,0 +1,48 @@ +{ + "all_neurons_keep_original_rfc": true, + "completeness_sha256": "c391cd11c54130ce647d85f3b175256f1bfc2d5b50601ede4231cb7038cea401", + "connectivity_sha256": "abf150cbffed88d715f9282ad1f63a27652af8cef3e672bfbdaaa1f072a27355", + "dt_ms": 0.1, + "parameter_checks": { + "membrane_tau_ms": { + "author": 20.0, + "case": 20.0 + }, + "refractory_ms": { + "author": 2.2, + "case": 2.2 + }, + "reset_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "resting_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "synaptic_delay_ms": { + "author": 1.8, + "case": 1.8 + }, + "synaptic_tau_ms": { + "author": 5.0, + "case": 5.0 + }, + "threshold_mv": { + "author": -45.0, + "case": -45.0 + }, + "w_syn_mv_per_anatomical_synapse": { + "author": 0.275, + "case": 0.275 + } + }, + "poisson_helper_used": false, + "precision": "float32", + "queue_trace_enabled": false, + "request_interface": "before_thresholds; v=v_th+1mV only if not_refractory", + "source_parameters_modified": false, + "source_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "state_units": "SI volts, original dtype", + "steps": 100 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float32/unwrapped-audit/queue-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float32/unwrapped-audit/queue-audit.json new file mode 100644 index 0000000..6d2ed14 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float32/unwrapped-audit/queue-audit.json @@ -0,0 +1,11 @@ +{ + "accepted_due_events": 0, + "advance_calls": 0, + "all_due_events_preserved": null, + "due_events": 0, + "installations": [], + "ordering": "raw anatomical queue.peek local edge-index sequence; no sorting or filtering", + "peek_calls": 0, + "proxy_contract": "peek returns original object; advance and all other methods forward unchanged", + "trace_enabled": false +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float32/unwrapped-audit/schedule.json b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float32/unwrapped-audit/schedule.json new file mode 100644 index 0000000..4202f07 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float32/unwrapped-audit/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_common_requests (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 " +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float64/case.json b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float64/case.json new file mode 100644 index 0000000..3038724 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float64/case.json @@ -0,0 +1,35 @@ +{ + "author_commit": "91bdd1e7dcf193f3e7ca5a8933497fcef63b7960", + "author_path": "/data/digital-drosophila/experiments/phase4ad-author-semantics/external-resources/model.py", + "author_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "case_arrays_sha256": "4acb2f79684a0ffd1c9666da608f8b0ad4f5c150ba5b0d6a2d08e2778a20a298", + "case_spec_sha256": "8a000b9052226e0d4db020cc1dbfc839ac2aa98f01cb9361de2209dbe8706495", + "common_interface_preserved": true, + "learning": false, + "original_poi_interface_adopted": false, + "precision": "float64", + "spec": { + "description": "Preintegration voltages bracket strict-threshold landing in both precisions; inert zero fixture edge.", + "dt_ms": 0.1, + "duration_ms": 10.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 + }, + "name": "threshold_rounding", + "selection": null, + "steps": 100, + "trace_queue": true, + "validate_queue_proxy": true + }, + "trace_queue": true, + "validate_queue_proxy": true, + "whole_brain": false +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float64/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float64/coefficients.json new file mode 100644 index 0000000..493550a --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float64/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_24", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_24", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_24", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_24", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_24", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_24", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float64/environment.json b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float64/environment.json new file mode 100644 index 0000000..7b43f4f --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float64/environment.json @@ -0,0 +1,14 @@ +{ + "backend": "Brian2 numpy runtime", + "packages": { + "brian2": "2.5.1", + "cython": "0.29.33", + "numpy": "1.22.3", + "pandas": "1.4.3", + "pyarrow": "11.0.0", + "scipy": "1.8.1", + "sympy": "1.12" + }, + "platform": "Linux-5.15.0-194-generic-x86_64-with-glibc2.35", + "python": "3.10.12 (main, Aug 31 2026, 10:18:17) [GCC 11.4.0]" +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float64/instrumented/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float64/instrumented/coefficients.json new file mode 100644 index 0000000..493550a --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float64/instrumented/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_24", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_24", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_24", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_24", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_24", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_24", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float64/instrumented/compiled-code.json b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float64/instrumented/compiled-code.json new file mode 100644 index 0000000..3b9afa3 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float64/instrumented/compiled-code.json @@ -0,0 +1,122 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + }, + { + "active": true, + "code_objects": [], + "name": "zz_oracle_queue_installer", + "order": 1000000, + "type": "QueueInstaller", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float64/instrumented/completeness.csv b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float64/instrumented/completeness.csv new file mode 100644 index 0000000..7a9725f --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float64/instrumented/completeness.csv @@ -0,0 +1,11 @@ +global_neuron_idx,local_index +-10,0 +-9,1 +-8,2 +-7,3 +-6,4 +-5,5 +-4,6 +-3,7 +-2,8 +-1,9 diff --git a/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float64/instrumented/generated-code.json b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float64/instrumented/generated-code.json new file mode 100644 index 0000000..93cad87 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float64/instrumented/generated-code.json @@ -0,0 +1,122 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject_24" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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_24" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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_1" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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_24" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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_24" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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_1" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + }, + { + "active": true, + "code_objects": [], + "name": "zz_oracle_queue_installer", + "order": 1000000, + "type": "QueueInstaller", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float64/instrumented/input-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float64/instrumented/input-audit.json new file mode 100644 index 0000000..006e474 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float64/instrumented/input-audit.json @@ -0,0 +1,48 @@ +{ + "all_neurons_keep_original_rfc": true, + "completeness_sha256": "c391cd11c54130ce647d85f3b175256f1bfc2d5b50601ede4231cb7038cea401", + "connectivity_sha256": "abf150cbffed88d715f9282ad1f63a27652af8cef3e672bfbdaaa1f072a27355", + "dt_ms": 0.1, + "parameter_checks": { + "membrane_tau_ms": { + "author": 20.0, + "case": 20.0 + }, + "refractory_ms": { + "author": 2.2, + "case": 2.2 + }, + "reset_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "resting_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "synaptic_delay_ms": { + "author": 1.8, + "case": 1.8 + }, + "synaptic_tau_ms": { + "author": 5.0, + "case": 5.0 + }, + "threshold_mv": { + "author": -45.0, + "case": -45.0 + }, + "w_syn_mv_per_anatomical_synapse": { + "author": 0.275, + "case": 0.275 + } + }, + "poisson_helper_used": false, + "precision": "float64", + "queue_trace_enabled": true, + "request_interface": "before_thresholds; v=v_th+1mV only if not_refractory", + "source_parameters_modified": false, + "source_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "state_units": "SI volts, original dtype", + "steps": 100 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float64/instrumented/queue-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float64/instrumented/queue-audit.json new file mode 100644 index 0000000..8d9e0b9 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float64/instrumented/queue-audit.json @@ -0,0 +1,14 @@ +{ + "accepted_due_events": 0, + "advance_calls": 100, + "all_due_events_preserved": true, + "due_events": 0, + "installations": [ + "default_synapses_pre_codeobject", + "default_synapses_pre_codeobject_24" + ], + "ordering": "raw anatomical queue.peek local edge-index sequence; no sorting or filtering", + "peek_calls": 100, + "proxy_contract": "peek returns original object; advance and all other methods forward unchanged", + "trace_enabled": true +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float64/instrumented/schedule.json b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float64/instrumented/schedule.json new file mode 100644 index 0000000..93e03d3 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float64/instrumented/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_common_requests (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 \nzz_oracle_queue_installer (QueueInstaller) | -- | 100. us (every step) | end | 1000000 | yes " +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float64/proxy-validation.json b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float64/proxy-validation.json new file mode 100644 index 0000000..50c684d --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float64/proxy-validation.json @@ -0,0 +1,33 @@ +{ + "arrival_arrays_excluded": "An unwrapped queue is deliberately not observed", + "exact_arrays": { + "applicable_count": true, + "coefficients": true, + "counts": true, + "external_accepted": true, + "external_step": true, + "external_target": true, + "external_weights": true, + "fired": true, + "g": true, + "history": true, + "initial_g": true, + "initial_v": true, + "local_idx": true, + "neuron_idx": true, + "nodes": true, + "not_refractory": true, + "ref": true, + "ref_history": true, + "rejected_count": true, + "request_accepted": true, + "request_attempted": true, + "request_count": true, + "request_rejected": true, + "step": true, + "v": true, + "weights": true + }, + "pass": true, + "performed": true +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float64/summary.json b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float64/summary.json new file mode 100644 index 0000000..ae3c94b --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float64/summary.json @@ -0,0 +1,18 @@ +{ + "applicable_requests": 0, + "coefficient_file": "/data/digital-drosophila/experiments/phase4ae-author-runtime/oracle/threshold_rounding-float64/coefficients.json", + "complete": true, + "due_arrivals": 0, + "edges": 1, + "name": "threshold_rounding", + "nodes": 10, + "precision": "float64", + "queue_proxy_validated": true, + "queue_trace_enabled": true, + "rejected_requests": 0, + "requests": 0, + "source_unchanged": true, + "spikes": 4, + "state_file": "/data/digital-drosophila/experiments/phase4ae-author-runtime/oracle/threshold_rounding-float64/state.npz", + "steps": 100 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float64/unwrapped-audit/coefficients.json b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float64/unwrapped-audit/coefficients.json new file mode 100644 index 0000000..d07ca16 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float64/unwrapped-audit/coefficients.json @@ -0,0 +1,72 @@ +{ + "c0": -0.00025935108198051754, + "cg": 0.004937935295309027, + "cv": 0.9950124791926823, + "gd": 0.9801986733067553, + "metadata": { + "constant_values_are_double": true, + "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.", + "g_expression": "gd * old_g", + "hex": { + "c0": "-0x1.0ff306a505980p-12", + "cg": "0x1.439cce9a65d5bp-8", + "cv": "0x1.fd7246927d28bp-1", + "gd": "0x1.f5dc99badec5bp-1", + "reset": "-0x1.a9fbe76c8b43ap-5", + "seed_volt": "-0x1.6872b020c49bap-5", + "threshold": "-0x1.70a3d70a3d70ap-5" + }, + "names": { + "c0": "_lio_8", + "cg": "_lio_9", + "cv": "_lio_10", + "gd": "_lio_2" + }, + "provenance": { + "c0": { + "code_object": "default_neurons_stateupdater_codeobject_25", + "name": "_lio_8", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cg": { + "code_object": "default_neurons_stateupdater_codeobject_25", + "name": "_lio_9", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "cv": { + "code_object": "default_neurons_stateupdater_codeobject_25", + "name": "_lio_10", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "gd": { + "code_object": "default_neurons_stateupdater_codeobject_25", + "name": "_lio_2", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "reset": { + "code_object": "default_neurons_spike_resetter_codeobject_25", + "name": "v_rst", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + }, + "seed_volt": { + "source": "common request interface: unchanged v_th + 1 mV" + }, + "threshold": { + "code_object": "default_neurons_spike_thresholder_codeobject_25", + "name": "v_th", + "namespace_dtype": "float64", + "source": "CodeObject.namespace" + } + }, + "units": "SI volts and dimensionless coefficients", + "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))" + }, + "reset": -0.052000000000000005, + "seed_volt": -0.044, + "threshold": -0.045 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float64/unwrapped-audit/compiled-code.json b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float64/unwrapped-audit/compiled-code.json new file mode 100644 index 0000000..9a4ea64 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float64/unwrapped-audit/compiled-code.json @@ -0,0 +1,114 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float64/unwrapped-audit/completeness.csv b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float64/unwrapped-audit/completeness.csv new file mode 100644 index 0000000..7a9725f --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float64/unwrapped-audit/completeness.csv @@ -0,0 +1,11 @@ +global_neuron_idx,local_index +-10,0 +-9,1 +-8,2 +-7,3 +-6,4 +-5,5 +-4,6 +-3,7 +-2,8 +-1,9 diff --git a/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float64/unwrapped-audit/generated-code.json b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float64/unwrapped-audit/generated-code.json new file mode 100644 index 0000000..5b8d843 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float64/unwrapped-audit/generated-code.json @@ -0,0 +1,114 @@ +[ + { + "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 lastspike = _array_default_neurons_lastspike\n rfc = _array_default_neurons_rfc\n v = _array_default_neurons_v.copy()\n t = _array_defaultclock_t[0]\n not_refractory = _array_default_neurons_not_refractory.copy()\n dt = _array_defaultclock_dt[0]\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_not_refractory[:] = not_refractory\n _array_default_neurons_v[:] = v\n", + "name": "default_neurons_stateupdater_codeobject_25" + } + ], + "name": "default_neurons_stateupdater", + "order": 0, + "type": "StateUpdater", + "when": "groups" + }, + { + "active": true, + "code_objects": [], + "name": "oracle_common_requests", + "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 not_refractory = _array_default_neurons_not_refractory\n v = _array_default_neurons_v\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_25" + } + ], + "name": "default_neurons_spike_thresholder", + "order": 0, + "type": "Thresholder", + "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_t = _array_defaultclock_t[0]\n _source_i = _array_default_neurons_i[_idx]\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_1" + } + ], + "name": "spikemonitor", + "order": 1, + "type": "SpikeMonitor", + "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" + }, + { + "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 not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n w = _array_default_synapses_w[_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_25" + } + ], + "name": "default_synapses_pre", + "order": -1, + "type": "SynapticPathway", + "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_25" + } + ], + "name": "default_neurons_spike_resetter", + "order": 0, + "type": "Resetter", + "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_g = _array_default_neurons_g[_idx]\n _source_not_refractory = _array_default_neurons_not_refractory[_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_1" + } + ], + "name": "oracle_end_state", + "order": 0, + "type": "StateMonitor", + "when": "end" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float64/unwrapped-audit/input-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float64/unwrapped-audit/input-audit.json new file mode 100644 index 0000000..a876741 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float64/unwrapped-audit/input-audit.json @@ -0,0 +1,48 @@ +{ + "all_neurons_keep_original_rfc": true, + "completeness_sha256": "c391cd11c54130ce647d85f3b175256f1bfc2d5b50601ede4231cb7038cea401", + "connectivity_sha256": "abf150cbffed88d715f9282ad1f63a27652af8cef3e672bfbdaaa1f072a27355", + "dt_ms": 0.1, + "parameter_checks": { + "membrane_tau_ms": { + "author": 20.0, + "case": 20.0 + }, + "refractory_ms": { + "author": 2.2, + "case": 2.2 + }, + "reset_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "resting_potential_mv": { + "author": -52.0, + "case": -52.0 + }, + "synaptic_delay_ms": { + "author": 1.8, + "case": 1.8 + }, + "synaptic_tau_ms": { + "author": 5.0, + "case": 5.0 + }, + "threshold_mv": { + "author": -45.0, + "case": -45.0 + }, + "w_syn_mv_per_anatomical_synapse": { + "author": 0.275, + "case": 0.275 + } + }, + "poisson_helper_used": false, + "precision": "float64", + "queue_trace_enabled": false, + "request_interface": "before_thresholds; v=v_th+1mV only if not_refractory", + "source_parameters_modified": false, + "source_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e", + "state_units": "SI volts, original dtype", + "steps": 100 +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float64/unwrapped-audit/queue-audit.json b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float64/unwrapped-audit/queue-audit.json new file mode 100644 index 0000000..6d2ed14 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float64/unwrapped-audit/queue-audit.json @@ -0,0 +1,11 @@ +{ + "accepted_due_events": 0, + "advance_calls": 0, + "all_due_events_preserved": null, + "due_events": 0, + "installations": [], + "ordering": "raw anatomical queue.peek local edge-index sequence; no sorting or filtering", + "peek_calls": 0, + "proxy_contract": "peek returns original object; advance and all other methods forward unchanged", + "trace_enabled": false +} diff --git a/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float64/unwrapped-audit/schedule.json b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float64/unwrapped-audit/schedule.json new file mode 100644 index 0000000..4202f07 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/oracle/threshold_rounding-float64/unwrapped-audit/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_common_requests (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 " +} diff --git a/registry/phase4ae-author-runtime/evidence/protocol/case-hashes.json b/registry/phase4ae-author-runtime/evidence/protocol/case-hashes.json new file mode 100644 index 0000000..5695dd3 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/protocol/case-hashes.json @@ -0,0 +1,114 @@ +[ + { + "path": "cases/fanin_bursts/arrays.npz", + "sha256": "f3a900e9032754619549005131283cbaf87fdaa9093887a90a295589dac590fb" + }, + { + "path": "cases/fanin_bursts/spec.json", + "sha256": "90850d6968a7832e415d0966b57e216a65f5ba8f63e488e497148b6525806d79" + }, + { + "path": "cases/highest_indegree/anatomical-edges.csv", + "sha256": "aec331ee87f0da905d55b4dbb61a7e72fae734246ae6fbf462d7f6348dcdae1b" + }, + { + "path": "cases/highest_indegree/arrays.npz", + "sha256": "02ab938969b4369b1e08bc4a82e8c5fe68683f7318baf5eb052098d63fab0302" + }, + { + "path": "cases/highest_indegree/identities.csv", + "sha256": "5a837548ac8d45d495765d012f4495f4f68b2c9b0eda3eabd759869fc793fe77" + }, + { + "path": "cases/highest_indegree/spec.json", + "sha256": "eab2c18f120fd3e9f067f489cee0a4c07477607facf3094083d3e3fa60bfd1ef" + }, + { + "path": "cases/mixed_high_indegree/anatomical-edges.csv", + "sha256": "4bb7f2b5344916035a87bffec9b26570ef21842010fcf78ff1a71230496c4757" + }, + { + "path": "cases/mixed_high_indegree/arrays.npz", + "sha256": "63fb734a967aee5f77709788ad9bd7d8783c2209c34f0e1d9aa6a0a8b7a6ecf5" + }, + { + "path": "cases/mixed_high_indegree/identities.csv", + "sha256": "ad8f92fab6e2c38ed2b369b7f03c5b75d3c26433ad43bde6e2fc76f8058dd009" + }, + { + "path": "cases/mixed_high_indegree/spec.json", + "sha256": "11f07dd0a3e62b6ee66373022539a68daad766dce26fa759654f0201599f6703" + }, + { + "path": "cases/motif_feedforward/arrays.npz", + "sha256": "cdba32792924258112a2fd6ffaca5e329c71404840a290a9187e5d3e2b6550d4" + }, + { + "path": "cases/motif_feedforward/spec.json", + "sha256": "1bb9ef28864e46336581d23fc15eaf80a329ee4d1a439abd0fc18c52f87a2b77" + }, + { + "path": "cases/motif_five/arrays.npz", + "sha256": "712a18275609cc71875e4ea04ca97222de917de9b1d6760f4052e2a3f0dd465e" + }, + { + "path": "cases/motif_five/spec.json", + "sha256": "f78ba9423ed1dfb686cd79a0a003cda0bf9e7603d37e8d318118e08766ece7b3" + }, + { + "path": "cases/motif_no_input/arrays.npz", + "sha256": "3e3f7c2bd477e097761d3e34745f88fb215636c74d89a9e77a2b9a5f2fc738c3" + }, + { + "path": "cases/motif_no_input/spec.json", + "sha256": "02adfcd0717aa2d98eb571107136eae7186166ce1c7d7eb87df23bedb452fbd9" + }, + { + "path": "cases/motif_pair/arrays.npz", + "sha256": "7c01e762480777b22474264f28cc413e554314602fad320a33b53dd028a1fb5a" + }, + { + "path": "cases/motif_pair/spec.json", + "sha256": "faee4cdcdc93293b4b5e15d852a6a97b76767ce6aa7c534b12c6f204264daa7a" + }, + { + "path": "cases/motif_trio/arrays.npz", + "sha256": "a40e803b1227d4bb6b2c24d76bdf1454cb63ace61ebb9e77ff01010dd91cab37" + }, + { + "path": "cases/motif_trio/spec.json", + "sha256": "da4b6cea0b8a33ca15e552425b55ce699d74ddf81660b02eeb30d5edcc4494cd" + }, + { + "path": "cases/ordered_cancellation/arrays.npz", + "sha256": "97e033aaacc5703bca141b03a1db1d33522a3bf8c7ae182bafd15cafcb4c1e23" + }, + { + "path": "cases/ordered_cancellation/spec.json", + "sha256": "1866003021cc39ad50858fe0d9f56d74e8dd16bd574eef15c0625b604cd987b2" + }, + { + "path": "cases/release_selfloop/arrays.npz", + "sha256": "aececf2fd48c52804d84852483e467b13d23b7b675c8b7b0d967c02aee960a5f" + }, + { + "path": "cases/release_selfloop/spec.json", + "sha256": "f63a2d3a4e99220a42944461a3223c459e3a1e7c02d22dc5e30cd129dd9452d1" + }, + { + "path": "cases/signed_random/arrays.npz", + "sha256": "b29ac37913a97f3e3a9a3136b0949e9cbaf3a42ddcd1c7cec1e5b356a5da1ac7" + }, + { + "path": "cases/signed_random/spec.json", + "sha256": "7c6af1bf5fd8f68c84fe000ec6b4977d05f6db17f4b9338d8ad49376036cbf32" + }, + { + "path": "cases/threshold_rounding/arrays.npz", + "sha256": "4acb2f79684a0ffd1c9666da608f8b0ad4f5c150ba5b0d6a2d08e2778a20a298" + }, + { + "path": "cases/threshold_rounding/spec.json", + "sha256": "8a000b9052226e0d4db020cc1dbfc839ac2aa98f01cb9361de2209dbe8706495" + } +] diff --git a/registry/phase4ae-author-runtime/evidence/protocol/preregistered.json b/registry/phase4ae-author-runtime/evidence/protocol/preregistered.json new file mode 100644 index 0000000..61178c4 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/protocol/preregistered.json @@ -0,0 +1,88 @@ +{ + "timestamp_utc": "2026-09-29T23:35:57.381321+00:00", + "config": { + "phase": "4AE", + "name": "author-runtime-lab-v1", + "human_authorization": "允许独立新模型分支测试动力学假设", + "seed": 410301, + "gpu_uuid": "GPU-79f3a85d-adce-7833-7003-6488140ca596", + "precisions": [ + "float64", + "float32" + ], + "gpu_repeats": 3, + "max_abs_volt": { + "float64": 1e-11, + "float32": 1e-06 + }, + "exact_events_required": true, + "exact_refractory_required": true, + "exact_arrival_order_per_tick_target_required": true, + "training": false, + "whole_brain_author_backend_claimed": false, + "candidate_generation": false, + "synthetic_cases": [ + "ordered_cancellation", + "fanin_bursts", + "release_selfloop", + "threshold_rounding", + "signed_random" + ], + "real_cases": [ + "highest_indegree", + "mixed_high_indegree" + ], + "prior_motifs": [ + "pair", + "trio", + "five", + "feedforward", + "no_input" + ] + }, + "sources": { + "PROTOCOL.md": "72601f46dde3202d62e71161958f620a3ce5b8f9c24cf1f5b7158289b5f9a3f0", + "author_ext.cpp": "208a937d17bbb041b9bf6b25b89264ee566830b60609e58491b44583d8541f15", + "author_ext.cu": "669f166e18ce9a3f63fc723db8b0a8b74f7fa4757194b1bd65b4cf6008a7787e", + "config.json": "356b6161576f6f6d79745af1927bb43b12a7c3d50922bf9e1bd29e473fcf2106", + "context.py": "9eea9a592241cab7f4303850e969def7887eee3f4ec18421103605cafd258cf8", + "finalize.py": "cb75d512ddf9a5ff344f3ac82eefb112406593bf7b414dfac79d7c5d730371ee", + "gpu_backend.py": "03758d07572f4b44d272059d9308fac534268ad201b57bdd77d69fee95e67278", + "oracle_stress.py": "32eb1c42383068ce52701d2139a376ce155ad7072cde019949f8ca2d55492409", + "prepare.py": "2519eaa2c50b2d91fd0c4f623aeabd6f5d212c5b537951d0a66bc81c569db78c", + "run_suite.py": "92733a48921f95c3c0935bf16a704634b89b6540352f31cc1169ec6d3211b57a", + "verify_frozen.py": "720d04b379b6f1f64cae28a2203444a6d4c4e72ecb121cc69e93c2740fae69ab" + }, + "inputs": [ + { + "path": "datasets/male-cns-v1.0/processed/neuron-only/gpu/csr-indptr.int64.npy", + "sha256": "fe43420f11e6242a11f8199ae7f097cab4b8a6db181d36f2a46b9e46670acbb4" + }, + { + "path": "datasets/male-cns-v1.0/processed/neuron-only/gpu/csr-indices.int32.npy", + "sha256": "ce20f7433f78442c717ad2a7b5394cf4a3b109d990b4be0788040b7b0f4ed150" + }, + { + "path": "datasets/male-cns-v1.0/processed/neuron-only/gpu/csr-weights.int64.npy", + "sha256": "c7ae101451dd19c47fd976bcfacbc52d67193a68ffa04c5b4d2e911cfd52d99b" + }, + { + "path": "datasets/male-cns-v1.0/processed/neuron-only/neuron-index/unified-metadata.parquet", + "sha256": "922af16846a065c3dbfca7c11146b83ca217fcbd7392edc745f444a04eae8c63" + }, + { + "path": "models/male-cns-lif/runtime-v1/phase4c.yaml", + "sha256": "0734ffb3a99231b40db2052dea0f2d21efd5dad8d11d17d4731b952811ba5071" + }, + { + "path": "experiments/phase4ad-author-semantics/external-resources/model.py", + "sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e" + }, + { + "path": "experiments/phase4ad-author-semantics/manifest.json", + "sha256": "c939d3977a1883e86108c1e3edd25619118cec61e5c7712ae4dfa2893a73c0ca" + } + ], + "before_model_execution": true, + "parent_commit": "92241aea027cdd0df1c771b56007279a1b04c273" +} diff --git a/registry/phase4ae-author-runtime/evidence/regression/frozen-five.json b/registry/phase4ae-author-runtime/evidence/regression/frozen-five.json new file mode 100644 index 0000000..44d4bf7 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/regression/frozen-five.json @@ -0,0 +1,63 @@ +{ + "pass_all": true, + "trials": [ + { + "trial": "auditory-10hz", + "exact": { + "step": true, + "neuron_idx": true, + "counts": true, + "v": true, + "g": true + }, + "wall_seconds": 2.7077458479998313 + }, + { + "trial": "auditory-100hz", + "exact": { + "step": true, + "neuron_idx": true, + "counts": true, + "v": true, + "g": true + }, + "wall_seconds": 4.969465333000244 + }, + { + "trial": "olfactory-50hz", + "exact": { + "step": true, + "neuron_idx": true, + "counts": true, + "v": true, + "g": true + }, + "wall_seconds": 5.004304638999656 + }, + { + "trial": "mechanosensory-50hz", + "exact": { + "step": true, + "neuron_idx": true, + "counts": true, + "v": true, + "g": true + }, + "wall_seconds": 4.998432711000078 + }, + { + "trial": "gustatory-50hz", + "exact": { + "step": true, + "neuron_idx": true, + "counts": true, + "v": true, + "g": true + }, + "wall_seconds": 4.962681748999785 + } + ], + "wall_seconds": 82.26836688600042, + "peak_allocated_vram": 285994496, + "oracle": "old frozen deterministic-v2 only" +} diff --git a/registry/phase4ae-author-runtime/evidence/regression/gpu-complete.json b/registry/phase4ae-author-runtime/evidence/regression/gpu-complete.json new file mode 100644 index 0000000..00c4003 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/regression/gpu-complete.json @@ -0,0 +1,3680 @@ +{ + "pass_all": true, + "trials": [ + { + "case": "fanin_bursts", + "precision": "float64", + "repeat": 0, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 1539, + "gpu_events": 1539, + "due_edges": 1545, + "accepted_edges": 1285, + "attempted_requests": 2049, + "accepted_requests": 1537 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "fanin_bursts", + "precision": "float64", + "repeat": 1, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 1539, + "gpu_events": 1539, + "due_edges": 1545, + "accepted_edges": 1285, + "attempted_requests": 2049, + "accepted_requests": 1537 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "fanin_bursts", + "precision": "float64", + "repeat": 2, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 1539, + "gpu_events": 1539, + "due_edges": 1545, + "accepted_edges": 1285, + "attempted_requests": 2049, + "accepted_requests": 1537 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "fanin_bursts", + "precision": "float32", + "repeat": 0, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 1539, + "gpu_events": 1539, + "due_edges": 1545, + "accepted_edges": 1285, + "attempted_requests": 2049, + "accepted_requests": 1537 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "fanin_bursts", + "precision": "float32", + "repeat": 1, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 1539, + "gpu_events": 1539, + "due_edges": 1545, + "accepted_edges": 1285, + "attempted_requests": 2049, + "accepted_requests": 1537 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "fanin_bursts", + "precision": "float32", + "repeat": 2, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 1539, + "gpu_events": 1539, + "due_edges": 1545, + "accepted_edges": 1285, + "attempted_requests": 2049, + "accepted_requests": 1537 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "highest_indegree", + "precision": "float64", + "repeat": 0, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 101, + "gpu_events": 101, + "due_edges": 930, + "accepted_edges": 839, + "attempted_requests": 96, + "accepted_requests": 96 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "highest_indegree", + "precision": "float64", + "repeat": 1, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 101, + "gpu_events": 101, + "due_edges": 930, + "accepted_edges": 839, + "attempted_requests": 96, + "accepted_requests": 96 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "highest_indegree", + "precision": "float64", + "repeat": 2, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 101, + "gpu_events": 101, + "due_edges": 930, + "accepted_edges": 839, + "attempted_requests": 96, + "accepted_requests": 96 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "highest_indegree", + "precision": "float32", + "repeat": 0, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 101, + "gpu_events": 101, + "due_edges": 930, + "accepted_edges": 839, + "attempted_requests": 96, + "accepted_requests": 96 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "highest_indegree", + "precision": "float32", + "repeat": 1, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 101, + "gpu_events": 101, + "due_edges": 930, + "accepted_edges": 839, + "attempted_requests": 96, + "accepted_requests": 96 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "highest_indegree", + "precision": "float32", + "repeat": 2, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 101, + "gpu_events": 101, + "due_edges": 930, + "accepted_edges": 839, + "attempted_requests": 96, + "accepted_requests": 96 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "mixed_high_indegree", + "precision": "float64", + "repeat": 0, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 106, + "gpu_events": 106, + "due_edges": 626, + "accepted_edges": 556, + "attempted_requests": 96, + "accepted_requests": 96 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "mixed_high_indegree", + "precision": "float64", + "repeat": 1, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 106, + "gpu_events": 106, + "due_edges": 626, + "accepted_edges": 556, + "attempted_requests": 96, + "accepted_requests": 96 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "mixed_high_indegree", + "precision": "float64", + "repeat": 2, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 106, + "gpu_events": 106, + "due_edges": 626, + "accepted_edges": 556, + "attempted_requests": 96, + "accepted_requests": 96 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "mixed_high_indegree", + "precision": "float32", + "repeat": 0, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 106, + "gpu_events": 106, + "due_edges": 626, + "accepted_edges": 556, + "attempted_requests": 96, + "accepted_requests": 96 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "mixed_high_indegree", + "precision": "float32", + "repeat": 1, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 106, + "gpu_events": 106, + "due_edges": 626, + "accepted_edges": 556, + "attempted_requests": 96, + "accepted_requests": 96 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "mixed_high_indegree", + "precision": "float32", + "repeat": 2, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 106, + "gpu_events": 106, + "due_edges": 626, + "accepted_edges": 556, + "attempted_requests": 96, + "accepted_requests": 96 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "motif_feedforward", + "precision": "float64", + "repeat": 0, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 3, + "gpu_events": 3, + "due_edges": 3, + "accepted_edges": 3, + "attempted_requests": 1, + "accepted_requests": 1 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "motif_feedforward", + "precision": "float64", + "repeat": 1, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 3, + "gpu_events": 3, + "due_edges": 3, + "accepted_edges": 3, + "attempted_requests": 1, + "accepted_requests": 1 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "motif_feedforward", + "precision": "float64", + "repeat": 2, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 3, + "gpu_events": 3, + "due_edges": 3, + "accepted_edges": 3, + "attempted_requests": 1, + "accepted_requests": 1 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "motif_feedforward", + "precision": "float32", + "repeat": 0, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 3, + "gpu_events": 3, + "due_edges": 3, + "accepted_edges": 3, + "attempted_requests": 1, + "accepted_requests": 1 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "motif_feedforward", + "precision": "float32", + "repeat": 1, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 3, + "gpu_events": 3, + "due_edges": 3, + "accepted_edges": 3, + "attempted_requests": 1, + "accepted_requests": 1 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "motif_feedforward", + "precision": "float32", + "repeat": 2, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 3, + "gpu_events": 3, + "due_edges": 3, + "accepted_edges": 3, + "attempted_requests": 1, + "accepted_requests": 1 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "motif_five", + "precision": "float64", + "repeat": 0, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 60, + "gpu_events": 60, + "due_edges": 185, + "accepted_edges": 155, + "attempted_requests": 1, + "accepted_requests": 1 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "motif_five", + "precision": "float64", + "repeat": 1, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 60, + "gpu_events": 60, + "due_edges": 185, + "accepted_edges": 155, + "attempted_requests": 1, + "accepted_requests": 1 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "motif_five", + "precision": "float64", + "repeat": 2, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 60, + "gpu_events": 60, + "due_edges": 185, + "accepted_edges": 155, + "attempted_requests": 1, + "accepted_requests": 1 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "motif_five", + "precision": "float32", + "repeat": 0, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 60, + "gpu_events": 60, + "due_edges": 185, + "accepted_edges": 155, + "attempted_requests": 1, + "accepted_requests": 1 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "motif_five", + "precision": "float32", + "repeat": 1, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 60, + "gpu_events": 60, + "due_edges": 185, + "accepted_edges": 155, + "attempted_requests": 1, + "accepted_requests": 1 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "motif_five", + "precision": "float32", + "repeat": 2, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 60, + "gpu_events": 60, + "due_edges": 185, + "accepted_edges": 155, + "attempted_requests": 1, + "accepted_requests": 1 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "motif_no_input", + "precision": "float64", + "repeat": 0, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 0, + "gpu_events": 0, + "due_edges": 0, + "accepted_edges": 0, + "attempted_requests": 0, + "accepted_requests": 0 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "motif_no_input", + "precision": "float64", + "repeat": 1, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 0, + "gpu_events": 0, + "due_edges": 0, + "accepted_edges": 0, + "attempted_requests": 0, + "accepted_requests": 0 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "motif_no_input", + "precision": "float64", + "repeat": 2, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 0, + "gpu_events": 0, + "due_edges": 0, + "accepted_edges": 0, + "attempted_requests": 0, + "accepted_requests": 0 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "motif_no_input", + "precision": "float32", + "repeat": 0, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 0, + "gpu_events": 0, + "due_edges": 0, + "accepted_edges": 0, + "attempted_requests": 0, + "accepted_requests": 0 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "motif_no_input", + "precision": "float32", + "repeat": 1, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 0, + "gpu_events": 0, + "due_edges": 0, + "accepted_edges": 0, + "attempted_requests": 0, + "accepted_requests": 0 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "motif_no_input", + "precision": "float32", + "repeat": 2, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 0, + "gpu_events": 0, + "due_edges": 0, + "accepted_edges": 0, + "attempted_requests": 0, + "accepted_requests": 0 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "motif_pair", + "precision": "float64", + "repeat": 0, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 22, + "gpu_events": 22, + "due_edges": 21, + "accepted_edges": 21, + "attempted_requests": 1, + "accepted_requests": 1 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "motif_pair", + "precision": "float64", + "repeat": 1, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 22, + "gpu_events": 22, + "due_edges": 21, + "accepted_edges": 21, + "attempted_requests": 1, + "accepted_requests": 1 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "motif_pair", + "precision": "float64", + "repeat": 2, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 22, + "gpu_events": 22, + "due_edges": 21, + "accepted_edges": 21, + "attempted_requests": 1, + "accepted_requests": 1 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "motif_pair", + "precision": "float32", + "repeat": 0, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 22, + "gpu_events": 22, + "due_edges": 21, + "accepted_edges": 21, + "attempted_requests": 1, + "accepted_requests": 1 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "motif_pair", + "precision": "float32", + "repeat": 1, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 22, + "gpu_events": 22, + "due_edges": 21, + "accepted_edges": 21, + "attempted_requests": 1, + "accepted_requests": 1 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "motif_pair", + "precision": "float32", + "repeat": 2, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 22, + "gpu_events": 22, + "due_edges": 21, + "accepted_edges": 21, + "attempted_requests": 1, + "accepted_requests": 1 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "motif_trio", + "precision": "float64", + "repeat": 0, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 45, + "gpu_events": 45, + "due_edges": 88, + "accepted_edges": 87, + "attempted_requests": 1, + "accepted_requests": 1 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "motif_trio", + "precision": "float64", + "repeat": 1, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 45, + "gpu_events": 45, + "due_edges": 88, + "accepted_edges": 87, + "attempted_requests": 1, + "accepted_requests": 1 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "motif_trio", + "precision": "float64", + "repeat": 2, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 45, + "gpu_events": 45, + "due_edges": 88, + "accepted_edges": 87, + "attempted_requests": 1, + "accepted_requests": 1 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "motif_trio", + "precision": "float32", + "repeat": 0, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 45, + "gpu_events": 45, + "due_edges": 88, + "accepted_edges": 87, + "attempted_requests": 1, + "accepted_requests": 1 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "motif_trio", + "precision": "float32", + "repeat": 1, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 45, + "gpu_events": 45, + "due_edges": 88, + "accepted_edges": 87, + "attempted_requests": 1, + "accepted_requests": 1 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "motif_trio", + "precision": "float32", + "repeat": 2, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 45, + "gpu_events": 45, + "due_edges": 88, + "accepted_edges": 87, + "attempted_requests": 1, + "accepted_requests": 1 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "ordered_cancellation", + "precision": "float64", + "repeat": 0, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 32, + "gpu_events": 32, + "due_edges": 32, + "accepted_edges": 32, + "attempted_requests": 32, + "accepted_requests": 32 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "ordered_cancellation", + "precision": "float64", + "repeat": 1, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 32, + "gpu_events": 32, + "due_edges": 32, + "accepted_edges": 32, + "attempted_requests": 32, + "accepted_requests": 32 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "ordered_cancellation", + "precision": "float64", + "repeat": 2, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 32, + "gpu_events": 32, + "due_edges": 32, + "accepted_edges": 32, + "attempted_requests": 32, + "accepted_requests": 32 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "ordered_cancellation", + "precision": "float32", + "repeat": 0, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 32, + "gpu_events": 32, + "due_edges": 32, + "accepted_edges": 32, + "attempted_requests": 32, + "accepted_requests": 32 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "ordered_cancellation", + "precision": "float32", + "repeat": 1, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 32, + "gpu_events": 32, + "due_edges": 32, + "accepted_edges": 32, + "attempted_requests": 32, + "accepted_requests": 32 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "ordered_cancellation", + "precision": "float32", + "repeat": 2, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 32, + "gpu_events": 32, + "due_edges": 32, + "accepted_edges": 32, + "attempted_requests": 32, + "accepted_requests": 32 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "release_selfloop", + "precision": "float64", + "repeat": 0, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 8, + "gpu_events": 8, + "due_edges": 11, + "accepted_edges": 4, + "attempted_requests": 6, + "accepted_requests": 6 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "release_selfloop", + "precision": "float64", + "repeat": 1, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 8, + "gpu_events": 8, + "due_edges": 11, + "accepted_edges": 4, + "attempted_requests": 6, + "accepted_requests": 6 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "release_selfloop", + "precision": "float64", + "repeat": 2, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 8, + "gpu_events": 8, + "due_edges": 11, + "accepted_edges": 4, + "attempted_requests": 6, + "accepted_requests": 6 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "release_selfloop", + "precision": "float32", + "repeat": 0, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 8, + "gpu_events": 8, + "due_edges": 11, + "accepted_edges": 4, + "attempted_requests": 6, + "accepted_requests": 6 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "release_selfloop", + "precision": "float32", + "repeat": 1, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 8, + "gpu_events": 8, + "due_edges": 11, + "accepted_edges": 4, + "attempted_requests": 6, + "accepted_requests": 6 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "release_selfloop", + "precision": "float32", + "repeat": 2, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 8, + "gpu_events": 8, + "due_edges": 11, + "accepted_edges": 4, + "attempted_requests": 6, + "accepted_requests": 6 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "signed_random", + "precision": "float64", + "repeat": 0, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 400, + "gpu_events": 400, + "due_edges": 3072, + "accepted_edges": 2517, + "attempted_requests": 27, + "accepted_requests": 23 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "signed_random", + "precision": "float64", + "repeat": 1, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 400, + "gpu_events": 400, + "due_edges": 3072, + "accepted_edges": 2517, + "attempted_requests": 27, + "accepted_requests": 23 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "signed_random", + "precision": "float64", + "repeat": 2, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 400, + "gpu_events": 400, + "due_edges": 3072, + "accepted_edges": 2517, + "attempted_requests": 27, + "accepted_requests": 23 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "signed_random", + "precision": "float32", + "repeat": 0, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 400, + "gpu_events": 400, + "due_edges": 3072, + "accepted_edges": 2517, + "attempted_requests": 27, + "accepted_requests": 23 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "signed_random", + "precision": "float32", + "repeat": 1, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 400, + "gpu_events": 400, + "due_edges": 3072, + "accepted_edges": 2517, + "attempted_requests": 27, + "accepted_requests": 23 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "signed_random", + "precision": "float32", + "repeat": 2, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 400, + "gpu_events": 400, + "due_edges": 3072, + "accepted_edges": 2517, + "attempted_requests": 27, + "accepted_requests": 23 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "threshold_rounding", + "precision": "float64", + "repeat": 0, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 4, + "gpu_events": 4, + "due_edges": 0, + "accepted_edges": 0, + "attempted_requests": 0, + "accepted_requests": 0 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "threshold_rounding", + "precision": "float64", + "repeat": 1, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 4, + "gpu_events": 4, + "due_edges": 0, + "accepted_edges": 0, + "attempted_requests": 0, + "accepted_requests": 0 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "threshold_rounding", + "precision": "float64", + "repeat": 2, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-11, + "first_event_divergence_step": null, + "oracle_events": 4, + "gpu_events": 4, + "due_edges": 0, + "accepted_edges": 0, + "attempted_requests": 0, + "accepted_requests": 0 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "threshold_rounding", + "precision": "float32", + "repeat": 0, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 3, + "gpu_events": 3, + "due_edges": 0, + "accepted_edges": 0, + "attempted_requests": 0, + "accepted_requests": 0 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "threshold_rounding", + "precision": "float32", + "repeat": 1, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 3, + "gpu_events": 3, + "due_edges": 0, + "accepted_edges": 0, + "attempted_requests": 0, + "accepted_requests": 0 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + }, + { + "case": "threshold_rounding", + "precision": "float32", + "repeat": 2, + "comparison": { + "pass_all": true, + "checks": { + "step": true, + "neuron_idx": true, + "counts": true, + "ref": true, + "history_ref_exact": true, + "finite_states": true, + "state_tolerance": true, + "weights_exact": true, + "request_attempted_exact": true, + "request_accepted_exact": true, + "request_rejected_exact": true, + "arrival_order_and_guard_exact": true + }, + "bitwise_history": true, + "max_abs_volt": 0.0, + "mean_abs_volt": 0.0, + "fixed_limit_volt": 1e-06, + "first_event_divergence_step": null, + "oracle_events": 3, + "gpu_events": 3, + "due_edges": 0, + "accepted_edges": 0, + "attempted_requests": 0, + "accepted_requests": 0 + }, + "repeat_arrays": { + "nodes": true, + "history": true, + "counts": true, + "v": true, + "g": true, + "ref": true, + "weights": true, + "step": true, + "neuron_idx": true, + "request_attempted": true, + "request_accepted": true, + "request_rejected": true, + "arrival_step": true, + "arrival_edge_index": true, + "arrival_accepted": true + }, + "pass_all": true + } + ], + "wall_seconds": 15.926790338000046, + "whole_brain_tested": false, + "learning_achieved": false +} diff --git a/registry/phase4ae-author-runtime/evidence/regression/old-integrity-after.json b/registry/phase4ae-author-runtime/evidence/regression/old-integrity-after.json new file mode 100644 index 0000000..8bff3e0 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/regression/old-integrity-after.json @@ -0,0 +1,83 @@ +{ + "original": { + "pass": true, + "checked": 230239, + "mismatches": [], + "reference_sha256": "6f186112e6102f2f7969de7442fa7ee4432200a3678586cfc4e10c490b31bca4", + "exclusions": [ + ".cache", + ".git", + ".mypy_cache", + ".pytest_cache", + ".venv", + "__pycache__", + "node_modules", + "venv" + ], + "new_stage_additions_allowed": true, + "meaning": "All original listed bytes checked; only newly named stage outputs are additions." + }, + "models/male-cns-lif/apl-pn-scope-audit-v1": { + "pass": true, + "checked": 12, + "mismatches": [], + "manifest_sha256": "9120685eb02dc2bd3b38d42b2ade1f38f6bbc2a1ec269fd4d555cead2d628277", + "checksums_sha256": "55dc418f2d62be04601af33cbd8789578447e6a2289d3a581dc713cbb7466a25" + }, + "experiments/phase4aa-apl-pn-scope": { + "pass": true, + "checked": 68, + "mismatches": [], + "manifest_sha256": "6d75567af2a6c0993d4fc08e272814910c19fa9602811cfacd1ebc4ba76bc737", + "checksums_sha256": "a69b2511689207b0d9ddbe2fabce3be71908f457bb898e3b685a213a796a272a" + }, + "models/male-cns-lif/terminal-scope-diagnostic-v1": { + "pass": true, + "checked": 11, + "mismatches": [], + "manifest_sha256": "5cea0035a95345825b73385c6e3056244c2a614d10a6fa6742487a331d8f0f3e", + "checksums_sha256": "92a03195cb41863027fd0397ad3811248354a5d3f2e91ffa2c297eba62dc2821" + }, + "experiments/phase4ab-terminal-scope": { + "pass": true, + "checked": 199, + "mismatches": [], + "manifest_sha256": "cb3723f9dae29d4889489ae39f40293c927f4f9e532551e2c4d5214bf0a70140", + "checksums_sha256": "d83926a3055d9f9ca471ceba328076d7ceba883f267468750914080733e95e31" + }, + "models/male-cns-lif/lif-semantics-audit-v1": { + "pass": true, + "checked": 7, + "mismatches": [], + "manifest_sha256": "53e53d51bba86ec11a02e920f2c2653db4c138dd9562e8416dd001780635070c", + "checksums_sha256": "15b7b7828492387beed2c885ad9d22af682cff1dc38198c0770ab7175759c69d" + }, + "experiments/phase4ac-lif-semantics": { + "pass": true, + "checked": 57, + "mismatches": [], + "manifest_sha256": "4e7d1606e107fe72f5dad935952705260577edaba6f811d65b4105ce07abd72c", + "checksums_sha256": "81bb3a86454147f1562bc3592438b6a6d0091dbe1d2a777e802882ecf1d0db35" + }, + "registry/feedback-context-review-20260930": { + "pass": true, + "checked": 8, + "mismatches": [], + "manifest_sha256": "8fda8506cae9b5b258fe371c8938a15e613114f4234c969fdf742d1f5133c64b", + "checksums_sha256": "9390c04cf4d0bcd2ed89bb4efd1db01cb2faf7dc4f23e8cb411b2ed782ba083d" + }, + "models/male-cns-lif/author-semantics-lab-v1": { + "pass": true, + "checked": 11, + "mismatches": [], + "manifest_sha256": "07a22bade4892adca3a4585656aa3ecce5219790b0dc8a851a12bfd7248d3769", + "checksums_sha256": "a632c04e62d8072caacfa680e0da7ad785a1d0db604cf5900853fd0b01c70ee7" + }, + "experiments/phase4ad-author-semantics": { + "pass": true, + "checked": 565, + "mismatches": [], + "manifest_sha256": "c939d3977a1883e86108c1e3edd25619118cec61e5c7712ae4dfa2893a73c0ca", + "checksums_sha256": "89ca0f11877dadb901bd2bd5d469d7bd145de980fc6b203b79daeec640a1b72c" + } +} diff --git a/registry/phase4ae-author-runtime/evidence/regression/old-integrity-before.json b/registry/phase4ae-author-runtime/evidence/regression/old-integrity-before.json new file mode 100644 index 0000000..8bff3e0 --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/regression/old-integrity-before.json @@ -0,0 +1,83 @@ +{ + "original": { + "pass": true, + "checked": 230239, + "mismatches": [], + "reference_sha256": "6f186112e6102f2f7969de7442fa7ee4432200a3678586cfc4e10c490b31bca4", + "exclusions": [ + ".cache", + ".git", + ".mypy_cache", + ".pytest_cache", + ".venv", + "__pycache__", + "node_modules", + "venv" + ], + "new_stage_additions_allowed": true, + "meaning": "All original listed bytes checked; only newly named stage outputs are additions." + }, + "models/male-cns-lif/apl-pn-scope-audit-v1": { + "pass": true, + "checked": 12, + "mismatches": [], + "manifest_sha256": "9120685eb02dc2bd3b38d42b2ade1f38f6bbc2a1ec269fd4d555cead2d628277", + "checksums_sha256": "55dc418f2d62be04601af33cbd8789578447e6a2289d3a581dc713cbb7466a25" + }, + "experiments/phase4aa-apl-pn-scope": { + "pass": true, + "checked": 68, + "mismatches": [], + "manifest_sha256": "6d75567af2a6c0993d4fc08e272814910c19fa9602811cfacd1ebc4ba76bc737", + "checksums_sha256": "a69b2511689207b0d9ddbe2fabce3be71908f457bb898e3b685a213a796a272a" + }, + "models/male-cns-lif/terminal-scope-diagnostic-v1": { + "pass": true, + "checked": 11, + "mismatches": [], + "manifest_sha256": "5cea0035a95345825b73385c6e3056244c2a614d10a6fa6742487a331d8f0f3e", + "checksums_sha256": "92a03195cb41863027fd0397ad3811248354a5d3f2e91ffa2c297eba62dc2821" + }, + "experiments/phase4ab-terminal-scope": { + "pass": true, + "checked": 199, + "mismatches": [], + "manifest_sha256": "cb3723f9dae29d4889489ae39f40293c927f4f9e532551e2c4d5214bf0a70140", + "checksums_sha256": "d83926a3055d9f9ca471ceba328076d7ceba883f267468750914080733e95e31" + }, + "models/male-cns-lif/lif-semantics-audit-v1": { + "pass": true, + "checked": 7, + "mismatches": [], + "manifest_sha256": "53e53d51bba86ec11a02e920f2c2653db4c138dd9562e8416dd001780635070c", + "checksums_sha256": "15b7b7828492387beed2c885ad9d22af682cff1dc38198c0770ab7175759c69d" + }, + "experiments/phase4ac-lif-semantics": { + "pass": true, + "checked": 57, + "mismatches": [], + "manifest_sha256": "4e7d1606e107fe72f5dad935952705260577edaba6f811d65b4105ce07abd72c", + "checksums_sha256": "81bb3a86454147f1562bc3592438b6a6d0091dbe1d2a777e802882ecf1d0db35" + }, + "registry/feedback-context-review-20260930": { + "pass": true, + "checked": 8, + "mismatches": [], + "manifest_sha256": "8fda8506cae9b5b258fe371c8938a15e613114f4234c969fdf742d1f5133c64b", + "checksums_sha256": "9390c04cf4d0bcd2ed89bb4efd1db01cb2faf7dc4f23e8cb411b2ed782ba083d" + }, + "models/male-cns-lif/author-semantics-lab-v1": { + "pass": true, + "checked": 11, + "mismatches": [], + "manifest_sha256": "07a22bade4892adca3a4585656aa3ecce5219790b0dc8a851a12bfd7248d3769", + "checksums_sha256": "a632c04e62d8072caacfa680e0da7ad785a1d0db604cf5900853fd0b01c70ee7" + }, + "experiments/phase4ad-author-semantics": { + "pass": true, + "checked": 565, + "mismatches": [], + "manifest_sha256": "c939d3977a1883e86108c1e3edd25619118cec61e5c7712ae4dfa2893a73c0ca", + "checksums_sha256": "89ca0f11877dadb901bd2bd5d469d7bd145de980fc6b203b79daeec640a1b72c" + } +} diff --git a/registry/phase4ae-author-runtime/evidence/regression/oracle-complete.json b/registry/phase4ae-author-runtime/evidence/regression/oracle-complete.json new file mode 100644 index 0000000..29113ab --- /dev/null +++ b/registry/phase4ae-author-runtime/evidence/regression/oracle-complete.json @@ -0,0 +1,125 @@ +{ + "cases": [ + { + "case": "fanin_bursts", + "precision": "float64", + "events": 1539 + }, + { + "case": "fanin_bursts", + "precision": "float32", + "events": 1539 + }, + { + "case": "highest_indegree", + "precision": "float64", + "events": 101 + }, + { + "case": "highest_indegree", + "precision": "float32", + "events": 101 + }, + { + "case": "mixed_high_indegree", + "precision": "float64", + "events": 106 + }, + { + "case": "mixed_high_indegree", + "precision": "float32", + "events": 106 + }, + { + "case": "motif_feedforward", + "precision": "float64", + "events": 3 + }, + { + "case": "motif_feedforward", + "precision": "float32", + "events": 3 + }, + { + "case": "motif_five", + "precision": "float64", + "events": 60 + }, + { + "case": "motif_five", + "precision": "float32", + "events": 60 + }, + { + "case": "motif_no_input", + "precision": "float64", + "events": 0 + }, + { + "case": "motif_no_input", + "precision": "float32", + "events": 0 + }, + { + "case": "motif_pair", + "precision": "float64", + "events": 22 + }, + { + "case": "motif_pair", + "precision": "float32", + "events": 22 + }, + { + "case": "motif_trio", + "precision": "float64", + "events": 45 + }, + { + "case": "motif_trio", + "precision": "float32", + "events": 45 + }, + { + "case": "ordered_cancellation", + "precision": "float64", + "events": 32 + }, + { + "case": "ordered_cancellation", + "precision": "float32", + "events": 32 + }, + { + "case": "release_selfloop", + "precision": "float64", + "events": 8 + }, + { + "case": "release_selfloop", + "precision": "float32", + "events": 8 + }, + { + "case": "signed_random", + "precision": "float64", + "events": 400 + }, + { + "case": "signed_random", + "precision": "float32", + "events": 400 + }, + { + "case": "threshold_rounding", + "precision": "float64", + "events": 4 + }, + { + "case": "threshold_rounding", + "precision": "float32", + "events": 3 + } + ], + "wall_seconds": 14.178826867000225 +} diff --git a/registry/phase4ae-author-runtime/seal-verification.json b/registry/phase4ae-author-runtime/seal-verification.json new file mode 100644 index 0000000..97da75b --- /dev/null +++ b/registry/phase4ae-author-runtime/seal-verification.json @@ -0,0 +1,16 @@ +{ + "models/male-cns-lif/author-runtime-lab-v1": { + "pass": true, + "checked": 11, + "mismatches": [], + "manifest_sha256": "7e8b0ac4adcd48eceabca7c9cc4f2c42a8746ebc673aee4490bae5a4746bbe12", + "checksums_sha256": "bf8eaad5963e6a6cf6bada6024ba37a36a0acb064bfc0beacd9c69dfd074b5c8" + }, + "experiments/phase4ae-author-runtime": { + "pass": true, + "checked": 916, + "mismatches": [], + "manifest_sha256": "a86caca4ecbd96c2b7cf24371b28f80f37170fa8769cdd9a31c822434be1eef5", + "checksums_sha256": "7bd84b8365953964b24684830e1fd97fca04bef8f8c051dcad3ff95633a1ae82" + } +} diff --git a/tools/publish_phase4ae.py b/tools/publish_phase4ae.py new file mode 100644 index 0000000..e4e29fd --- /dev/null +++ b/tools/publish_phase4ae.py @@ -0,0 +1,40 @@ +"""Copy small sealed evidence and compute descriptive cross-precision comparison.""" +import json +from pathlib import Path +import shutil +import sys +import numpy as np + +ROOT=Path('/data/digital-drosophila');MODEL=ROOT/'models/male-cns-lif/author-runtime-lab-v1';EXP=ROOT/'experiments/phase4ae-author-runtime' +sys.path.insert(0,str(MODEL)) +from context import save,digest,check +sys.path.insert(0,str(ROOT/'models/male-cns-lif/terminal-scope-diagnostic-v1')) +from diagnostic import manifest_check +check();verification={str(p.relative_to(ROOT)):manifest_check(p,digest) for p in (MODEL,EXP)} +assert all(v['pass'] for v in verification.values()) +registry=ROOT/'registry/phase4ae-author-runtime';registry.mkdir(exist_ok=False);records=[] +manifest=json.loads((EXP/'manifest.json').read_text()) +for p in [EXP/r['path'] for r in manifest['files']]+[EXP/'manifest.json',EXP/'checksums.sha256']: + if p.stat().st_size>4*1024**2 or p.suffix not in ('.json','.csv','.md','.sha256'):continue + dst=registry/'evidence'/p.relative_to(EXP);dst.parent.mkdir(parents=True,exist_ok=True) + with p.open('rb') as src,dst.open('xb') as out:shutil.copyfileobj(src,out) + assert digest(dst)==digest(p) + records.append(dict(source=str(p.relative_to(ROOT)),copy=str(dst.relative_to(registry)),sha256=digest(p),bytes=p.stat().st_size)) +save(registry/'evidence-index.json',records);save(registry/'seal-verification.json',verification) +cross=[] +for case in sorted((EXP/'cases').iterdir()): + paths=[EXP/'oracle'/(case.name+'-'+p)/'state.npz' for p in ('float64','float32')] + with np.load(paths[0]) as a,np.load(paths[1]) as b: + events=bool(np.array_equal(a['step'],b['step']) and np.array_equal(a['neuron_idx'],b['neuron_idx'])) + first=None + if not events: + for tick in range(len(a['history'])): + if not np.array_equal(a['neuron_idx'][a['step']==tick],b['neuron_idx'][b['step']==tick]):first=tick;break + cross.append(dict(case=case.name,event_equal=events,events_float64=len(a['step']),events_float32=len(b['step']), + first_event_divergence_step=first,max_vg_abs_volt=float(np.max(np.abs(a['history'][:,:2].astype(np.float64)-b['history'][:,:2].astype(np.float64)))), + input_hashes={str(p.relative_to(ROOT)):digest(p) for p in paths})) +save(registry/'cross-precision-description.json',dict(cases=cross, + meaning='Descriptive only; no changed tolerances, no variant selected by activity. Each GPU arm is validated against its own precision Brian oracle.')) +target=ROOT/'docs/progress/phase4ae-author-runtime.md' +with (EXP/'REPORT.md').open('rb') as src,target.open('xb') as out:shutil.copyfileobj(src,out) +print(json.dumps(dict(copied=len(records),cross_precision_event_differences=[r for r in cross if not r['event_equal']]),ensure_ascii=False))