Upload 2 files

README.md

@@ -1,3 +1,5 @@
----
-license: mit
----
+On "all 2^39 patterns" — any explicit file is infeasible (minimum ~2.75 TB). The correct answer is: the pattern space is [0, 2^39). A stream_all_patterns() generator is included that yields every pattern on-demand with zero memory overhead — decode pattern k directly from integer k without storing anything.
+
+**In short**: use `TopoDevPOC_n39.py` if you dont want unnessesary file saved on your disk. And use `TopoDevPOC_n39_save.py` if you want to store every pattern on to CSV format with a total of 2.75 TB file. 
+
+**Tip**: there is no need to store 549755813888 patterns externally since it can be generated on-demand using the generator function. 

TopoDevPOC_n39_save.py

@@ -0,0 +1,592 @@
+#!/usr/bin/env python3
+"""
+TopoDevPOC_n39.py
+Topologically Unique Developing Point of Control Patterns
+Pre-market K-Lines, n = 39 three-minute candlesticks
+
+Paper : TopoDevPOC.tex  (ConQ Research Team, Continual Quasars)
+Compute: Vectorized NumPy + GPU Torch (T4) + Warp branchless ops
+         Architectural patterns from core_engine_v11.py (Hyper-Warp Edition)
+
+Outputs (CLI):
+  1. Total combination count for n=39
+  2. Matrix state-transition validation
+  3. 100 random ternary matrices  (1×38 each)
+  4. 100 random symbolic sequences (length-38 strings)
+  5. 100 developing_poc charts saved as PNG + ASCII CLI preview
+  6. CSV export — bit-packed uint64 pattern_id (39-bit encoding, min bytes)
+  7. Binary export — raw .npy uint64 array (fastest machine read)
+
+COMPRESSION SCHEME:
+  Each pattern encodes into a single uint64 (8 bytes):
+    bit  0      : direction  (0=Bullish, 1=Bearish)
+    bits 1..38  : transitions (1=strict, 0=equality)
+  Decode: direction = id & 1;  trans[k] = (id >> (k+1)) & 1
+  Full matrix + direction reconstructed from one integer in O(1).
+  Entire 2^39 space = integers [0, 2^39). No file required for enumeration.
+
+Run on Google Colab T4:
+    !python TopoDevPOC_n39.py
+"""
+
+# ── stdlib ────────────────────────────────────────────────────────────────────
+import os, sys, time, math, csv, struct
+import numpy as np
+
+# ── matplotlib (non-interactive for Colab CLI) ────────────────────────────────
+import matplotlib
+matplotlib.use('Agg')
+import matplotlib.pyplot as plt
+import matplotlib.ticker as mticker
+
+# ── GPU setup (T4 Colab) ─────────────────────────────────────────────────────
+try:
+    import torch
+    HAS_CUDA = torch.cuda.is_available()
+    DEVICE   = 'cuda' if HAS_CUDA else 'cpu'
+except ImportError:
+    HAS_CUDA = False
+    DEVICE   = 'cpu'
+    torch    = None
+
+# Optional Warp (core_engine_v11.py pattern) ─────────────────────────────────
+HAS_WARP = False
+try:
+    import warp as wp
+    wp.init()
+    wp.set_module_options({"enable_backward": False, "fast_math": True, "max_unroll": 8})
+    HAS_WARP = bool(wp.get_cuda_devices())
+except Exception:
+    pass
+
+# ─────────────────────────────────────────────────────────────────────────────
+# CONSTANTS  (tex Section II)
+# ─────────────────────────────────────────────────────────────────────────────
+N         = 39          # pre-market 3-min candles  (C_0 … C_{-(n-1)})
+N_TRANS   = N - 1       # 38 adjacent-pair relations
+N_SAMPLES = 100
+SEED      = int(time.time() * 1000) & 0x7FFFFFFF
+
+SEP = "=" * 74
+
+# ─────────────────────────────────────────────────────────────────────────────
+# 0. HEADER
+# ─────────────────────────────────────────────────────────────────────────────
+print(SEP)
+print("  TopoDevPOC — Developing POC Pattern Enumerator")
+print(f"  n = {N} candles | {N_TRANS} transitions | device = {DEVICE}")
+if HAS_CUDA and torch:
+    print(f"  GPU = {torch.cuda.get_device_name(0)}")
+if HAS_WARP:
+    print(f"  Warp = enabled (branchless kernel path)")
+print(SEP)
+
+# ─────────────────────────────────────────────────────────────────────────────
+# SECTION 1 — COMBINATORIAL ENUMERATION  (tex Theorem, Sec. III)
+#
+#   Bullish:  each of (n-1) transitions ∈ {>, =}  → 2^(n-1) patterns
+#   Bearish:  each of (n-1) transitions ∈ {<, =}  → 2^(n-1) patterns
+#   Total   : 2^(n-1) + 2^(n-1) = 2^n  (disjoint families)
+#   n=39    : 2^39 = 549,755,813,888
+# ─────────────────────────────────────────────────────────────────────────────
+TOTAL = 1 << N          # exact Python int (arbitrary precision)
+HALF  = 1 << (N - 1)
+
+print(f"\n[THEOREM]  Total unique developing POC patterns for n={N}")
+print(f"  Bullish (non-increasing) : 2^{N-1} = {HALF:,}")
+print(f"  Bearish (non-decreasing) : 2^{N-1} = {HALF:,}")
+print(f"  Total  (2^{N})           : {TOTAL:,}")
+
+# ─────────────────────────────────────────────────────────────────────────────
+# SECTION 2 — MATRIX STATE-TRANSITION VALIDATION  (tex Sec. IV)
+#
+#   States  : S_0 (equality), S_± (strict move)
+#   A = [[1,1],[1,1]]   (fully-connected 2-state digraph)
+#   v_0 = [1,1]^T       (both states reachable initially)
+#
+#   B_n = 1^T · A^(n-2) · v_0
+#       = 2^(n-3) · 1^T · A · 1     (using A^k = 2^(k-1)·A for k≥1)
+#       = 2^(n-3) · 4  =  2^(n-1)   per direction
+#
+#   Implementation: exact Python-int matrix exponentiation (no float rounding)
+# ─────────────────────────────────────────────────────────────────────────────
+
+def _mm2(A, B):
+    """Exact 2×2 matrix multiply with Python arbitrary-precision ints."""
+    return [
+        [A[0][0]*B[0][0] + A[0][1]*B[1][0],  A[0][0]*B[0][1] + A[0][1]*B[1][1]],
+        [A[1][0]*B[0][0] + A[1][1]*B[1][0],  A[1][0]*B[0][1] + A[1][1]*B[1][1]],
+    ]
+
+def _mpow2(M, k):
+    """Fast 2×2 matrix power, exact ints, O(log k)."""
+    if k == 0: return [[1,0],[0,1]]
+    if k == 1: return M
+    h = _mpow2(M, k >> 1)
+    s = _mm2(h, h)
+    return s if (k & 1) == 0 else _mm2(s, M)
+
+A_mat  = [[1,1],[1,1]]
+v0     = [1, 1]
+A_pow  = _mpow2(A_mat, N - 2)
+# 1^T · A^(n-2) · v0
+Av0_0  = A_pow[0][0]*v0[0] + A_pow[0][1]*v0[1]
+Av0_1  = A_pow[1][0]*v0[0] + A_pow[1][1]*v0[1]
+B_n    = Av0_0 + Av0_1          # = 1^T · (A^(n-2)·v0)
+
+print(f"\n[MATRIX]  A = [[1,1],[1,1]] | v_0 = [1,1]^T")
+print(f"  A^{N-2} = [[{A_pow[0][0]}, {A_pow[0][1]}],")
+print(f"             [{A_pow[1][0]}, {A_pow[1][1]}]]")
+print(f"  B_{N} = 1^T · A^{N-2} · v_0 = {B_n:,}")
+print(f"  Expected 2^{{n-1}}           = {HALF:,}")
+assert B_n == HALF,          f"Matrix B_n mismatch: {B_n} ≠ {HALF}"
+assert 2 * B_n == TOTAL,     f"Total mismatch: {2*B_n} ≠ {TOTAL}"
+print(f"  [OK] 2 × {B_n:,} = {TOTAL:,}  ✓")
+
+# ─────────────────────────────────────────────────────────────────────────────
+# SECTION 3 — PATTERN ENCODING SCHEME
+#
+#   Each of the 2^39 patterns maps bijectively to a 39-bit integer:
+#     bit  0          : direction   (0 = Bullish, 1 = Bearish)
+#     bits 1 … N-1   : transitions  (1 = strict move, 0 = equality)
+#
+#   pattern_id ∈ [0, 2^39)   uniquely identifies every valid pattern.
+#
+#   Ternary matrix m ∈ {+1,0}^(n-1) for bullish,
+#                  m ∈ {-1,0}^(n-1) for bearish.
+#   Bijection: m_k = sign(direction) × trans_bit_k
+# ─────────────────────────────────────────────────────────────────────────────
+
+# ─────────────────────────────────────────────────────────────────────────────
+# SECTION 4 — GPU-ACCELERATED RANDOM SAMPLING
+#   Generate (N_SAMPLES × N) binary matrix at once on T4 GPU.
+#   Inspired by core_engine_v11.py XOR-shift PRNG kernel design.
+#   bits[:,0]  = direction flags
+#   bits[:,1:] = N_TRANS transition flags per pattern
+# ─────────────────────────────────────────────────────────────────────────────
+
+t_sample = time.perf_counter()
+
+if HAS_WARP:
+    # ── Warp branchless path (core_engine_v11.py style) ─────────────────────
+    # Launch one thread per sample; XOR-shift fills N bits per thread.
+    _seed_wp = SEED
+
+    @wp.kernel
+    def k_rng_bits(seed: int, N_cols: int,
+                   out: wp.array(dtype=wp.int8)):
+        tid = wp.tid()
+        rng = wp.uint32(seed) ^ wp.uint32(tid)
+        if rng == wp.uint32(0):
+            rng = wp.uint32(123456789)
+        base = tid * N_cols
+        for col in range(N_cols):
+            rng = rng ^ (rng << wp.uint32(13))
+            rng = rng ^ (rng >> wp.uint32(17))
+            rng = rng ^ (rng << wp.uint32(5))
+            out[base + col] = wp.int8(int(rng) & 1)
+
+    out_wp  = wp.zeros(N_SAMPLES * N, dtype=wp.int8, device='cuda')
+    wp.launch(k_rng_bits, dim=N_SAMPLES, block_dim=128,
+              inputs=[_seed_wp, N, out_wp], device='cuda')
+    wp.synchronize()
+    bits_np = out_wp.numpy().reshape(N_SAMPLES, N)
+    print(f"\n[SAMPLE]  {N_SAMPLES} patterns sampled via Warp XOR-shift kernel")
+
+elif HAS_CUDA and torch is not None:
+    # ── Torch GPU path ───────────────────────────────────────────────────────
+    gen = torch.Generator(device='cuda')
+    gen.manual_seed(SEED)
+    bits_t  = torch.randint(0, 2, (N_SAMPLES, N), device='cuda',
+                            generator=gen, dtype=torch.int8)
+    bits_np = bits_t.cpu().numpy()
+    print(f"\n[SAMPLE]  {N_SAMPLES} patterns sampled on GPU (torch.randint)")
+
+else:
+    # ── CPU NumPy fallback ────────────────────────────────────────────────────
+    rng_cpu = np.random.default_rng(SEED)
+    bits_np = rng_cpu.integers(0, 2, size=(N_SAMPLES, N), dtype=np.int8)
+    print(f"\n[SAMPLE]  {N_SAMPLES} patterns sampled on CPU (NumPy)")
+
+sample_ms = (time.perf_counter() - t_sample) * 1e3
+print(f"          Sampling time: {sample_ms:.2f} ms")
+
+# ─────────────────────────────────────────────────────────────────────────────
+# SECTION 5 — VECTORISED DECODING  (NumPy, no Python loops over patterns)
+#
+#   bits[:,0]   → direction array  (0=Bullish, 1=Bearish), shape (100,)
+#   bits[:,1:]  → trans array,     shape (100, 38)
+#   ternary_mat: +trans if Bullish, -trans if Bearish  → shape (100, 38)
+#   sign: Bullish→+1, Bearish→-1, broadcast multiply
+# ─────────────────────────────────────────────────────────────────────────────
+
+dir_bits  = bits_np[:, 0].astype(np.int8)      # 0 or 1
+trans     = bits_np[:, 1:].astype(np.int8)      # (100,38), values 0 or 1
+signs     = 1 - 2 * dir_bits                    # 0→+1 (bull), 1→-1 (bear)
+ternary   = (signs[:, None] * trans).astype(np.int8)  # (100,38): +1/0/-1
+
+# Compact 39-bit pattern IDs
+pows64    = (np.uint64(1) << np.arange(N, dtype=np.uint64))
+pat_ids   = (bits_np.astype(np.uint64) * pows64[None, :]).sum(axis=1)
+
+# Symbolic sequences: vectorised char lookup
+#   Bullish (sign=+1): trans=1 → '>', trans=0 → '='
+#   Bearish (sign=-1): trans=1 → '<', trans=0 → '='
+SYM_BULL = np.array(['=', '>'], dtype='<U1')   # index by trans bit
+SYM_BEAR = np.array(['=', '<'], dtype='<U1')
+sym_matrix = np.where(dir_bits[:, None] == 0,
+                      SYM_BULL[trans],
+                      SYM_BEAR[trans])          # (100, 38)
+
+# POC price sequence (right-to-left: p[0]=C_0=newest, p[N-1]=C_{-(N-1)}=oldest)
+#   p_raw[i, k] = POC of candle C_{-k} for sample i
+#   Transition k: p[k] = p[k+1] + ternary[k]
+#   Build by cumsum from oldest→newest: p_raw[:, N-1] = 50, then forward
+BASE    = 50.0
+step    = 1.0
+p_raw   = np.zeros((N_SAMPLES, N), dtype=np.float32)
+p_raw[:, N-1] = BASE
+# Vectorised: cumulative sum of ternary (columns N-2 down to 0)
+for k in range(N-2, -1, -1):
+    p_raw[:, k] = p_raw[:, k+1] + ternary[:, k].astype(np.float32) * step
+
+# Display order: oldest(left) → newest(right)
+# poc_disp[:, j] = p_raw[:, N-1-j]
+poc_disp = p_raw[:, ::-1].copy()   # (100, 39), column 0=oldest, col N-1=newest
+
+# ─────────────────────────────────────────────────────────────────────────────
+# OUTPUT 1 — TERNARY MATRICES  (100 × 38)
+# ─────────────────────────────────────────────────────────────────────────────
+print(f"\n{SEP}")
+print(f"  OUTPUT 1 — TERNARY MATRICES  (1×{N_TRANS}, values ∈ {{-1,0,+1}})")
+print(f"  Format: [#] Direction | PatternID | M = [m_0 … m_37]")
+print(SEP)
+
+for i in range(N_SAMPLES):
+    d_label = "Bullish" if dir_bits[i] == 0 else "Bearish"
+    pid     = int(pat_ids[i])
+    row_str = np.array2string(ternary[i], separator=',',
+                              max_line_width=400).replace('\n','')
+    print(f"  [{i+1:3d}] {d_label:7s} | ID={pid:>15d} | M={row_str}")
+
+# ─────────────────────────────────────────────────────────────────────────────
+# OUTPUT 2 — SYMBOLIC SEQUENCES  (length 38)
+# ─────────────────────────────────────────────────────────────────────────────
+print(f"\n{SEP}")
+print(f"  OUTPUT 2 — SYMBOLIC SEQUENCES  (Σ, length {N_TRANS})")
+print(f"  Format: [#] Direction | PatternID | Σ = σ_0 σ_1 … σ_37")
+print(SEP)
+
+for i in range(N_SAMPLES):
+    d_label = "Bullish" if dir_bits[i] == 0 else "Bearish"
+    pid     = int(pat_ids[i])
+    seq_str = ' '.join(sym_matrix[i])
+    print(f"  [{i+1:3d}] {d_label:7s} | ID={pid:>15d} | Σ = {seq_str}")
+
+# ─────────────────────────────────────────────────────────────────────────────
+# OUTPUT 3 — CHARTS
+#   (a) Full matplotlib figure: 10×10 grid, saved to PNG
+#   (b) ASCII CLI preview for first 10 patterns
+# ─────────────────────────────────────────────────────────────────────────────
+print(f"\n{SEP}")
+print(f"  OUTPUT 3 — DEVELOPING POC CHARTS  (100 patterns)")
+print(SEP)
+
+# ── x-axis: position 0=oldest C_{-(N-1)}, N-1=newest C_0 ──────────────────
+x_pos  = np.arange(N, dtype=np.float32)
+x_tick_pos = [0, 9, 19, 29, N-1]
+x_tick_lbl = [f'C_{{-{N-1}}}', f'C_{{-29}}', f'C_{{-19}}', f'C_{{-9}}', 'C_0']
+
+ROWS, COLS = 10, 10
+fig = plt.figure(figsize=(COLS * 3.2, ROWS * 2.0))
+fig.suptitle(
+    f"TopoDevPOC — 100 Random Developing POC Patterns   "
+    f"n={N} pre-market 3-min K-lines\n"
+    f"Total pattern space: 2^{N} = {TOTAL:,}   "
+    f"(Bullish: {HALF:,}  |  Bearish: {HALF:,})",
+    fontsize=10, y=1.005
+)
+
+for i in range(N_SAMPLES):
+    ax  = fig.add_subplot(ROWS, COLS, i + 1)
+    poc = poc_disp[i]
+    is_bull = (dir_bits[i] == 0)
+    color   = '#1a6eb5' if is_bull else '#c0392b'
+    label   = 'B↑' if is_bull else 'B↓'
+
+    # Background shade
+    ax.set_facecolor('#f7f9fc' if is_bull else '#fdf4f4')
+
+    # POC line
+    ax.plot(x_pos, poc, color=color, linewidth=1.2, zorder=3)
+
+    # Mark strict-move positions (non-zero ternary in display coords)
+    # Transition k corresponds to display segment [N-2-k, N-1-k]
+    # Highlight the newer-side node at display index N-1-k = N-1-k
+    strict_k   = np.where(ternary[i] != 0)[0]          # transition indices
+    strict_disp = (N - 1 - strict_k).astype(int)        # display x-positions
+    if strict_disp.size > 0:
+        ax.scatter(strict_disp, poc[strict_disp],
+                   color=color, s=5, zorder=5, linewidths=0)
+
+    # Flat segments (equality)
+    flat_k     = np.where(ternary[i] == 0)[0]
+    flat_disp  = (N - 1 - flat_k).astype(int)
+    if flat_disp.size > 0:
+        ax.scatter(flat_disp, poc[flat_disp],
+                   color='gray', s=3, zorder=4, linewidths=0, alpha=0.5)
+
+    n_strict = int(np.abs(ternary[i]).sum())
+    pid_short = int(pat_ids[i]) % 10**9      # last 9 digits for readability
+    ax.set_title(f"#{i+1} {label}  mv={n_strict}  …{pid_short:09d}",
+                 fontsize=5.5, pad=2, color=color)
+
+    ax.set_xlim(-0.5, N - 0.5)
+    ax.set_xticks(x_tick_pos)
+    ax.set_xticklabels(['←old', '', '', '', 'new→'], fontsize=3.5)
+    ax.tick_params(axis='y', labelsize=3.5)
+    ax.yaxis.set_major_locator(mticker.MaxNLocator(4))
+    for sp in ('top', 'right'):
+        ax.spines[sp].set_visible(False)
+    ax.spines['left'].set_color(color)
+    ax.spines['left'].set_linewidth(1.5)
+    ax.spines['bottom'].set_color('#cccccc')
+
+plt.tight_layout(rect=[0, 0, 1, 1])
+chart_path = "TopoDevPOC_n39_100samples.png"
+plt.savefig(chart_path, dpi=110, bbox_inches='tight')
+plt.close(fig)
+print(f"  [SAVED] {chart_path}")
+
+# ── ASCII CLI chart for first 10 patterns ────────────────────────────────────
+H  = 7          # chart height in rows
+W  = 39         # chart width  = N
+
+print(f"\n  ASCII CLI Charts — first 10 samples (right side = C_0 = newest)\n")
+for i in range(10):
+    poc    = poc_disp[i]
+    d_lbl  = "Bullish" if dir_bits[i] == 0 else "Bearish"
+    pid    = int(pat_ids[i])
+    n_mv   = int(np.abs(ternary[i]).sum())
+    pmin, pmax = poc.min(), poc.max()
+    span   = pmax - pmin if pmax != pmin else 1.0
+
+    # Map each x-position to a row
+    rows   = (H - 1 - ((poc - pmin) / span * (H - 1))).round().astype(int)
+    rows   = np.clip(rows, 0, H - 1)
+
+    grid   = [[' '] * W for _ in range(H)]
+    for j in range(W):
+        r = rows[j]
+        # Strict-move node in the pair ending at display j:
+        # transition index k = N-1-j  (if j < N-1)
+        is_strict = (j < N - 1) and (ternary[i, N - 2 - j] != 0)
+        grid[r][j] = '●' if is_strict else '·'
+    # Connect with horizontal dash where poc is flat
+    for row_idx in range(H):
+        line = grid[row_idx]
+        for j in range(1, W):
+            if line[j] == ' ' and rows[j] == row_idx:
+                line[j] = '-'
+
+    print(f"  [{i+1:2d}] {d_lbl:7s} | ID={pid} | strict_moves={n_mv}/{N_TRANS}")
+    poc_hi = poc[N-1]; poc_lo = poc[0]
+    print(f"       POC range: oldest={poc_lo:.0f}  →  newest={poc_hi:.0f}")
+    print(f"       ┌{'─'*W}┐")
+    for row_idx in range(H):
+        print(f"       │{''.join(grid[row_idx])}│")
+    print(f"       └{'─'*W}┘")
+    sym_preview = ' '.join(sym_matrix[i, :12]) + ' …'
+    print(f"       Σ (first 12): {sym_preview}\n")
+
+# ─────────────────────────────────────────────────────────────────────────────
+# OUTPUT 4 — COMPRESSED CSV EXPORT  (bit-packed uint64 pattern_id)
+#
+#  COMPRESSION LOGIC:
+#   Naive CSV text per row (direction label + 38 integers): ~110 bytes/row
+#   Compressed: single uint64 hex string per row             ~  18 bytes/row
+#   Reduction: ~6× on text CSV; binary .npy = 8 bytes/row (machine-optimal)
+#
+#  ENCODING (39-bit integer into uint64):
+#   pattern_id = dir_bit | (trans[0]<<1) | (trans[1]<<2) | … | (trans[37]<<38)
+#   bit 0      = direction (0=Bullish, 1=Bearish)
+#   bits 1..38 = transition flags
+#
+#  DECODE (one-liner, O(1)):
+#   direction  = "Bullish" if (pid & 1) == 0 else "Bearish"
+#   trans[k]   = (pid >> (k+1)) & 1         for k in 0..37
+#   ternary[k] = trans[k] if Bullish else -trans[k]
+#
+#  NOTE ON "ALL PATTERNS":
+#   2^39 = 549,755,813,888 patterns.  At 8 bytes/pattern → 4.4 TB.
+#   At minimum 39 bits/pattern (bit-packed) → 2.68 TB.
+#   The pattern space IS [0, 2^39). Pattern k = integer k. No file needed.
+#   Use the streaming generator below for on-demand enumeration.
+# ─────────────────────────────────────────────────────────────────────────────
+
+print(f"\n{SEP}")
+print(f"  OUTPUT 4 — COMPRESSED EXPORT")
+print(SEP)
+
+# ── Verify encoding round-trip before writing ─────────────────────────────
+def encode_pattern_id(dir_bit, trans_bits):
+    """Pack direction + 38 transition bits into one uint64."""
+    pid = np.uint64(dir_bit)
+    for k, t in enumerate(trans_bits):
+        pid |= (np.uint64(int(t)) << np.uint64(k + 1))
+    return int(pid)
+
+def decode_pattern_id(pid, n_trans=38):
+    """Unpack uint64 → direction + ternary matrix. O(1) per pattern."""
+    pid = int(pid)
+    dir_bit = pid & 1
+    direction = "Bullish" if dir_bit == 0 else "Bearish"
+    sign = 1 if dir_bit == 0 else -1
+    trans = np.array([(pid >> (k + 1)) & 1 for k in range(n_trans)], dtype=np.int8)
+    ternary = (sign * trans).astype(np.int8)
+    return direction, trans, ternary
+
+# Round-trip verification on all 100 samples
+for i in range(N_SAMPLES):
+    pid_ref  = int(pat_ids[i])
+    pid_enc  = encode_pattern_id(int(dir_bits[i]), trans[i])
+    assert pid_ref == pid_enc, f"Encode mismatch at sample {i}"
+    d2, t2, m2 = decode_pattern_id(pid_enc)
+    assert (d2 == ("Bullish" if dir_bits[i] == 0 else "Bearish")), "Direction mismatch"
+    assert np.array_equal(m2, ternary[i]), f"Ternary mismatch at sample {i}"
+print("  [OK] 100-sample encode/decode round-trip verified")
+
+# ── CSV: bit-packed uint64 — one integer per row ──────────────────────────
+# Columns: seq_id (1-based), pattern_id_uint64 (hex), direction, n_strict
+# Total row bytes: ~50 chars vs ~110 for expanded matrix text
+CSV_PATH = "TopoDevPOC_n39_samples.csv"
+with open(CSV_PATH, 'w', newline='') as f:
+    writer = csv.writer(f)
+    # Header — human-readable but compact
+    writer.writerow([
+        "seq_id",           # 1-based sample index
+        "pattern_id_uint64",# hex string — encodes everything, 18 chars
+        "pattern_id_dec",   # decimal for inspection
+        "direction",        # B+ or B- (1 char each saves space vs full label)
+        "n_strict_moves",   # popcount of transitions
+    ])
+    for i in range(N_SAMPLES):
+        pid     = int(pat_ids[i])
+        d_char  = "B+" if dir_bits[i] == 0 else "B-"
+        n_mv    = int(np.abs(ternary[i]).sum())
+        writer.writerow([
+            i + 1,
+            f"0x{pid:016X}",    # 18-char hex — decode with int(x, 16)
+            pid,
+            d_char,
+            n_mv,
+        ])
+
+csv_bytes = os.path.getsize(CSV_PATH)
+print(f"  [CSV]    {CSV_PATH}  →  {csv_bytes:,} bytes  ({csv_bytes/N_SAMPLES:.1f} bytes/row)")
+
+# ── Binary .npy — uint64 array, 8 bytes/row, machine-optimal ─────────────
+NPY_PATH = "TopoDevPOC_n39_samples.npy"
+np.save(NPY_PATH, pat_ids.astype(np.uint64))
+npy_bytes = os.path.getsize(NPY_PATH)
+print(f"  [NPY]    {NPY_PATH}  →  {npy_bytes:,} bytes  ({(npy_bytes-128)/N_SAMPLES:.1f} bytes/row payload)")
+
+# ── Raw bit-packed .bin — 39 bits/pattern → ceil(39/8)=5 bytes each ──────
+# Pack 8 patterns × 39 bits = 312 bits = 39 bytes per block (tight packing)
+# Simple implementation: pack pattern_ids as 5-byte little-endian chunks
+BIN_PATH = "TopoDevPOC_n39_samples.bin"
+BYTES_PER = 5   # ceil(39 / 8) = 5 bytes holds one 39-bit pattern_id
+with open(BIN_PATH, 'wb') as f:
+    # 8-byte magic + 4-byte n_patterns + 1-byte bits_per_pattern
+    f.write(b'TPOC3900')
+    f.write(struct.pack('<IB', N_SAMPLES, 39))
+    for i in range(N_SAMPLES):
+        pid = int(pat_ids[i])
+        f.write(pid.to_bytes(BYTES_PER, byteorder='little'))
+bin_bytes = os.path.getsize(BIN_PATH)
+payload   = N_SAMPLES * BYTES_PER
+print(f"  [BIN]    {BIN_PATH}  →  {bin_bytes:,} bytes  (13 hdr + {payload} payload = {BYTES_PER} bytes/pattern)")
+
+# ── Print size comparison ─────────────────────────────────────────────────
+print()
+print(f"  SIZE COMPARISON (100 samples, n=39, {N_TRANS} transitions):")
+print(f"    Naive text (direction + 38 ints):  ~{100 * 110:,} bytes")
+print(f"    CSV hex uint64  (this file):        {csv_bytes:,} bytes  ({100*110//csv_bytes:.1f}× smaller)")
+print(f"    NumPy .npy uint64:                  {npy_bytes:,} bytes")
+print(f"    Raw bit-packed .bin (39 bits each): {bin_bytes:,} bytes  ({100*110//bin_bytes:.1f}× smaller)")
+print()
+print(f"  SCALING TO ALL 2^{N} = {TOTAL:,} PATTERNS:")
+full_npy_tb  = (TOTAL * 8) / 1e12
+full_bin_tb  = (TOTAL * BYTES_PER) / 1e12
+full_text_tb = (TOTAL * 110) / 1e12
+print(f"    Naive text:           ~{full_text_tb:.1f} TB  (infeasible)")
+print(f"    uint64 binary (.npy): ~{full_npy_tb:.2f} TB  (infeasible to store)")
+print(f"    5-byte bit-packed:    ~{full_bin_tb:.2f} TB  (infeasible to store)")
+print(f"    Optimal:               0 bytes  — pattern k = integer k, range [0, 2^{N})")
+print(f"    Use streaming generator below for on-demand enumeration.")
+
+# ── Streaming generator (no memory, yields all 2^39 on-demand) ───────────
+def stream_all_patterns(n=N):
+    """
+    Yields (pattern_id, direction, ternary_matrix) for all 2^n patterns.
+    Zero memory beyond one pattern at a time. Works for any n.
+    Pattern_id k: bit0=direction, bits1..n-1=transitions.
+    """
+    sign_map = {0: 1, 1: -1}
+    for k in range(1 << n):
+        dir_bit   = k & 1
+        sign      = sign_map[dir_bit]
+        direction = "Bullish" if dir_bit == 0 else "Bearish"
+        ternary_k = np.array(
+            [sign * ((k >> (j + 1)) & 1) for j in range(n - 1)],
+            dtype=np.int8
+        )
+        yield k, direction, ternary_k
+
+# Show the first 4 and last 4 pattern_ids to confirm ordering
+print()
+print(f"  STREAMING GENERATOR — first 4 / last 4 of all {TOTAL:,} patterns:")
+gen = stream_all_patterns(N)
+for _ in range(4):
+    pid_s, d_s, _ = next(gen)
+    print(f"    pattern_id={pid_s:>3d}  direction={d_s}")
+print(f"    ... ({TOTAL - 8:,} patterns omitted) ...")
+# Last 4: decode directly from known IDs
+for pid_s in range(TOTAL - 4, TOTAL):
+    d_s = "Bullish" if (pid_s & 1) == 0 else "Bearish"
+    print(f"    pattern_id={pid_s}  direction={d_s}")
+
+# ─────────────────────────────────────────────────────────────────────────────
+# FINAL SUMMARY
+# ─────────────────────────────────────────────────────────────────────────────
+total_ms = (time.perf_counter() - t_sample) * 1e3
+print(SEP)
+print("  SUMMARY")
+print(SEP)
+print(f"  n (candles)                = {N}")
+print(f"  Transitions per pattern    = {N_TRANS}")
+print(f"  Total patterns  [2^{N}]    = {TOTAL:,}")
+print(f"  Bullish         [2^{N-1}]  = {HALF:,}")
+print(f"  Bearish         [2^{N-1}]  = {HALF:,}")
+print(f"  Matrix B_n validated       = {B_n:,}  ✓")
+print(f"  Samples generated          = {N_SAMPLES}")
+print(f"  Chart file                 = {chart_path}")
+print(f"  CSV export (hex uint64)    = {CSV_PATH}  ({csv_bytes:,} bytes)")
+print(f"  Binary export (.npy)       = {NPY_PATH}   ({npy_bytes:,} bytes)")
+print(f"  Bit-packed export (.bin)   = {BIN_PATH}  ({bin_bytes:,} bytes)")
+print(f"  Compute device             = {DEVICE}")
+print(f"  Wall-clock (sample+decode) = {total_ms:.2f} ms")
+print(SEP)
+print()
+print("  CONVERSION FORMULAS  (tex Sec. V)")
+print("  Symbolic → Ternary:")
+print("    Bullish: '>' → +1,  '=' →  0")
+print("    Bearish: '<' → -1,  '=' →  0")
+print("  Ternary → Symbolic:")
+print("    +1 → '>',  0 → '=',  -1 → '<'")
+print()
+print("  TEMPORAL CONVENTION:")
+print(f"    Chart x-axis: left = C_{{-{N-1}}} (oldest) → right = C_0 (newest)")
+print("    Bullish pattern: POC non-increasing toward right (higher on left)")
+print("    Bearish pattern: POC non-decreasing toward right (lower on left)")
+print(SEP)