# Felisyn protocol 017: do the cat-circuit model's dynamics change its decisions? (simulation only)

Declared 23 October 2026 (Europe/Vienna), before any milestone-2 model run. The model data seen for this question so far are:

- the reduction check (5 s of spontaneous activity);
- the milestone-1 probe, an exploratory run that set the decoder (below);
- two 16-step feedforward-only smoke runs on the reduction;
- smoke runs of the sequence stimulus on Mozaik's tiny test configuration, which is saturated and unusable as an engine.

Everything here is simulation. No wallet, token, exchange, key or real order exists in this work, and nothing here is connected to one.

## Question

Felisyn's controller stage asks whether a cat visual-cortex circuit model can sit inside a decision pipeline as more than a decoration. We build a simulated pipeline:

1. A synthetic market produces a signal at every step.
2. An encoder turns the signal into a visual stimulus.
3. The circuit model responds.
4. A fixed decoder turns its spikes into a buy, sell or hold request.
5. A simulated executor accepts or rejects the request under limits.

The test question is whether the circuit's dynamics materially change the decisions: whether a decision depends on the previous input, beyond the response to the current one. We also ask whether the circuit's intracortical connections matter for the answer.

The project plan fixes the consequence. If the dynamics contribute nothing beyond a simpler baseline, this controller design stops and we report that.

## Engine

The model is a 2 mm reduction of the published LSV1M model (Antolík et al. 2024): retina and LGN, then layer 4 and layer 2/3 excitatory and inhibitory populations with an orientation map. It uses the published parameter set `param_spont`, the one of our full run 011. That set differs from the published `param` only in its recorders, and our copy replaces those with spike recorders on every neuron. The published files are otherwise unchanged. Three command-line overrides make the reduction:

- cortical sheet 2000 µm instead of 5000 µm;
- LGN patch 3°;
- orientation-map stretch 8.375, which keeps the map's physical scale.

**Reduction check** (23 Oct, 5 s spontaneous, `reduction-check.json`):

- activity is asynchronous and irregular (ISI CV 0.91-0.96);
- rates are 2.0, 9.0, 3.1 and 10.9 Hz (L4E, L4I, L2/3E, L2/3I) against the full model's 1.4, 7.6, 2.0 and 4.7;
- spike-count correlations are 3-6 times higher;
- neurons near the sheet edge fire more.

The reduction is not the validated full model. Every result of this protocol is labelled as the reduction.

**Time scales that can link successive steps:**

- The model has no slow spike-frequency adaptation: its excitatory cells' adaptation time constant is 1 ms, and its inhibitory cells have none.
- Synapses within the cortex, L4E→L2/3 included, recover from depression with time constants of 20 to 70 ms.
- Synapses from the LGN to layer 4 recover with 125 ms.
- The LGN's temporal filters last 200 ms, and the LGN has contrast gain control.
- Recurrent activity in the cortical network itself.

## Pipeline (declared engineering choices, no biological or financial meaning)

