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": 4064,
+  "base_graph_files_modified": false,
+  "base_weight_raw_bytes_sha256": "a8c19cde743bd456bcb2e988d504f805b6943d6ceb97cd241d6e1e472ab5a591",
+  "count": 5845,
+  "effective_weights_file_sha256": "ac433da4b0ac3cdc20c526d99a7158c3dc2298b62c10784f9dcd7db1f089214b",
+  "effective_weights_raw_sha256": "b8b8f43048e0ef03943e607666319d25363bed3b2564fdc02b4149837e7eedc9",
+  "fullgraph_required_mask_count": 5845,
+  "graded_targets": "only KC identities present in this LIF case",
+  "ordered_original_edge_id_sha256": "78d88b017b336f9c72a230680a39a9c4e74fedeff6fbb7b9c8641f30cb15e72b",
+  "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": 1000,
+  "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": [
+    146.9673614501953,
+    169.30679321289062
+  ],
+  "final_apl_state_nonzero": true,
+  "final_apl_state_u32_bits": [
+    1125316517,
+    1126780554
+  ],
+  "finite_generated_sequence_partition_exact": true,
+  "future_apl_decay_or_feedback_generated": false,
+  "future_generated_decay_tail_included": false,
+  "generated_rows": 1000,
+  "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": 1000,
+  "pending_application_tick_stop_exclusive": 1000,
+  "pending_file_sha256": "3c2a5c3dfcbfa8529154fb7a9b107029ae01f9cf29407e32ca4cdeb6526ab33a",
+  "pending_generated_count": 0,
+  "pending_generated_tick_start": 1000,
+  "pending_generated_tick_stop_exclusive": 1000,
+  "pending_initial_zero_prefix": 0,
+  "pending_raw_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+  "pending_shape": [
+    0,
+    4064
+  ],
+  "positive_zero_warmup_exact": true,
+  "steps": 1000,
+  "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\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    rfc = _array_default_neurons_rfc\n    t = _array_defaultclock_t[0]\n    not_refractory = _array_default_neurons_not_refractory.copy()\n    v = _array_default_neurons_v.copy()\n    dt = _array_defaultclock_dt[0]\n    lastspike = _array_default_neurons_lastspike\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\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\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\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]\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\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\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\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\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()\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _owner.push_spikes()\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\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\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()\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\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\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\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\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\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    rfc = _array_default_neurons_rfc\n    t = _array_defaultclock_t[0]\n    not_refractory = _array_default_neurons_not_refractory.copy()\n    v = _array_default_neurons_v.copy()\n    dt = _array_defaultclock_dt[0]\n    lastspike = _array_default_neurons_lastspike\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\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\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\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]\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\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\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\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\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()\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _owner.push_spikes()\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\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\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()\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\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\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\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\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,77 @@
+{
+  "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": {
+    "requests.npz": "9f87b434e8da524ce31b4563ad89ab47189dc7035c9f827840f3250aad81083d",
+    "spec.json": "2232a76d76465f67fc0162e1b0c68df30273ef6ffd3b10ff1154686ac0d43952"
+  },
+  "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": "fb9033398abb7585ae63472ced9d8c8cab787f69965dc9ce5fa409ab105bc1bc",
+    "connectivity.parquet": "1362c1102b74f5552f4b01fca956574fd6252f749e31493c4a00a1bc9eab00b3",
+    "dst.npy": "ce20f7433f78442c717ad2a7b5394cf4a3b109d990b4be0788040b7b0f4ed150",
+    "edge_id.npy": "49260615ff2b6432ce3dea9ce2c7ab8f83d06c2fb7491e58e08355fcedf86a30",
+    "nodes.npy": "5b511a98e8fbf8d65bbc70b93e75ecae19366f650b7842a45611bfad62ed83dc",
+    "ptr.npy": "fe43420f11e6242a11f8199ae7f097cab4b8a6db181d36f2a46b9e46670acbb4",
+    "signed_raw.npy": "f9884ccb8930b32420b27c69271df78034a8350fe5a5c9b76a63c259268efc09",
+    "src.npy": "bfd625ce690fc21eb0a8b9dede831688ab73b789045ba83ddf4baeefeddf1fc3",
+    "weights.npy": "462839ffc3feb8f6c278044488082b1c8e410e7f23229d6b5e29d1b7042416a1"
+  },
+  "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": 100.0,
+    "expected_external_events": 105.90211181640625,
+    "graph_dir": "/data/digital-drosophila/experiments/phase4ag-author-apl-r2/graphs/full",
+    "kind": "calibration",
+    "legacy_apl_worker": "/data/digital-drosophila/models/male-cns-lif/author-apl-lab-v2/legacy_apl_worker.py",
+    "mode": "physiological",
+    "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": "cal-physiological-00-s51101",
+    "odor_id": "OMSUIQOIVADKIM-RXMQYKEDSA-N",
+    "odor_index": 0,
+    "odor_name": "ethyl (R)-(-)-3-hydroxybutanoate",
+    "output_budget_bytes": 25769803776,
+    "precision": "float64",
+    "rate_sum_hz": 1059.0211181640625,
+    "record_history": false,
+    "science_python": "/data/digital-drosophila/models/male-cns-lif/.venv/bin/python",
+    "seed": 51101,
+    "steps": 1000,
+    "target_count": 48,
+    "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": [
+      1000,
+      4064
+    ],
+    "drive": [
+      1000,
+      2
+    ],
+    "inhibition": [
+      1000,
+      4064
+    ],
+    "pending_tail": [
+      0,
+      4064
+    ],
+    "state": [
+      1000,
+      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": false,
+  "history_shape": [
+    1000,
+    166700
+  ],
+  "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": 1000,
+  "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": 1000,
+  "post_threshold_pre_synaptic_guard_observed": true,
+  "same_peek_object_returned": true,
+  "zero_weight_and_refractory_rejected_edges_retained": true
+}
@@ -0,0 +1,122 @@
+tick,neuron_idx,attempted,accepted,rejected
+1,522,1,1,0
+26,2010,1,1,0
+27,7679,1,1,0
+31,4311,1,1,0
+37,7781,1,1,0
+40,2601,1,1,0
+42,3345,1,1,0
+58,1011,1,1,0
+59,2493,1,1,0
+69,5519,1,1,0
+81,7679,1,1,0
+86,3252,1,1,0
+95,1514,1,1,0
+102,3252,1,0,1
+103,12644,1,1,0
+115,130497,1,1,0
+127,2970,1,1,0
+130,4505,1,0,1
+137,2010,1,1,0
+158,130753,1,1,0
+162,2029,1,1,0
+162,130472,1,1,0
+163,2010,1,1,0
+181,522,1,1,0
+190,10769,1,1,0
+195,360,1,1,0
+198,2493,1,1,0
+199,1011,1,1,0
+241,1011,1,1,0
+247,10769,1,1,0
+248,6842,1,0,1
+252,2010,1,1,0
+253,4026,1,1,0
+259,360,1,1,0
+260,4026,1,0,1
+265,999,1,1,0
+270,3345,1,1,0
+271,2231,1,1,0
+288,1514,1,0,1
+299,3161,1,1,0
+300,522,1,0,1
+319,3252,1,1,0
+326,1514,1,1,0
+331,2601,1,1,0
+335,9975,1,1,0
+345,2586,1,0,1
+365,3202,1,0,1
+377,3252,1,0,1
+412,1514,1,1,0
+413,2493,1,1,0
+417,130753,1,1,0
+418,130753,1,0,1
+425,6842,1,1,0
+431,360,1,0,1
+444,9370,1,1,0
+445,189,1,0,1
+458,9370,1,0,1
+474,331,1,1,0
+480,1011,1,1,0
+483,6842,1,1,0
+492,3202,1,0,1
+497,189,1,0,1
+500,2029,1,1,0
+501,9188,1,1,0
+503,7679,1,1,0
+510,6842,1,1,0
+528,1011,1,1,0
+530,2535,1,1,0
+588,522,1,1,0
+589,1011,1,0,1
+605,3252,1,1,0
+607,12644,1,1,0
+609,4505,1,0,1
+623,4311,1,1,0
+633,3161,1,1,0
+637,131226,1,1,0
+650,2010,1,0,1
+652,331,1,1,0
+659,3252,1,1,0
+667,8504,1,1,0
+674,14839,1,0,1
+676,360,1,0,1
+680,1011,1,0,1
+687,2347,1,1,0
+697,522,1,1,0
+704,10769,1,1,0
+704,21802,1,1,0
+709,9975,1,1,0
+722,2970,1,1,0
+724,3202,1,1,0
+743,2231,1,0,1
+749,12644,1,1,0
+752,2029,1,1,0
+752,2970,1,1,0
+757,4311,1,1,0
+764,5519,1,1,0
+778,2586,1,0,1
+785,360,1,1,0
+787,999,1,0,1
+815,522,1,1,0
+835,2010,1,1,0
+844,130753,1,1,0
+853,2231,1,1,0
+862,10769,1,1,0
+867,1514,1,1,0
+872,1191,1,1,0
+874,2029,1,1,0
+878,1927,1,1,0
+880,131226,1,0,1
+901,130472,1,1,0
+904,130497,1,1,0
+906,1514,1,1,0
+920,522,1,1,0
+942,7679,1,1,0
+951,5519,1,1,0
+952,5519,1,0,1
+955,2493,1,1,0
+961,360,1,0,1
+961,130753,1,0,1
+989,2601,1,1,0
+993,14839,1,1,0
@@ -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": "0227a22a7c8f54321e7f02ef320a3bc22142b7efd63d9fc4a475653c86d4f025",
+  "APL_fast_edges_zeroed": 5845,
+  "APL_finite_sequence_partition_exact": true,
+  "APL_pending_tail_sha256": "3c2a5c3dfcbfa8529154fb7a9b107029ae01f9cf29407e32ca4cdeb6526ab33a",
+  "APL_precision": "float32",
+  "APL_timing_audit_sha256": "4688b8633b41678bf774c052e8388e3c66168a06527f8d1f36152054121b56c6",
+  "APL_transport_shift_exact": true,
+  "APL_worker_exit_status": 0,
+  "APL_worker_ticks": 1000,
+  "apl_delay_steps": 0,
+  "apl_fast_edges_zeroed": 5845,
+  "applicable_requests": 93,
+  "backend": "shared-APL-component closed-loop Brian2 oracle",
+  "candidate_trace_used_as_input": false,
+  "complete": true,
+  "completed_ticks": 1000,
+  "edges": 25582938,
+  "effective_weights_raw_sha256": "b8b8f43048e0ef03943e607666319d25363bed3b2564fdc02b4149837e7eedc9",
+  "events_sha256": "4980889373ddb0681fd3444881a59242681890b9c0fa0aa20154ad9376c3cdbd",
+  "future_generated_decay_tail_included": false,
+  "history_recorded": false,
+  "independent_CPU_all_components_claim": false,
+  "initial_zero_prefix": 0,
+  "kc_targets_present": 4064,
+  "name": "cal-physiological-00-s51101",
+  "no_poi": true,
+  "no_training": true,
+  "nodes": 166700,
+  "output_budget_bytes": 25769803776,
+  "output_bytes_before_summary": 1207221169,
+  "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": "8ed73b17d00fc6a67b807c3d36f5c9b82a974f17f1ce2d3bfd9f8d6c15de5a01",
+  "ref_rejected_requests": 28,
+  "requests": 121,
+  "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": 29938,
+  "state_hashes_sha256": "f9134739ed6a2b7558957a2bc47ad375d831b733d4c259a826e4be296bcb0cc9",
+  "steps": 1000,
+  "weights_sha256": "ac433da4b0ac3cdc20c526d99a7158c3dc2298b62c10784f9dcd7db1f089214b"
+}