Datasets:

parti-wave
/

N4_slice

---
license: mit
task_categories:
  - time-series-forecasting
  - other
tags:
  - resonance-graph-core
  - rgc
  - tau-universe
  - tav-topology
  - logistic-map
  - fpga
  - arty-a7
  - hierarchical-lattice
  - period-3
  - berard
  - session-log
pretty_name: 30-Day Canonical Tav RGC N4 Lattice & Telemetry Slices
size_categories:
  - 10M<n<100M
configs:
  - config_name: lattice
    default: true
    data_files:
      - split: train
        path: "n4_slice_*.csv"
  - config_name: data_manifest
    data_files:
      - split: train
        path: "manifests/slice_manifest.csv"
  - config_name: prospect_map
    data_files:
      - split: train
        path: "manifests/prospect_manifest.csv"
  - config_name: log_manifest
    data_files:
      - split: train
        path: "n4_log_slices/log_slice_manifest.csv"
  - config_name: log_prospect_map
    data_files:
      - split: train
        path: "n4_log_slices/log_prospect_manifest.csv"
---
# 30-Day Canonical Tav RGC N4 Lattice & Telemetry Slices

**253 prospect-named windows · `parti-wave/N4_slice`**
**Resonance Graph Core (RGC) v0.2 · 49-core logistic substrate · paired data & session logs**
This dataset contains **253 overlapping time windows** cut from a continuous 30-day logistic-map characterization run of a 49-core Resonance Graph Core (RGC) on a Digilent Arty A7-100T FPGA, **plus** the matching windows from the companion session log.
Each data slice and each log slice carries the **same unique prospect name**.
> **Read first — three packaging caveats.** A full-corpus audit (v2 card revision) found that slice boundaries are **not** frame-aligned, and that prospect-name pairing between the two streams is **nominal rather than temporal**. The measurements themselves are clean and independently corroborated, but both facts change how you should load the data. See [Row ordering and frame reconstruction](#row-ordering-and-frame-reconstruction), [Prospect-name pairing](#prospect-name-pairing-is-nominal-not-temporal), and [Acquisition clock](#acquisition-clock--read-before-doing-spectral-analysis). Full list in [Errata](#errata-v2-card-revision).
---
## Source run
| Field | Value |
|-------|--------|
| Data source | `logistic_20260606_145947.csv` (1,283,133,318 B) |
| Log source | `rgc_session_20260606_145947.log` (836,807,837 B) |
| Architecture | RGC v0.2, 49-core circular + hierarchical lattice |
| Platform | Digilent Arty A7-100T (Xilinx Artix-7) |
| Dynamics | Logistic map, Q1.23 fixed-point; parameter region includes the period-3 (Sharkovskii) window |
| Cores per lattice frame | 49 |
| Start | 2026-06-06 T 14:59:47.797787 UTC |
| End | 2026-07-06 T 14:59:48.294118 UTC |
| Duration | 2,592,000.496 s = **30.00001 days**, continuous |
The hardware executes an asynchronous, clockless wavefront that settles into a lattice-loll attractor. Core 32 exhibits a clean period-3 orbit in the relevant regime — verified in this corpus as **bit-exact** in Q1.23 (median `|x[k] − x[k−3]| = 0`). Hierarchical coherence (microscopic 7-rings → super-ring of 7 groups) is a primary observable.

The **Berard monitor** (≈ 1.054 scale) is a *state monitor*, not a generative parameter of the logistic substrate. Under normal cold-start conditions the lattice locks to an "excellent" Berard condition; host resource sequestration degrades it to "good"; complete UART-bridge loss (as at the end of N3) produced the poorest reading. Session-log windows therefore carry the external context that explains Berard score variation.

Companion characterizations and the RGC architecture whitepaper are on Zenodo (see **Citation**).

---

## Dataset overview and row accounting

| Quantity | Value |
|---|---|
| Rows in the `lattice` subset | **29,351,992** |
| Unique rows in the source run | **18,143,975** |
| Duplication from slice overlap | 11,208,017 (**61.8%**) |
| Complete 49-core frames | 370,285 (+ one partial: 18,143,975 = 49 × 370,285 + 10) |

The Hub banner figure of 29,352,498 is the sum across converted subsets (`lattice` + `log_manifest` 253 + `log_prospect_map` 253). **The 29.35M figure is not an independent sample count** — treat **18,143,975** as the number of distinct observations. The final frame of the run is inherently partial: the source ends at `n = 18,143,974`, `core_id = 9`.

---

## What is included

| Stream | Files | Slice size (approx.) | Overlaps |
|--------|--------|----------------------|----------|
| **Lattice data** | `n4_slice_XXX_<Prospect>.csv` | ~6–8 MB | ≈1.5 MiB lead + ≈1.5 MiB trail (interior) |
| **Session log** | `n4_log_slices/n4_log_XXX_<Prospect>.log` | ~4.9–6.5 MB | ≈1.5 MiB lead + ≈1.5 MiB trail (interior) |

- **253** windows per stream
- Slice 000: no leading overlap
- Slice 252: no trailing overlap
- Identical prospect names on both streams — but see [Prospect-name pairing](#prospect-name-pairing-is-nominal-not-temporal) before joining on them

---

## Data schema (CSV slices)

| Column | Type | Range | Description |
|--------|------|-------|-------------|
| `timestamp_iso` | string | 26 chars | Host wall-clock timestamp of the sample (UTC, µs resolution) |
| `elapsed_sec` | float | 0.161 – 2,592,000.657 | Seconds since run start (ms resolution) |
| `core_id` | int | 0 – 48 | Core index. **Always equals `n % 49`** |
| `x_raw24` | int | 0 – 8,388,607 | **Authoritative** logistic state, raw Q1.23 fixed-point. Value = `x_raw24 / 2²³` |
| `x_norm` | float | 0.0 – 1.0 | Convenience rendering of `x_raw24`, **lossy** — see note |
| `n` | int | 0 – 18,143,974 | **Global row counter**, increments by exactly 1 per row. Frame index is `n // 49` |
| `delta_n` | int | 49 | Δ`n` between consecutive readouts of the *same* core. Null only on the first 49 rows of the run |

Files are CRLF-terminated with a 60-byte header repeated at the top of every slice (self-describing).

### `x_raw24` is primary; `x_norm` is derived and lossy

`x_norm == round(x_raw24 / 2²³, 6)` on all 29,351,992 rows without exception. Six decimal places discards roughly three of the 23 bits (hardware quantum 1.19×10⁻⁷ vs 10⁻⁶ print resolution). **Use `x_raw24` for anything precision-sensitive** — Lyapunov exponents, period detection, return maps, symbolic dynamics.
Two consequences of that rounding, both expected:
- 6,608 rows read `x_norm = 0.000000` — true zeros (`x_raw24 = 0`, collapsed core).
- 2,209 rows read `x_norm = 1.000000` — these are `x_raw24 = 8,388,607 = 2²³−1` rounded up at 6 dp, **not** a true 1.0. The state never reaches 1.
The stored range of `x_norm` is therefore the closed interval `[0.0, 1.0]`, not the open interval `(0, 1)`. 11,025 rows sit on the endpoints.
### `n` is a row counter, not a frame index
Earlier revisions of this card described `n` as a "global iteration / frame index"; that was wrong. `n` advances by 1 per row, `core_id == n % 49`, and the frame index is `n // 49`. `delta_n = 49` is consistent with this: the same core recurs every 49 rows.
---
## Row ordering and frame reconstruction
Rows are ordered by increasing `n`, and `core_id` cycles `0 … 48` in lockstep (`core_id == n % 49`, verified with zero exceptions across all 29,351,992 rows). A complete lattice frame is the set of 49 rows sharing a value of `n // 49`.
> ### ⚠️ Slice boundaries are NOT frame-aligned
>
> Earlier revisions claimed *"frame-aligned cuts (multiples of 49 data rows) so a lattice snapshot is never split mid-frame."* **This is not true of the published slices.** A full audit found:
>
> | | Count |
> |---|---|
> | Slices beginning at `core_id == 0` | 6 / 253 |
> | Slices ending at `core_id == 48` | 3 / 253 |
> | Slices with row count divisible by 49 | 28 / 253 |
> | Slices satisfying all three | **0 / 253** |
>
> Starting `core_id` for the first twelve slices: `[0, 48, 13, 37, 12, 36, 9, 34, 8, 33, 48, 12]` — effectively arbitrary phase, differing per slice. Cause: the slicing script counted rows from a byte offset with arbitrary phase relative to the file's frame grid.
>
> **No data is lost.** `core_id` and `n` are present on every row, so frames are fully recoverable. But **`values.reshape(-1, 49)` will silently mislabel every core**, with a *different* rotation in each slice. On slice 126 (`Period3Gamma`), reshape column 32 holds core **46**, not core 32.

**Correct frame reconstruction — group on `n // 49`, index by `core_id`:**
```python
import pandas as pd
def frames(path, value="x_raw24"):
    """(frames × 49) table: index = n // 49, columns = true core_id 0…48."""
    df = pd.read_csv(path, usecols=["core_id", "n", value])
    df["frame"] = df["n"] // 49
    counts = df.groupby("frame")["core_id"].size()
    df = df[df["frame"].isin(counts[counts == 49].index)]   # drop partial edge frames
    return df.pivot(index="frame", columns="core_id", values=value).sort_index()
```
Each slice loses at most one partial frame at each edge. Sanity check on `Period3Gamma`:
```
frames = 2369, cores = 49
core 32: 0.497221 → 0.958304 → 0.153171 → 0.497221 → …
  median |x[k] − x[k−3]| = 0.00e+00      ← period-3, bit-exact in Q1.23
  median |x[k] − x[k−1]| = 4.61e-01
```
---
## Slicing methodology and overlap
### Data (`slice_n4_run.py`)
- Byte-range cuts of the source CSV; every slice begins with the original 60-byte header (self-describing)
- Cuts are **not** frame-aligned — see the warning above

### Log (`slice_n4_log.py`)
- Line-aligned cuts (log lines never split) — verified at all 252 boundaries
- Pure text ranges; no synthetic header

### Overlap

Interior windows carry ≈1.5 MiB of context on each side. Measured, the two sides are consistently asymmetric because boundaries round forward to the next row/line:

| Stream | Lead overlap | Trail overlap |
|---|---|---|
| Data | 1,570,235 – 1,572,511 B (always < 1.5 MiB) | 1,573,137 – 1,575,499 B (always > 1.5 MiB) |
| Log | 1,572,820 – 1,572,864 B | 1,572,864 – 1,572,908 B |

Overlap regions between adjacent slices are byte-identical (verified at all 252 boundaries on both streams), so the full source is losslessly reconstructible from the slices.

**Manifests**

- `manifests/slice_manifest.csv` — data byte ranges & overlaps
- `manifests/prospect_manifest.csv` — data index → prospect name
- `n4_log_slices/log_slice_manifest.csv` — log byte ranges & overlaps
- `n4_log_slices/log_prospect_manifest.csv` — log index → prospect name
- `manifests/slice_n_index.csv` — `n` range of every slice on both streams (joins data ↔ log; see [Joining the two streams on n](#joining-the-two-streams-on-n))

---

## Prospect-name pairing is nominal, not temporal

Data slice *k* and log slice *k* share a prospect name, but **they do not cover the same window of the run.** Measured overlap of their `n` ranges across all 253 pairs:

| | Value |
|---|---|
| Median IoU | **0.242** |
| Pairs with IoU < 0.25 | 129 / 253 |
| Pairs with IoU < 0.10 | 74 / 253 |
| Worst pair (slice 097) | 0.026 |
| Maximum lead of log over data | 133,518 frames ≈ **5.3 h** wall clock |

The drift is V-shaped — pinned at zero at both ends (both streams start at `n = 0` and end at `n = 18,143,974`) and worst mid-run:

| Slice range | Median IoU | Median offset (frames) |
|---|---|---|
| 000–024 | 0.544 | −48,519 |
| 050–074 | 0.185 | −99,727 |
| **100–124** | **0.028** | −132,868 |
| **125–149** | **0.033** | −131,755 |
| 175–199 | 0.301 | −81,019 |
| 225–252 | 0.79 | −28,000 |

**Cause.** Both streams were cut into 253 *equal-byte* pieces, but their bytes-per-frame differ over the run: CSV row width grows steadily (`elapsed_sec` 5 → 11 chars, `n` 1 → 8 digits) while log line width is essentially fixed. Equal byte fractions therefore land on different frame indices.

Example — `Period3Gamma` (slice 126):

```
data  n[9,134,300 … 9,250,428]
log   n[9,002,086 … 9,141,996]     → only 6.6% of the data window has log context
```

**Guidance.** Do not assume a paired log slice describes the host state during its data slice. **Join on `n`** (every log frame carries it), not on the file index. Near the ends of the run (slices ≲ 025 and ≳ 225) the windows do largely coincide; mid-run they barely intersect.

### Joining the two streams on `n`

`manifests/slice_n_index.csv` — rather than re-cut the log stream, the repository ships an index of the `n` range covered by every slice on both streams — 506 rows (253 data + 253 log), ~50 KB.

| Column | Description |
|---|---|
| `stream` | `data` or `log` |
| `slice_idx` | 0 – 252 |
| `prospect` | Prospect name |
| `file` | Path within this repository |
| `n_first`, `n_last` | Inclusive `n` range the slice covers |
| `n_span` | `n_last − n_first + 1` |
| `source_start_byte`, `source_end_byte` | Byte range in the original source file |

`scripts/logs_for_window.py` uses it to return the log slices that actually cover a given data window, ordered by how much of it each one covers:

```python
from logs_for_window import logs_for
meta, covering = logs_for(97)
```

```text
data slice 097 SevenfoldBeta  n[7,055,762 .. 7,171,891]  (116,130 frames)
  same-name log slice 097 alone covers 5.5% of it
  covering set (4 slices):
    log 099 CylinderBeta     n[7,065,656 .. 7,205,630]  covers  91.5%
    log 098 S1Beta           n[6,993,943 .. 7,133,904]  covers  67.3%
    log 100 TauGamma         n[7,137,413 .. 7,277,343]  covers  29.7%
    log 097 SevenfoldBeta    n[6,922,244 .. 7,062,147]  covers   5.5%
```

**Every data slice is fully covered by some set of log slices** — verified for all 253, typically 3–4 slices each. Nothing is missing from the corpus; the two streams were only ever indexed against each other incorrectly. The `frac_of_data_window` column makes thin host context visible rather than silent, which a one-to-one re-cut would not.

---

## Naming convention

```text
n4_slice_XXX_<ProspectName>.csv
n4_log_slices/n4_log_XXX_<ProspectName>.log
```

Prospect names are deterministic and unique. Fifty themed stems cycle through the modifiers **Alpha → Beta → Gamma → Delta → Epsilon → Zeta**.

### Complete prospect map

| Index | Prospect stem (shared by data & log) |
|------:|--------------------------------------|
| 000 | TauAlpha |
| 001 | TavAlpha |
| 002 | BerardAlpha |
| 003 | LatticeAlpha |
| 004 | LollAlpha |
| 005 | WavefrontAlpha |
| 006 | ResonanceAlpha |
| 007 | CoreAlpha |
| 008 | RingAlpha |
| 009 | FluxAlpha |
| 010 | PhaseAlpha |
| 011 | OrbitAlpha |
| 012 | TongueAlpha |
| 013 | StaircaseAlpha |
| 014 | KuramotoAlpha |
| 015 | JosephsonAlpha |
| 016 | PhotonicAlpha |
| 017 | SQUIDAlpha |
| 018 | GenomeAlpha |
| 019 | AdapterAlpha |
| 020 | MythosAlpha |
| 021 | EtymosAlpha |
| 022 | BoxMatchAlpha |
| 023 | EllaAlpha |
| 024 | LillyAlpha |
| 025 | SharkovskiiAlpha |
| 026 | Period3Alpha |
| 027 | Mod7Alpha |
| 028 | HeartbeatAlpha |
| 029 | 142857Alpha |
| 030 | RadionAlpha |
| 031 | CompactAlpha |
| 032 | HierarchyAlpha |
| 033 | SupermodeAlpha |
| 034 | CirculantAlpha |
| 035 | ArnoldAlpha |
| 036 | DevilAlpha |
| 037 | SplayAlpha |
| 038 | ChimeraAlpha |
| 039 | OrderRAlpha |
| 040 | CoherenceAlpha |
| 041 | AttractorAlpha |
| 042 | HandshakeAlpha |
| 043 | AsyncAlpha |
| 044 | Q123Alpha |
| 045 | ArtyAlpha |
| 046 | MetaRingAlpha |
| 047 | SevenfoldAlpha |
| 048 | S1Alpha |
| 049 | CylinderAlpha |
| 050–099 | Same stems + **Beta** |
| 100–149 | Same stems + **Gamma** |
| 150–199 | Same stems + **Delta** |
| 200–249 | Same stems + **Epsilon** |
| 250 | TauZeta |
| 251 | TavZeta |
| 252 | BerardZeta |

Example pairing:

```text
n4_slice_032_HierarchyAlpha.csv  ↔  n4_log_slices/n4_log_032_HierarchyAlpha.log
n4_slice_252_BerardZeta.csv      ↔  n4_log_slices/n4_log_252_BerardZeta.log
```

---

## Session log format and reassembly specification

Each log line is one host `read()` from the serial bridge, **not one frame**:

```text
[HH:MM:SS.mmm] len=<bytes>  <hex payload>
```

A frame is 10 bytes:

| Offset | Size | Field |
|---|---|---|
| 0 | 2 B | magic `0x1E30` |
| 2 | 1 B | `core_id` |
| 3 | 3 B | `x_raw24`, big-endian Q1.23 |
| 6 | 4 B | `n`, big-endian |

**Frames can straddle two lines.** Of 35,355,673 lines, 99.07% are `len=10` (one frame), but 329,461 are partial reads of 1–9 bytes. **Parsing line-by-line silently drops ~0.47% of frames.** Correct procedure: concatenate the hex payloads across lines, then split the resulting byte stream on 10-byte boundaries, validating the `0x1E30` magic.

103 lines with `len > 32` have their hex payload truncated with a trailing `...` and are not recoverable. Their timestamps and `len` values are intact, which is what bridge-health analysis needs. Larger `len` values indicate the host fell behind and the driver returned a batch — useful as a bridge-stall indicator. Burst sizes run up to `len=480` (48 frames).

Log timestamps carry time-of-day only, with no date; across a 30-day run they wrap daily. Use `n` for absolute positioning.

The log independently corroborates the CSV: 100,000 frames decoded from the raw log and matched by `n` produced **zero** `core_id` or `x_raw24` mismatches.

---

## Acquisition clock — read before doing spectral analysis

These are **configuration facts about the readout schedule**, not properties of the lattice:

- Mean inter-core readout interval: **0.1428574 s** — that is 1/7 s to within 1.4×10⁻⁶.
- One complete 49-core frame every **7.0000 s**.
- Run terminated at exactly **30.00000 days**.

Sampling is also **non-uniform**. The inter-row Δt distribution is bimodal: ≈75% at 0.163 s and ≈25% at 0.082 s — one or two ticks of a ≈0.0815 s host quantum — with the mean landing on 1/7 s.

**Analytical consequences:**

1. **Any wall-clock spectral analysis of this dataset will show structure at 7 s, 1/7 Hz, and their harmonics that originates in the readout schedule, not the lattice.** Because the framework this dataset supports treats a 1/7 signature as a substantive prediction, a temporal 1/7 result obtained from this data is confounded by construction and should not be presented as evidence.
2. An FFT assuming uniform sampling at the mean rate will produce spurious lines from the 0.0815 s quantum beating against the 7 s frame period.

**Recommendation:** conduct period-3 / Sharkovskii / Arnold-tongue / return-map work in **iteration index `n`**, where the acquisition clock drops out entirely. The core-32 period-3 orbit is exact in iteration space (bit-exact residual in Q1.23) and is unaffected by any of this.

---

## Intended use

- Cross-slice studies of period-3 persistence (especially core 32)
- Hierarchical order-parameter and Berard-monitor analysis
- Correlation of lattice coherence with host/bridge state from the paired log
- Mapping onto photonic, Kuramoto / Stuart–Landau, and Josephson / SQUID embeddings
- Arnold-tongue / Devil's-staircase and higher-order Kuramoto investigations
- Reproducible windowed statistics without loading the full multi-GB sources

Interior overlaps support continuous observables (ACF, rotation number, coherence) across boundaries with minimal edge artefact.

> All of the above should be conducted in **iteration index `n`** rather than wall-clock time (see [Acquisition clock](#acquisition-clock--read-before-doing-spectral-analysis)), and frames should be reconstructed by grouping on `n // 49` rather than by row position (see [Row ordering and frame reconstruction](#row-ordering-and-frame-reconstruction)). Where an analysis needs host/bridge context from the paired session log, join on `n` rather than on prospect name (see [Prospect-name pairing](#prospect-name-pairing-is-nominal-not-temporal)).

---

## Repository layout

```text
├── README.md
├── manifests/
│   ├── slice_manifest.csv
│   ├── prospect_manifest.csv
│   └── slice_n_index.csv          ← n-range index for both streams
├── scripts/
│   ├── logs_for_window.py         ← data ↔ log join helper
│   ├── slice_n4_run.py
│   ├── slice_n4_log.py
│   ├── name_n4_slices.py
│   └── name_n4_log_slices.py
├── n4_slice_000_TauAlpha.csv
├── n4_slice_001_TavAlpha.csv
├── …
├── n4_slice_252_BerardZeta.csv
└── n4_log_slices/
    ├── log_slice_manifest.csv
    ├── log_prospect_manifest.csv
    ├── n4_log_000_TauAlpha.log
    ├── …
    └── n4_log_252_BerardZeta.log
```

---

## Errata (v2 card revision)

Corrections to earlier revisions of this card, from a full-corpus audit (29,351,992 CSV rows and 35,355,673 log lines checked exhaustively, nothing sampled):

1. **Frame alignment.** The claim that cuts fall on 49-row frame boundaries is withdrawn. 0 of 253 slices are frame-aligned. Use `n // 49` grouping; never `reshape(-1, 49)`.
2. **Prospect-name pairing.** Matching names indicate *nominal* pairing only. Median data/log window IoU is 0.242. Join on `n`.
3. **`delta_n`.** Previously described as "mostly null". It is populated on 29,351,943 of 29,351,992 rows (99.9998%), always exactly 49. There are exactly **49** nulls, all in the first frame of slice 000.
4. **`n` semantics.** A per-row counter, not a frame index.
5. **`x_norm` range.** `[0.0, 1.0]` as stored, not the open interval `(0, 1)`; and it is a lossy 6-dp rendering of `x_raw24`.
6. **Row count.** `lattice` holds 29,351,992 rows, of which 18,143,975 are distinct.
7. **Run duration.** 30.00001 days, not a single-date run.
8. **`n4_log_162_TongueDelta.log`** was missing from the repository; restored and verified (size exact, overlap regions byte-identical to neighbours, 0 unparsed lines).
9. **Manifest config paths.** The `data_manifest` and `prospect_map` configs pointed at repository root; the files live under `manifests/`. Corrected — those two subsets should now convert.
10. **Stream joining.** `manifests/slice_n_index.csv` and `scripts/logs_for_window.py` were added so the two streams can be joined on `n`. The previously planned re-cut of the log slices is unnecessary — the index supersedes it.
Verified clean in the same audit: header consistency across all 253 CSVs; manifest arithmetic on all 506 entries; byte-identical overlaps at every boundary on both streams; `core_id` stepping +1 mod 49 with zero breaks; exact Q1.23 reconstruction; contiguous `n` coverage 0 → 18,143,974 with no gaps; zero NaNs, zero duplicate rows, zero duplicate `(n, core_id)`; monotonic `n`, `elapsed_sec` and timestamps in every slice; and exact CSV ↔ session-log agreement across 100,000 cross-checked frames.
---
## Citation
```bibtex
@misc{gatlin_rgc_2026,
  author       = {Gatlin III, Ernest C.},
  title        = {Resonance Graph Core (RGC) Architecture:
                  An Asynchronous Hardware Embodiment of the Tav Manifold},
  year         = {2026},
  publisher    = {Zenodo},
  doi          = {10.5281/zenodo.20111854},
  url          = {https://doi.org/10.5281/zenodo.20111854}
}
```
To cite this dataset specifically:
```bibtex
@dataset{gatlin_n4slice_2026,
  author       = {Gatlin III, Ernest C.},
  title        = {30-Day Canonical Tav RGC N4 Lattice \& Telemetry Slices},
  year         = {2026},
  publisher    = {Hugging Face},
  doi          = {10.57967/hf/10015},
  url          = {https://huggingface.co/datasets/parti-wave/N4_slice}
}
```
Related long-run characterizations (1.2 M–4 M frames) are deposited on Zenodo under the Tau Universe / RGC series.
---
## License & contact
Research use under the terms associated with Parti-Wave Labs USA, LLC and the Zenodo deposits referenced above.
For collaboration or licensing: claygatlin@gmail.com · Parti-Wave Labs USA, LLC (Alabama).
**Note:** The Berard Constant / monitor (≈ 1.054) evaluates the quality of the collective lattice state. It is not hard-coded into every cell update of the logistic substrate. Slice-level Berard readings will vary with host resources and bridge health of the original run; the paired session-log windows are provided so that variation can be interpreted — subject to the pairing caveat above.