- **Market.** 120 steps with i.i.d. signals s_t, uniform on [−1, 1] (`decisions.iid_market`). The seed is 170, fixed in this declaration before the sequence was generated. The sequence is generated once, so no seed is selected. The next log return is r_(t+1) = 0.01·s_t + N(0, 0.02²). The signal predicts the next return slightly by construction, so the noiseless rule has a positive expected simulated P&L. Signals are independent from step to step, so any dependence of a decision on an earlier signal can only come from the pipeline itself.
- **Encoder.** Grating orientation 90° + s·45° (45° to 135°) and contrast 30 + 70·|s| percent. The stimuli are full-field drifting sinusoidal gratings at 0.8 cycles per degree and 2 Hz, the same stimulus family as the model paper's orientation-tuning protocol. Each step shows the grating for 210 ms (30 frames of 7 ms), then a mean-luminance blank for 147 ms (21 frames), so one step lasts 357 ms. The network is never reset between steps. The sequence is shown as consecutive presentations of at most 100 steps, balanced in size (`server/controller_experiments.py`). The first starts with a recorded 504 ms mean-luminance lead-in, so the network settles before step 0. Mozaik adds its usual unrecorded 150 ms blank before each presentation. So the first step of each later presentation follows its predecessor after 297 ms of blank instead of 147 ms. Those few pairs are kept in every measure. The split is needed because Mozaik computes a presentation's whole LGN input before simulating it and keeps it in memory, about 1.2 s and 0.12 MB per 7 ms frame.
- **Decoder.** A population vector over the spike counts of all 6,000 layer 4 excitatory neurons, 40 to 300 ms after each step's onset, with balanced weights w_n = exp(2iφ_n) − mean_m exp(2iφ_m) (`decoder.json`). With balanced weights, a response that is equal across neurons adds nothing, whatever the distribution of preferences. Each neuron's preference φ_n is its map-assigned orientation (`LGNAfferentOrientation`). The estimate is θ_t = arg(Σ_n c_n·w_n)/2, in [0°, 180°). The decision signal is ŝ_t = clip((θ_t − 90°)/45°, −1, 1). The request is buy above +0.25, sell below −0.25, otherwise hold, with 1 unit per order. A step with no spikes in the window is a hold.
- **Executor (simulated).** Cash 100, position limit 5 units, order size limit 1 unit, fee 0.3 %. Fills happen at the step's synthetic price. The log has four separate stages per step: model output, decoded request, executor decision and simulated outcome.

## Conditions

All three model runs see the same declared sequence (`sequence.json`):

| Run | What changes | Command-line overrides beyond the reduction |
| --- | --- | --- |
| intact-A | nothing: the published parameters | none |
| intact-B | a second network instance | `pynn_seed 6` (published: 5) |
| feedforward-only | intact-A's network with every connection between cortical neurons at zero weight | the five base weights below set to `0.0` |

**Second instance.** `pynn_seed` draws the neuron positions. The per-neuron seeds for connection sampling and weight draws come from Mozaik's own generator (seed 513, fixed by the pinned code), so they are the same in both instances. The connections still differ, because positions, and with them distances and map-assigned preferences, differ. The NEST kernel seed (42) is the same in all three runs, so the LGN's noise may also come out identical. The analysis reports, for each pair of runs, the fraction of LGN neurons with identical spike trains.

**Feedforward-only.** Mozaik applies overrides before it resolves parameter references. Setting five literal base weights to zero therefore zeroes twelve projections:

- within layer 4: L4E→L4E, L4E→L4I, L4I→L4E and L4I→L4I;
- within layer 2/3: L2/3E→L2/3E, L2/3E→L2/3I, L2/3I→L2/3E and L2/3I→L2/3I;
- between the layers: L4E→L2/3E and L4E→L2/3I, and the feedback L2/3E→L4E and L2/3E→L4I.

Only LGN→L4E and LGN→L4I are kept. The decoded layer 4 is therefore driven by the LGN alone, with no input from any cortical neuron. The five overrides are:

- `sheets.l4_cortex_exc.L4ExcL4ExcConnection.base_weight`
- `sheets.l4_cortex_exc.L4ExcL4InhConnection.base_weight`
- `sheets.l4_cortex_inh.L4InhL4ExcConnection.base_weight`
- `sheets.l23_cortex_exc.L23ExcL23InhConnection.base_weight`
- `sheets.l23_cortex_exc.L4ExcL23ExcConnection.base_weight`

**Why five overrides.** The first smoke run used only the first four, keeping L4E→L2/3 (`receipts/ff-smoke.log.gz`, `ff-smoke-decoding.json`). Without any inhibition, layer 2/3 then fired near its ceiling during the gratings: 292 Hz on average for its excitatory cells and 555 Hz for its inhibitory cells, against 7.6 and 33 Hz intact. The zeroed feedback kept this away from the decoded layer 4. It still slowed the simulation about 3.7-fold, and it would have put a 60-step presentation near the memory limit. Zeroing L4E→L2/3 as well leaves layer 4's input unchanged and keeps layer 2/3 without input.

