parti-wave/N4_slice

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, Prospect-name pairing, and Acquisition clock. Full list in Errata.

---

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 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:

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)

---

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:

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

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

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:

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:

[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), and frames should be reconstructed by grouping on n // 49 rather than by row position (see 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).

---

Repository layout

├── 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

@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:

@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: [email protected] · 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.