🌐 The Polyformalism at Work

TYPE :: QuiltCell
  REAL(8), DIMENSION(:) :: z_in
  REAL(8), DIMENSION(:) :: z_out
  REAL(8) :: jepa
  REAL(8) :: double_entry
  REAL(8), DIMENSION(3) :: vibe
  INTEGER :: gc_phase
  LOGICAL :: murmur_target
  INTEGER :: graph_id
END TYPE QuiltCell

typedef struct QuiltCell {
    double *z_in;        size_t z_in_len;
    double *z_out;       size_t z_out_len;
    double (*jepa)(const double*, size_t, const double*, size_t);
    double double_entry; // invariant
    double vibe[3];      // pos, vel, acc
    int gc_phase;        // 0=mark, 1=sweep, 2=rebalance
    void *murmur_target; // gossip partner
    int graph_id;
} QuiltCell;

template<typename Embedding>
class QuiltCell {
    std::vector<Embedding> z_in, z_out;
    double jepa(const std::vector<Embedding>&, const std::vector<Embedding>&);
    double double_entry; // invariant
    std::array<double, 3> vibe;
    enum class GCPhase { Mark, Sweep, Rebalance } gc;
    QuiltCell* murmur_target;
    int graph_id;
};

pub struct QuiltCell {
    z_in: Vec<Embedding>,
    z_out: Vec<Embedding>,
    jepa: Box<dyn Fn(&[Embedding], &[Embedding]) -> f64>,
    double_entry: f64, // invariant
    vibe: Vibe,        // (pos, vel, acc)
    gc: GCPhase,       // enum Mark | Sweep | Rebalance
    murmur_target: Option<Rc<RefCell<QuiltCell>>>,
    graph_id: usize,
}

type QuiltCell struct {
    ZIn        []float64
    ZOut       []float64
    Jepa       func(in, out []float64) float64
    DoubleEntry float64 // invariant
    Vibe       Vibe    // pos, vel, acc
    GCPhase    int     // 0=mark, 1=sweep, 2=rebalance
    MurmurTo   *QuiltCell
    GraphID    int
}

record QuiltCell {
    var zIn: [0..#] real(64);
    var zOut: [0..#] real(64);
    var jepa: (real(64), real(64)) -> real(64);
    var doubleEntry: real(64);
    var vibe: 3*real(64);
    var gcPhase: int;
    var murmurTarget: QuiltCell;
    var graphId: int;
}

@value
struct QuiltCell:
    var z_in: List[Float64]
    var z_out: List[Float64]
    var jepa: fn(List[Float64], List[Float64]) -> Float64
    var double_entry: Float64  # invariant
    var vibe: SIMD[DType.float64, 3]  # pos, vel, acc
    var gc_phase: Int  # 0=mark, 1=sweep, 2=rebalance
    var murmur_target: Optional[QuiltCell]
    var graph_id: Int

struct QuiltCell {
    double* z_in;    int z_in_len;
    double* z_out;   int z_out_len;
    double jepa;     // computed
    double double_entry;
    double vibe[3];
    int gc_phase;
    int murmur_target_idx;  // index into cell array
    int graph_id;
};
// Accessed via __global__ kernels

// .global .align 8 .b8 cell_buffer[8*N];
// Each cell: 8 × 8 bytes = 64 bytes
// ld.global.f64 %f0, [cell + 0]   // z_in[0]
// ld.global.f64 %f1, [cell + 8]   // z_in[1]
// ... (5 doubles for z_in)
// ld.global.f64 %f5, [cell + 40]  // z_out[0]
// ld.global.f64 %f6, [cell + 48]  // jepa
// ld.global.f64 %f7, [cell + 56]  // double_entry
// ld.global.s32 %r0, [cell + 64]  // gc_phase
// (no explicit vibe array; inlined)

typedef struct {
    double z_in[8];
    double z_out[8];
    double jepa;
    double double_entry;
    double vibe[3];
    int gc_phase;
    int murmur_target;
    int graph_id;
} QuiltCell;

# QuiltCell

A Quilt cell has 8 primitives:

- **Z_in**: list of input embeddings (perception)
- **Z_out**: list of output embeddings (prediction)
- **JEPA**: surprise, computed by cross-DB comparison
- **DoubleEntry**: conservation invariant (sum of in + out = const)
- **Vibe**: (position, velocity, acceleration) tuple
- **GC**: 3-phase lifecycle (Mark → Sweep → Rebalance)
- **Murmur**: gossip partner (other cell reference)
- **Graph**: which sheet the cell lives in

The cell is the system. The 8 primitives are the cell.

A Quilt cell is defined by 8 fields:

1. z_in: array of input embeddings
2. z_out: array of output embeddings
3. jepa: float (the cross-database surprise)
4. double_entry: float (the conservation invariant)
5. vibe: 3-tuple (position, velocity, acceleration)
6. gc: integer phase (0=mark, 1=sweep, 2=rebalance)
7. murmur: reference to gossip partner
8. graph: integer sheet ID

The 8 fields describe every cell. The polyformalism test: these 8 fields
survive 12 languages. They are the canonical thing.