`check-overrides.json` shows the resolved weights of all fourteen projections in each condition, produced with Mozaik's own `load_parameters` and no network build. Every run's export also records the base weights and seeds the model was actually built with, and the analysis refuses a run whose values differ from its condition. Connections are still created, with zero weight. The LGN's temporal filters and gain control and the depression of LGN→L4 synapses stay intact, so this lesion isolates the cortical circuit, not all dynamics. Before this declaration, the two 16-step smoke runs (`ff-smoke.json`) checked that the lesioned network builds, responds and can be decoded:

- **Smoke run 1** (four overrides) exited normally after 1 h 47 min, at a peak of 5.8 GB.
  - Firing during the gratings:
    - layer 4: 47 Hz excitatory and 91 Hz inhibitory, against 6.9 and 25 Hz intact;
    - layer 2/3: near its ceiling, at 292 and 555 Hz.
  - The decoder chosen on the intact probe read layer 4 with a median error of 4.1° over the encoder's orientations (4.6° at 30 % contrast, 3.7° at 100 %), against 1.45° intact. All errors were within 22.5°, with 14 spikes per neuron per window.
- **Smoke run 2** (the declared five overrides) exited normally after 1 h 11 min, at a peak of 4.9 GB.
  - Layer 2/3 stayed silent.
  - Layer 4 and the LGN produced exactly the same spike trains as in smoke run 1, neuron by neuron: 1,669,566 layer 4 excitatory spikes in both (`ff-smoke-layer4-identity.json`). So the fifth override changes nothing for the decoded layer, and the decoder read it with the same 4.1° median error.
  - The simulation ran at about 184 s per simulated second, against 485 in smoke run 1 and 130 intact.

## Measures (`controller/decisions.py`)

For every run:

- **Accuracy:** the fraction of requests equal to the rule's request (the rule applied to s_t).
- **Errors:** the circular orientation error e_t = θ_t − (90° + 45°·s_t), wrapped to [−90°, 90°). Its mean and SD are given overall and in three signal bins: s ≤ −0.5, |s| < 0.5 and s ≥ 0.5.
- **History regression:** ordinary least squares ŝ_t = a + b·s_t + c·s_(t−1) over t = 1 … N−1. Here b is the gain and c the **carry-over**, meaning how much the previous input moves the current decision signal. The 95 % intervals of b and c come from a moving-block bootstrap: 2000 resamples, blocks of 5 steps, seed 17. Contrast depends only on |s|, so c cannot arise from contrast history alone. It needs a dependence on the previous orientation.
- **Decoding gate:** a run decodes if its accuracy is above the 95 % interval of its frozen baseline and the interval of b excludes 0.
- **Error null:** the run's own orientation errors, steps with no spikes included, are drawn independently with replacement within each signal bin, 2000 times. They are added to the presented orientation in angle space, so wrap-around behaves exactly as in the model. This is a relay whose errors depend on the input only through its signal bin and on nothing else. It gives 95 % intervals for accuracy, for c (with a two-sided p value) and for the lag-1 autocorrelation of the regression residuals.
- **Frozen baseline:** the run's decision signals permuted over steps, 2000 times. This is a response unrelated to the current input.
- **Executor:** rejections and the final simulated value. These are reported and never used as a criterion.
- **Secondary, reported only:** the extended regression ŝ_t = a + b·s_t + c·s_(t−1) + d·s_(t−2) + g·|s_(t−1)| + h·s_t·|s_(t−1)|, with bootstrap intervals. It shows lag-2 effects and effects of the previous contrast. The lag-1 residual autocorrelation is also reported against its null.

Pairs:

- **Lesion, intact-A against feedforward-only:** the paired differences in c, |c|, gain b and error SD. Each bootstrap resample is applied to both runs at the same steps.
- **Replication, intact-A against intact-B:** the agreement of the two runs' requests, compared with the agreement of two independent error-null relays built from each run's errors (2000 draws). The correlation of the two runs' regression residuals is also reported.
- **LGN identity:** for each pair of runs, the fraction of LGN neurons whose spike trains in the sequence are identical.

