Seal Phase 4AJ fixed APL timing hypothesis audit

2026-09-30 12:08:25 +08:00
parent 8d6b063aaf
commit cb6937666f
1992 changed files with 258416 additions and 10 deletions
@@ -0,0 +1,12 @@
+{
+  "KC_targets_in_case": 20,
+  "base_graph_files_modified": false,
+  "base_weight_raw_bytes_sha256": "41992774ca397eadc8b51d199c8ca6950567f363c5eebdeb7542f3a6ec8f2585",
+  "count": 50,
+  "effective_weights_file_sha256": "815a82e033b1f70f42595c15ad36677692521bde0befc558c34cfab624b38406",
+  "effective_weights_raw_sha256": "4f55a48a0b1e07e26b5fa132bb6a9ed87194f254ab832b4c7e9657b52cd375c6",
+  "fullgraph_required_mask_count": 5845,
+  "graded_targets": "only KC identities present in this LIF case",
+  "ordered_original_edge_id_sha256": "24009dd051cb88d5383254c72b2c6b15d7c8cb441cacb756804ddde6fac4c825",
+  "rule": "zero +0 all existing fast edges whose source GLOBAL neuron is in apl_globals; no graph edge removal"
+}
@@ -0,0 +1,39 @@
+{
+  "APL_generation_steps_after_window": 0,
+  "apl_delay_steps": 0,
+  "applied_generated_rows": 120,
+  "brain_steps_after_window": 0,
+  "brain_tail_advanced": false,
+  "closed_loop_branch_integrals_claimed_equal": false,
+  "delay_implementation": "independent list FIFO; no candidate or timing_queue imports",
+  "final_apl_state_float32": [
+    1.7472392320632935,
+    0.02430599182844162
+  ],
+  "final_apl_state_nonzero": true,
+  "final_apl_state_u32_bits": [
+    1071621513,
+    1019682140
+  ],
+  "finite_generated_sequence_partition_exact": true,
+  "future_apl_decay_or_feedback_generated": false,
+  "future_generated_decay_tail_included": false,
+  "generated_rows": 120,
+  "initial_zero_prefix": 0,
+  "meaning": "Tail contains only already generated h and any remaining initial-zero padding; never a complete future closed-loop or decay tail",
+  "pending_application_tick_start": 120,
+  "pending_application_tick_stop_exclusive": 120,
+  "pending_file_sha256": "3c2a5c3dfcbfa8529154fb7a9b107029ae01f9cf29407e32ca4cdeb6526ab33a",
+  "pending_generated_count": 0,
+  "pending_generated_tick_start": 120,
+  "pending_generated_tick_stop_exclusive": 120,
+  "pending_initial_zero_prefix": 0,
+  "pending_raw_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+  "pending_shape": [
+    0,
+    4064
+  ],
+  "positive_zero_warmup_exact": true,
+  "steps": 120,
+  "transport_shift_exact": true
+}
@@ -0,0 +1,56 @@
+{
+  "command": [
+    "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+    "-B",
+    "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py",
+    "--bundle-dir",
+    "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle",
+    "--dt-ms",
+    "0.1"
+  ],
+  "handshake": {
+    "array_sha256": {
+      "apl_globals.npy": "979ef88dff30d41168ce9b377a006ccb3cd034b2dce86d54923ca0f4b87cb6a6",
+      "input_matrix.npy": "528a5f6f5ffe424f323c5a44695db4a7cf32570709832eff2f37f49e85c92c3e",
+      "kc_globals.npy": "9e990d10a63b0f74cd7bbbdc5369082f24d5246487af944ba289bc6bf48d4b75",
+      "output_matrix.npy": "0dcf02cdb7836ab72da32ac47f5682ca33e25f63a8a662a8452d4ea9d46babb9"
+    },
+    "decay_f32_bits": "3f7eb923",
+    "dt_ms": 0.1,
+    "environment": {
+      "CUBLAS_WORKSPACE_CONFIG": null,
+      "cuda": "13.0",
+      "cuda_matmul_allow_tf32": false,
+      "cudnn": 92400,
+      "cudnn_allow_tf32": true,
+      "cudnn_benchmark": false,
+      "cudnn_deterministic": false,
+      "deterministic_algorithms": false,
+      "device_capability": [
+        8,
+        9
+      ],
+      "device_index": 0,
+      "device_name": "NVIDIA GeForce RTX 4090",
+      "float32_matmul_precision": "highest",
+      "numpy": "2.2.6",
+      "precision_configuration_changed_by_component": false,
+      "torch": "2.14.0+cu130"
+    },
+    "files_sha256": {
+      "apl_globals.npy": "8388c8795d49cfe5b14fda54f76ef3a35030c62ba87bd8ca6334a2dcdf186f19",
+      "input_matrix.npy": "c4d3df703ea5f1d7402b8255cfa19d9744139ad1048827c23b151d8ba766fec6",
+      "kc_globals.npy": "97a570aafa089f93e642b2bb07e3a3322dabb14c3c7dd431f0c8d2b3b7951fdd",
+      "output_matrix.npy": "e2d0a1ccd740e6777245ebf2efcd88bf5e1da9e47308c63ec8e83d451e134a73"
+    },
+    "gain_f32_bits": "3c23d70a",
+    "h_units": "legacy mV",
+    "initial_state": "float32 zeros",
+    "n_apl": 2,
+    "n_kc": 4064,
+    "n_neurons": 166700,
+    "ok": true,
+    "operator_sequence": "state.mul_(decay32); drive=mv(I32,spikes32); state.add_(drive); h=matmul(state,O32)*gain32",
+    "protocol": "phase4ag-apl-v1"
+  }
+}
@@ -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
+}
@@ -0,0 +1,124 @@
+[
+  {
+    "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": "before_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nafter_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_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    dt = _array_defaultclock_dt[0]\n    rfc = _array_default_neurons_rfc\n    t = _array_defaultclock_t[0]\n    lastspike = _array_default_neurons_lastspike\n    g = _array_default_neurons_g.copy()\n    v = _array_default_neurons_v.copy()\n    not_refractory = _array_default_neurons_not_refractory.copy()\n    not_refractory = timestep(t - lastspike, dt) >= timestep(rfc, dt)\n    _g = _numpy.where(not_refractory, _lio_2 * g, g)\n    _v = _numpy.where(not_refractory, _lio_8 + ((_lio_9 * g) + (_lio_10 * v)), _lio_7 + v)\n    g[not_refractory] = _g[not_refractory]\n    v[not_refractory] = _v[not_refractory]\n    _array_default_neurons_v[:] = v\n    _array_default_neurons_g[:] = g\n    _array_default_neurons_not_refractory[:] = not_refractory\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": "before_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nafter_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _array_default_neurons__spikespace[-1] = 0\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    numpy_True = _numpy.bool_(True)\n    numpy_False = _numpy.bool_(False)\n    # scalar code\n    _vectorisation_idx = 1\n    # vector code\n    _vectorisation_idx = LazyArange(N)\n    v = _array_default_neurons_v\n    not_refractory = _array_default_neurons_not_refractory\n    _cond = (v > v_th) & not_refractory\n    if _cond is True or _cond is numpy_True:\n        _events = _numpy.arange(N)\n    elif _cond is False or _cond is numpy_False:\n        _events = _numpy.array([])\n    else:\n        _events, = _cond.nonzero()\n    _array_default_neurons__spikespace[-1] = len(_events)\n    _array_default_neurons__spikespace[:len(_events)] = _events\n    # Set the neuron to refractory\n    _array_default_neurons_not_refractory[_events] = False\n    _array_default_neurons_lastspike[_events] = _array_defaultclock_t[0]\n",
+        "name": "default_neurons_spike_thresholder_codeobject"
+      }
+    ],
+    "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": "before_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nafter_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_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_i[_curlen:_newlen] = _to_record_i\n            _dynamic_array_spikemonitor_t[_curlen:_newlen] = _to_record_t\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": "before_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _owner.initialise_queue()\nafter_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\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": "before_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nafter_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _spiking_synapses = _queue.peek()\n    if len(_spiking_synapses):\n        # scalar code\n        # vector code\n        _idx = _spiking_synapses\n        _vectorisation_idx = _idx\n        #  Abstract code:  g += w\n        _postsynaptic_idx = _array_default_synapses__synaptic_post[_idx]\n        w = _array_default_synapses_w[_idx]\n        not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n        _numpy.add.at(_array_default_neurons_g, _postsynaptic_idx[not_refractory], w[not_refractory])\n    # Advance the spike queue\n    _queue.advance()\n",
+        "name": "default_synapses_pre_codeobject"
+      }
+    ],
+    "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": "before_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nafter_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_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_v[_idx] = v\n    _array_default_neurons_g[_idx] = g\n",
+        "name": "default_neurons_spike_resetter_codeobject"
+      }
+    ],
+    "name": "default_neurons_spike_resetter",
+    "order": 0,
+    "type": "Resetter",
+    "when": "resets"
+  },
+  {
+    "active": true,
+    "code_objects": [],
+    "name": "oracle_legacy_apl_unconditional",
+    "order": 0,
+    "type": "NetworkOperation",
+    "when": "end"
+  },
+  {
+    "active": true,
+    "code_objects": [],
+    "name": "oracle_after_apl_record",
+    "order": 1,
+    "type": "NetworkOperation",
+    "when": "end"
+  },
+  {
+    "active": true,
+    "code_objects": [],
+    "name": "zz_apl_queue_installer",
+    "order": 1000000,
+    "type": "QueueInstaller",
+    "when": "end"
+  }
+]
@@ -0,0 +1,17 @@
+{
+  "APL_precision": "float32 in separate science-Python process",
+  "Torch_imported_into_Brian": false,
+  "author_precision": "float64",
+  "codegen": "numpy",
+  "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]"
+}
@@ -0,0 +1,124 @@
+[
+  {
+    "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": "before_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nafter_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_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    dt = _array_defaultclock_dt[0]\n    rfc = _array_default_neurons_rfc\n    t = _array_defaultclock_t[0]\n    lastspike = _array_default_neurons_lastspike\n    g = _array_default_neurons_g.copy()\n    v = _array_default_neurons_v.copy()\n    not_refractory = _array_default_neurons_not_refractory.copy()\n    not_refractory = timestep(t - lastspike, dt) >= timestep(rfc, dt)\n    _g = _numpy.where(not_refractory, _lio_2 * g, g)\n    _v = _numpy.where(not_refractory, _lio_8 + ((_lio_9 * g) + (_lio_10 * v)), _lio_7 + v)\n    g[not_refractory] = _g[not_refractory]\n    v[not_refractory] = _v[not_refractory]\n    _array_default_neurons_v[:] = v\n    _array_default_neurons_g[:] = g\n    _array_default_neurons_not_refractory[:] = not_refractory\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": "before_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nafter_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _array_default_neurons__spikespace[-1] = 0\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    numpy_True = _numpy.bool_(True)\n    numpy_False = _numpy.bool_(False)\n    # scalar code\n    _vectorisation_idx = 1\n    # vector code\n    _vectorisation_idx = LazyArange(N)\n    v = _array_default_neurons_v\n    not_refractory = _array_default_neurons_not_refractory\n    _cond = (v > v_th) & not_refractory\n    if _cond is True or _cond is numpy_True:\n        _events = _numpy.arange(N)\n    elif _cond is False or _cond is numpy_False:\n        _events = _numpy.array([])\n    else:\n        _events, = _cond.nonzero()\n    _array_default_neurons__spikespace[-1] = len(_events)\n    _array_default_neurons__spikespace[:len(_events)] = _events\n    # Set the neuron to refractory\n    _array_default_neurons_not_refractory[_events] = False\n    _array_default_neurons_lastspike[_events] = _array_defaultclock_t[0]\n",
+        "name": "default_neurons_spike_thresholder_codeobject_1"
+      }
+    ],
+    "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": "before_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nafter_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_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_i[_curlen:_newlen] = _to_record_i\n            _dynamic_array_spikemonitor_t[_curlen:_newlen] = _to_record_t\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": "before_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _owner.initialise_queue()\nafter_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\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": "before_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nafter_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _spiking_synapses = _queue.peek()\n    if len(_spiking_synapses):\n        # scalar code\n        # vector code\n        _idx = _spiking_synapses\n        _vectorisation_idx = _idx\n        #  Abstract code:  g += w\n        _postsynaptic_idx = _array_default_synapses__synaptic_post[_idx]\n        w = _array_default_synapses_w[_idx]\n        not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n        _numpy.add.at(_array_default_neurons_g, _postsynaptic_idx[not_refractory], w[not_refractory])\n    # Advance the spike queue\n    _queue.advance()\n",
+        "name": "default_synapses_pre_codeobject_1"
+      }
+    ],
+    "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": "before_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nafter_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_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_v[_idx] = v\n    _array_default_neurons_g[_idx] = g\n",
+        "name": "default_neurons_spike_resetter_codeobject_1"
+      }
+    ],
+    "name": "default_neurons_spike_resetter",
+    "order": 0,
+    "type": "Resetter",
+    "when": "resets"
+  },
+  {
+    "active": true,
+    "code_objects": [],
+    "name": "oracle_legacy_apl_unconditional",
+    "order": 0,
+    "type": "NetworkOperation",
+    "when": "end"
+  },
+  {
+    "active": true,
+    "code_objects": [],
+    "name": "oracle_after_apl_record",
+    "order": 1,
+    "type": "NetworkOperation",
+    "when": "end"
+  },
+  {
+    "active": true,
+    "code_objects": [],
+    "name": "zz_apl_queue_installer",
+    "order": 1000000,
+    "type": "QueueInstaller",
+    "when": "end"
+  }
+]
@@ -0,0 +1,70 @@
+{
+  "ae_sha256": "32eb1c42383068ce52701d2139a376ce155ad7072cde019949f8ca2d55492409",
+  "af_sha256": "d72003d98f0f1624b12126eff50bd361c43d888f4a64d90ba9247a58976f1961",
+  "apl_delay_steps": 0,
+  "author_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e",
+  "bundle_hashes": {
+    "apl_globals.npy": "8388c8795d49cfe5b14fda54f76ef3a35030c62ba87bd8ca6334a2dcdf186f19",
+    "input_matrix.npy": "c4d3df703ea5f1d7402b8255cfa19d9744139ad1048827c23b151d8ba766fec6",
+    "kc_globals.npy": "97a570aafa089f93e642b2bb07e3a3322dabb14c3c7dd431f0c8d2b3b7951fdd",
+    "output_matrix.npy": "e2d0a1ccd740e6777245ebf2efcd88bf5e1da9e47308c63ec8e83d451e134a73"
+  },
+  "candidate_trace_used_as_input": false,
+  "case_hashes": {
+    "arrays.npz": "c256234eec74752513c95d961233e7c1a7b5caa20deaa9b4913be9f539b2f1d8",
+    "requests.npz": "2b5c4d1491dd65ac70a2e23b8d4db9be7f0798fabff114c308a753ccb58a051f",
+    "spec.json": "09382ada7694a5ceec602cf2626d9e291f01afc02188fc1e0b501718940e735e"
+  },
+  "coefficients_sha256": "bde79d95ef0097b827d5faf4d5658eafc009d8e9fcef1fddd645c953823e3f64",
+  "copied_oracle_sha256": "357a7d3debb5abc34a8714c0233b456547a154d9d5855d28661b4f01019a80ea",
+  "copied_oracle_source": "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/oracle_apl.py",
+  "graph_hashes": {
+    "completeness.csv": "fe19419a07b379537e0f94176c6e60058d42f07d576c87e7bebf1c7a568a500f",
+    "connectivity.parquet": "5ee85c2b1befe4cde2ca5ad3ace142bb4e338a143d99d756d348d6aeaf44db9b",
+    "dst.npy": "6f50ad492013b3d14fe45c46210a68c37fb138337ae7f91eed0730f92d5cc7d6",
+    "edge_id.npy": "8b3ad7ca57738feb1495d75dadb7c7cd62890ab0b763bfb46ed217d4002c8765",
+    "nodes.npy": "2a65c268f42ecb99ce2a30a22f0b654a0101ab1f336388bc2e96dc7057ccc0bd",
+    "ptr.npy": "98f301cd19c6e01a911249cc594431369ed593b686f870c24aee86fcb41c8f81",
+    "signed_raw.npy": "8af7fa8ede8c3da396d00bee2146d01cd549c065702d8e27211df73ad1a32471",
+    "src.npy": "98ccabc84a7a57fa01a92f7164e5333dbe3f90bf18efbccf3cb4f40fef326a5f",
+    "weights.npy": "d751ac5a580f88071e5a876882ada072aeb8e461f76e4fbca4ad41fa4b14f865"
+  },
+  "legacy_apl_worker_sha256": "21ceec65fe42581dc55872010e0025d660e80358905f1cf4df1dadf341a3b291",
+  "only_scientific_change": "transport generated graded-APL h before the unchanged end write",
+  "scope": "shared-APL-component closed-loop oracle, not all-components-independent CPU equivalence",
+  "spec": {
+    "apl": {
+      "gain": 0.01,
+      "normalization": 1.0,
+      "tau_ms": 20.0
+    },
+    "apl_bundle_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/apl-bundle",
+    "apl_delay_steps": 0,
+    "apl_precision": "float32",
+    "budget_root": "/data/digital-drosophila/experiments/phase4aj-apl-timing",
+    "coefficients_path": "/data/digital-drosophila/experiments/phase4af-author-fullgraph/oracle/no_input/coefficients.json",
+    "dt_ms": 0.1,
+    "duration_ms": 12.0,
+    "graph_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/fixtures",
+    "kind": "fixture",
+    "legacy_apl_worker": "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py",
+    "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": "arrival_collision",
+    "output_budget_bytes": 25769803776,
+    "precision": "float64",
+    "record_history": true,
+    "science_python": "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+    "steps": 120,
+    "training": false
+  }
+}
@@ -0,0 +1,60 @@
+{
+  "APL_SI_conversion": "h.astype(float64) * float64(0.001), then separate float64 g subtraction",
+  "APL_dtype": "float32",
+  "APL_h_units": "mV; gain already applied in float32",
+  "APL_inhibition_file_means": "generated h at the actual closed-loop Brian spike tick, not the delayed applied value",
+  "APL_input": "Brian's own actual global spikes, never candidate spikes or candidate inhibition",
+  "APL_pending_file": "apl-pending-tail.float32.npy",
+  "APL_pending_generated_count": 0,
+  "APL_pending_initial_zero_prefix": 0,
+  "APL_pending_scope": "next D scheduled applications from recorded h plus unconsumed initial zero slots; not future generated decay",
+  "APL_shapes": {
+    "applied": [
+      120,
+      4064
+    ],
+    "drive": [
+      120,
+      2
+    ],
+    "inhibition": [
+      120,
+      4064
+    ],
+    "pending_tail": [
+      0,
+      4064
+    ],
+    "state": [
+      120,
+      2
+    ]
+  },
+  "APL_transport": "applied[t]=generated_h[t-D] for t>=D, positive zero otherwise; separate independent list FIFO",
+  "APL_write_schedule": "end, order=0, after original reset, unconditional raw g write; recorder end/order=1",
+  "apl_delay_steps": 0,
+  "complete_marker": "summary.json complete=true only after worker exit and all checks",
+  "history_recorded": true,
+  "history_shape": [
+    120,
+    44
+  ],
+  "queue_protocol": "sealed Phase4AF queue_summary; original global edge IDs, including zero-weight/ref-rejected arrivals",
+  "request_columns": [
+    "tick",
+    "neuron_idx",
+    "attempted",
+    "accepted",
+    "rejected"
+  ],
+  "state_hash_encoding": "SHA256 of contiguous little-endian raw f64 V/g and i32 ref",
+  "state_hash_file": "tick-state-hashes.jsonl",
+  "state_npz": [
+    "step",
+    "neuron_idx",
+    "counts",
+    "v",
+    "g",
+    "ref"
+  ]
+}
@@ -0,0 +1,34 @@
+{
+  "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
+  }
+}
@@ -0,0 +1,15 @@
+{
+  "advance_calls": 120,
+  "forwarding_contract": "sealed AE/AF design",
+  "installations": [
+    "default_synapses_pre_codeobject",
+    "default_synapses_pre_codeobject_1"
+  ],
+  "limit": "Current wrapper was not independently rerun without the queue proxy",
+  "new_unwrapped_repeat_performed": false,
+  "original_edge_ids_not_sorted_or_filtered": true,
+  "peek_calls": 120,
+  "post_threshold_pre_synaptic_guard_observed": true,
+  "same_peek_object_returned": true,
+  "zero_weight_and_refractory_rejected_edges_retained": true
+}
@@ -0,0 +1,5 @@
+tick,neuron_idx,attempted,accepted,rejected
+0,71,1,1,0
+0,38891,1,1,0
+18,88824,1,1,0
+21,38891,1,0,1
@@ -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_legacy_apl_unconditional (NetworkOperation) | --                            | 100. us (every step) | end               |       0 |  yes  \noracle_after_apl_record (NetworkOperation)         | --                            | 100. us (every step) | end               |       1 |  yes  \nzz_apl_queue_installer (QueueInstaller)            | --                            | 100. us (every step) | end               | 1000000 |  yes  "
+}
@@ -0,0 +1,51 @@
+{
+  "APL_applied_sha256": "04a2f0809f96a13a8e07649f11f546c78e4173583f599f6c8a60109df8d8005a",
+  "APL_fast_edges_zeroed": 50,
+  "APL_finite_sequence_partition_exact": true,
+  "APL_pending_tail_sha256": "3c2a5c3dfcbfa8529154fb7a9b107029ae01f9cf29407e32ca4cdeb6526ab33a",
+  "APL_precision": "float32",
+  "APL_timing_audit_sha256": "97d374e126014f05056457ef0eacffbcde941bdd69c830609e78dbbf38bac3f7",
+  "APL_transport_shift_exact": true,
+  "APL_worker_exit_status": 0,
+  "APL_worker_ticks": 120,
+  "apl_delay_steps": 0,
+  "apl_fast_edges_zeroed": 50,
+  "applicable_requests": 3,
+  "backend": "shared-APL-component closed-loop Brian2 oracle",
+  "candidate_trace_used_as_input": false,
+  "complete": true,
+  "completed_ticks": 120,
+  "edges": 287,
+  "effective_weights_raw_sha256": "4f55a48a0b1e07e26b5fa132bb6a9ed87194f254ab832b4c7e9657b52cd375c6",
+  "events_sha256": "39136eaca57a5fc7eee6e4c41af79421a0e5931cdfba474e33949a775d5db53e",
+  "future_generated_decay_tail_included": false,
+  "history_recorded": true,
+  "independent_CPU_all_components_claim": false,
+  "initial_zero_prefix": 0,
+  "kc_targets_present": 20,
+  "name": "arrival_collision",
+  "no_poi": true,
+  "no_training": true,
+  "nodes": 44,
+  "output_budget_bytes": 25769803776,
+  "output_bytes_before_summary": 622936866,
+  "pass_all": true,
+  "pass_all_scope": "Oracle construction, protocol and internal self-checks only; candidate comparison is a separate gate",
+  "pending_generated_count": 0,
+  "pending_initial_zero_prefix": 0,
+  "pending_tail_shape": [
+    0,
+    4064
+  ],
+  "precision": "float64",
+  "queue_sha256": "a14e60c29eee17afa66692052d5aa7661c6269785a5672ab116b9ca096a247e0",
+  "ref_rejected_requests": 1,
+  "requests": 4,
+  "scope": "Only this fixed trajectory; legacy Torch APL is a shared numerical component, not an independent CPU APL implementation",
+  "single_continuous_run": true,
+  "source_and_inputs_unchanged": true,
+  "spikes": 3,
+  "state_hashes_sha256": "0bb726cf2815518ea4fe632d6eb162fecd1865cef54ec0fa25ba22a20f479772",
+  "steps": 120,
+  "weights_sha256": "815a82e033b1f70f42595c15ad36677692521bde0befc558c34cfab624b38406"
+}