## Declared readings

**Material margin.** A carry-over below |c| = 0.10 is not material. At c = 0.10, a strong previous signal (|s| = 1) moves the current decision signal by 0.10, which is 40 % of the 0.25 request threshold.

**Carry-over, per intact run**, from the 95 % interval of c:

| Interval of c | Category |
| --- | --- |
| lies entirely beyond ±0.10 | material carry-over |
| excludes 0 and reaches beyond ±0.10, but not entirely | carry-over, size unresolved |
| excludes 0 and lies within ±0.10 | small carry-over |
| includes 0 and lies within ±0.10 | no material carry-over |
| includes 0 and reaches beyond ±0.10 | inconclusive |

**Primary reading:**

- **material carry-over:** both intact runs show "material carry-over", with the same sign;
- **carry-over:** both show "material carry-over" or "carry-over, size unresolved", with the same sign, and they are not both material;
- **no material carry-over:** both show "small carry-over" or "no material carry-over";
- **mixed or inconclusive:** anything else.

**Overall reading,** which sets what happens next:

| Condition | Reading | Next |
| --- | --- | --- |
| an intact run fails the decoding gate | **decoding failed:** "The fixed decoder does not recover the input from at least one intact run, so no reading applies." | a revised decoder under a new protocol |
| primary "material carry-over" | **dynamics:** "The circuit's dynamics carry information from one decision to the next by a material amount: its decisions are not a plain relay of the current input." | the controller stage continues, under new protocols |
| primary "carry-over" | **dynamics, size unresolved:** "The circuit's dynamics carry detectable information from one decision to the next, but its size is not shown to reach the declared margin." | a larger test of the size under a new protocol |
| primary "no material carry-over" | **no carry-over:** "At this timing the circuit shows no material linear carry-over of the previous input: any carry-over this test detects is below the declared margin of 0.10. Following the project plan, this controller design stops here." | this design stops |
| primary "mixed or inconclusive" | **inconclusive:** "Mixed or inconclusive: no fixed reading applies; reported as measured." | a larger test under a new protocol |

**Secondary readings,** reported with the primary one and never changing it:

- **Accuracy against the error null:** below, within or above its interval reads "its errors cost more / about as many / fewer decisions than errors drawn independently within each signal bin". The null keeps any dependence of the errors on the input at the level of the three bins, so this reading sees only structure within a bin, such as errors that push weak signals across a request threshold. A smooth distortion such as a lower gain can stay within it; the gain b and the per-bin mean errors are reported for that.
- **Lesion:** these readings apply only if both runs pass the decoding gate. For c, an interval that excludes 0 reads "more positive" or "more negative with intracortical connections". For |c|, it reads "larger" or "smaller". For gain and error SD, it reads "higher" or "lower". Otherwise the reading is "no detected change". Carry-over that survives the lesion is still carry-over of the model's dynamics, but most likely from the input stage (LGN filtering and gain control, LGN→L4 depression), not from the cortical circuit.
- **Replication:** agreement above the null means the two network instances share part of their errors. Their shared input is the stimulus and, if the LGN check shows identical trains, the same LGN noise. Within the null, they disagree as independent errors would. Below it, they disagree more.
- **Sign of c:** positive means decisions lean toward the previous input (attraction); negative means they lean away from it (repulsion). These data cannot say which mechanism produces either.

## Sample size

The rule was fixed, as code (`controller/plan_n.py`), before the probe's results existed. Its SHA-256 was recorded in the project handoff at 16:14 UTC on 23 October, when the probe was still running. The cap was lowered from 600 to 260 steps at 16:40 UTC, still before any decoding result existed. The probe's timing had just shown that a presentation's LGN input is computed and kept in memory: about 1.2 s per frame and 0.12 MB per frame. At 260 steps a run takes about 9 h, so the three runs take about a day. The probe's final memory reading (5.1 GB after 48 steps) then showed that even 260 steps in one presentation would exceed the 6.5 GB limit. `plan_n.py`'s docstring still records the earlier, optimistic estimate of about 6 GB; it was left unchanged so that its recorded hash stays valid. Hence the split into presentations of at most 100 steps, which keeps memory bounded without changing N.

1. Take the chosen decoder's orientation errors on the probe steps at the encoder's orientations (45° to 135°), at both contrasts.
2. σ_hat is their root mean square, which is at least their SD.
3. σ_e is the one-sided 95 % chi-square upper bound, σ_hat·√(n/χ²₀.₀₅(n)), with n the number of those steps.
4. N is the smallest multiple of 20, at least 120, whose projected 95 % half-width of c, 1.96·(σ_e/45°)/(0.577·√(N−1)), is at most 0.05. N is capped at 260 steps.
5. If the half-width at the cap is still above 0.07, a "no material carry-over" reading would be nearly unreachable. The design is then revised before freezing (decoder or encoder), and the revision is reported.

On the probe, the chosen decoder's RMS error over the 30 steps at the encoder's orientations is 2.37°, and its one-sided 95 % upper bound is 3.02°. The smallest allowed N, 120, already gives a projected half-width of 0.021, well within 0.05, so N = 120 (`sample-size.json`). The projection is slightly conservative (Monte Carlo by the pre-freeze review).

`simulate_null.py` reran the declared measures on simulated decoders whose errors are drawn from the probe's own errors (`error-pools.json`: 30 % contrast errors for |s| < 0.5, 100 % for the rest), with and without a carry-over (`null-simulation.json`). The results, over 400 simulated runs per case:

| Simulated carry-over | Single runs | Pairs of runs |
| --- | --- | --- |
| none | 94 % "no material carry-over", 6 % "small carry-over" | all "no material carry-over" |
| at the margin (c = 0.10) | all detected it | 86.5 % "carry-over" |
| twice the margin | all "material carry-over" | all "material carry-over" |

The mean width of the 95 % interval of c was 0.031.

A single run's 95 % interval of c excludes 0 somewhat more often than 5 % when there is no carry-over: about 6-7 % in simulation. The primary reading needs both instances to agree in sign. If their errors were independent, a false "carry-over" reading would stay near 0.2 % or less. Shared input, such as identical LGN noise, can correlate them and raise that rate toward the single-run rate. The LGN identity check and the residual correlation of the two instances are reported for this reason.

**Runtime.** About 4.5 h for each intact run and about 5.5 h for the feedforward-only run, one run at a time, so about 15 h for the three. Measured on the probe: about 1.2 s per frame to compute the LGN input (51 frames per step) and about 130 s of computing per simulated second (0.357 s per step), so roughly 110 s per step. On top of that come about 15 min to build the network and the NEST preparation and readout at each presentation.

## What this cannot show

- **Not the full model and no biological claim.** These are decisions of a reduced model with a declared encoder and decoder. They say nothing about cats making decisions.
- **One market, one timing, one encoder and decoder.** Another step timing (for example a shorter blank) could engage the dynamics differently. Any such test needs a new protocol.
- **One kind of history.** The primary measure is a linear dependence on the previous signal. Other dependence on the past appears only in the secondary measures and does not change the reading. "No carry-over" therefore means no material linear carry-over at this timing, not that the circuit has no memory.
- **Open loop.** Decisions do not feed back into the market or the stimuli.
- **No financial claim.** The market is synthetic and the P&L is simulated.
- **Separate questions.** Carry-over shows that the model's state links successive decisions. It does not show that the link is useful.

## Milestone 1 and the decoder choice (exploratory)

The probe presented 48 gratings: 8 orientations × 2 contrasts (30 % and 100 %) × 3 repeats, shuffled with seed 15. Each step had the same 210 + 147 ms timing as here, in one presentation. The only difference is the warm-up: the probe's was a separate 105 ms presentation, where here it is a 504 ms lead-in. Results (`probe-decoding.json`, figure `figures/probe-decoding.png`):

- The rule chose layer 4 excitatory neurons, balanced weights and the 40 to 300 ms window. Over the encoder's orientations its median absolute error is 1.45° (1.36° at 30 % contrast, 1.55° at 100 %), its error SD 2.3° and its largest error 5.6°.
- Balanced weights beat raw ones (best raw: 3.3°) and the central-neuron variant (best: 3.6°).
- Layer 2/3 alone decodes less precisely (best: 3.3°, SD 5.6°).
- The run took 2 h 15 min and peaked at 5.5 GB.
- Mean rates during the gratings: 6.9 Hz (L4E), 25.3 Hz (L4I), 7.6 Hz (L2/3E) and 33.1 Hz (L2/3I), with the LGN at 46.5 Hz (ON) and 36.7 Hz (OFF).

The circuit therefore passes on the grating's orientation almost exactly at this timing. That makes small carry-over effects measurable, and it also means a relay-like result would be no surprise.

The selection rule was written into `analyze_probe.py` before its results were read. The file was last edited at 15:56:55 UTC to add lead-in support, which does nothing for the probe's export. Its SHA-256 (`8e42f776…`) was recorded at 16:13:48 UTC, when the probe export did not exist yet.

1. Consider only causal decoders, which use no later steps.
2. Take the one with the lowest median absolute error over the encoder's orientations (45° to 135°).
3. Among variants within 1° of the best, prefer, in order:
   - raw over balanced over centre weights;
   - fewer layers;
   - a window starting at 40 ms.

The probe output is `probe-decoding.json`.

## Changes from the approved spec, made before freezing

- **Engine:** the 2 mm reduction of the published model replaces Mozaik's tiny test configuration, which saturates at about 300 Hz.
- **Lesion:** the feedforward-only condition zeroes L4E→L2/3 as well, as explained above.
- **Stimulus timing:** each grating lasts 210 ms (30 frames), not 200 ms, and is followed by a 147 ms blank. The sequence is shown in a few long presentations of at most 100 steps, because a presentation per step cost about 950 s per step. The warm-up is a lead-in inside the first presentation.
- **Market:** an i.i.d. market replaces the drifting-regime market, so that any dependence on the previous signal can only come from the pipeline.
- **Baselines:**
  - The "matched noise" baseline is an error null of the run's own orientation errors, resampled within signal bins in angle space.
  - The frozen baseline is a permutation of decision signals.
  - The disconnected baseline of the plan is covered by the frozen one, a response unrelated to the current input.
- **Decoder:** chosen by the probe's pre-written rule instead of being fixed to layer 2/3 E.
- **After the first pre-freeze review:**
  - the error null works in angle space within three signal bins split by sign, with missing steps kept;
  - the decoding gate;
  - the fifth carry-over category and the size-unresolved readings;
  - the lesion's gate and unsigned |c| reading;
  - the secondary history measures and the LGN identity check;
  - the analysis refuses mislabelled runs, changed inputs, a missing run or a failed replay;
  - the replay recounts spikes independently and checks the written log;
  - seeds are fixed per run name;
  - the sample-size rule was fixed before computing;
  - the feedforward-only smoke runs;
  - corrected statements about adaptation and the seeds.
- **After the second pre-freeze review:**
  - a single stop reading, "no carry-over", replaces "relay" and "static", because the error null keeps the errors' dependence on the input at the level of the signal bins;
  - accuracy against that null is a secondary, accurately worded reading;
  - the sample-size rule gained a chi-square bound and a revise condition. Its cap moved from 300 to 600, then to 260 once the cost of the LGN input was known, all before the probe results;
  - error pools by contrast for `simulate_null.py`, built by `plan_n.py`;
  - `decoder.json` is built by `make_decoder.py`;
  - the analysis refuses a separate warm-up and checks the contract and its own code against the frozen manifest;
  - a test feeds the output of `make_contract.py` into the analysis;
  - the false-reading claim is conditional on independent instances, and the residual correlation is reported;
  - after the probe's timing became known: presentations of at most 100 steps, with Mozaik's per-run input cache cleared between them (`run_controller.py`); our stimuli never repeat, so this changes only memory. The analysis refuses presentations that differ from the declared split.
- **After the third pre-freeze review:**
  - the "no carry-over" text says that any carry-over the test detects is below the margin;
  - the freeze checks the staged package completely before copying it;
  - the analysis refuses a contract without a manifest;
  - a test ties the server's presentation split to the analysis's;
  - the layer 4 identity check across the two smoke runs;
  - stale text was corrected.

## Order of work

1. The milestone-1 probe and the decoder choice (23 Oct).
2. The two feedforward-only smoke runs (23 Oct).
3. This declaration and `contract.json`, three pre-freeze reviews and the freeze, with SHA-256 recorded in the project handoff.
4. Upload the frozen files to the server and check their hashes there.
5. The three runs, one at a time: intact-A, intact-B, then feedforward-only.
6. `analyze_decisions.py contract.json` on the three exports, unchanged.

The results go into a separate package that records this protocol's hash.

## Files

- `README.md`: this declaration.
- `contract.json`: parameters, commands, expected resolved weights, readings and the SHA-256 of `sequence.json` and `decoder.json`. The analysis checks these before it runs.
- `controller/`, with its tests:
  - `pipeline.py`: encoder, decoder, executor, log and replay;
  - `decisions.py`: measures and readings;
  - `analyze_decisions.py`: the analysis;
  - `make_sequence.py`, `make_decoder.py` and `plan_n.py`;
  - `simulate_null.py`.
- `server/`:
  - `controller_experiments.py`: the sequence stimulus;
  - `run_controller.py`: run and export;
  - `run_milestone2.sh`: the three runs;
  - `run_ff_smoke.sh` and `run_ff_smoke2.sh`: the two smoke runs (four, then the declared five overrides);
  - `check_overrides.py`.
- `sequence.json` (the declared market and stimulus sequence) and `decoder.json` (the fixed decoder).
- Evidence and inputs:
  - `check-overrides.json` and `reduction-check.json`;
  - the probe: `probe-decoding.json` and `analyze_probe.py`;
  - the smoke runs: `ff-smoke.json` (their sequence), `ff-smoke-decoding.json` (four overrides), `ff-smoke-2-decoding.json` (the declared five), `ff-smoke-layer4-identity.json` (layer 4 and the LGN compared across the two), `analyze_ff_smoke.py` and `compare_smoke_l4.py`;
  - the sample size: `sample-size.json`, `error-pools.json` and `null-simulation.json`;
  - `server-files-sha256.txt` (the model, parameter and recorder files on the server) and `make_contract.py`;
  - `data-sha256.txt`: the large spike exports of the probe and the smoke runs, kept outside the package on the research server and in our working copy.
- `server/rec/`: the recorder files that replace the published ones (spikes of every neuron).
- `probe-code/`: the server code exactly as the probe ran it (its warm-up was a separate presentation; the lead-in and chunking came later).
- `receipts/`: the logs of the probe and of both smoke runs.
- `figures/`: `draw_probe.py` and the probe figure.
- `manifest.json` and `protocol-evidence.zip`.

## Attribution

**Model.** Antolík J, Cagnol R, Rózsa T, Monier C, Frégnac Y, Davison AP (2024), *A comprehensive data-driven model of cat primary visual cortex*, [PLOS Computational Biology](https://doi.org/10.1371/journal.pcbi.1012342), published under [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/). LSV1M v1.0 is under its MIT license. Mozaik v0.4.0 (CeCILL), PyNN 0.11.0 and NEST 3.4 are as pinned in protocol 006. The 2 mm reduction and all runs are ours.

**Pipeline.** The market, encoder, decoder and executor are Felisyn's own engineering choices.
