C = A × B is the hot loop of nearly all numerical computing. CCO is where you submit a matmul strategy that computes it for less — lower latency, lower VRAM, lower time-complexity — without giving up accuracy, and have that claim measured the same way for everyone.
# Normal (exact) computing — O(N³), the frontier you must beat - C = A @ B # Smart (subspace) strategy — compress, compute, reconstruct + from strategy import subspace_matmul, Config + C = subspace_matmul(A, B, config=Config(transform="rsvd", rank_m=128)) assert rel_err(C, A @ B) < 1e-2 # admitted only if accurate AND cheaper # O(N²M) vs O(N³) · scored on accuracy, latency, VRAM, FLOPs — together
Gittensor pays TAO for real, merged pull requests to whitelisted open-source repositories. CCO is one of them. You don't need Discord access or prior SN74 knowledge to take part — read the docs here, run the scorer on your own GPU, and open a PR through the same GitHub path as any open-source project. This repository stays the single source of truth for the code, the scorer, the docs, and every admitted improvement.
C = A × B costs 2N³ FLOPs computed exactly. The same matrix operations sit underneath attention layers in Transformer LLMs — which is why CCO's roadmap points toward an attention-shaped track — but today's score-bearing arena is the general, provider-agnostic case: exact matrix multiplication, measured honestly.
Trivial today — the N³ term means this is not where the real cost lives.
Full-rank data, deliberately the hard case — no structure to exploit for free.
Where the exact engine must tile across disk-backed memory — a cheaper algorithm stops being optional.
No prize pool, no cycles, no committee — a deterministic scorer decides, and Gittensor's emission share pays for what it admits.
Add a Transform to strategy/transforms.py and open a PR with your self-scored scorecard.
python -m eval reruns your matmul strategy against the exact baseline on identical inputs — accuracy, latency, VRAM, FLOPs, together.
Admitted only if it dominates the exact baseline on every cost axis while holding accuracy — no averaging a win on one axis against a loss on another.
SN74 validators see the merged PR and pay TAO from CCO's emission share — no separate application, no cycle to wait for.
The reference strategy projects A and B onto a shared M-dimensional subspace (M ≪ N), multiplies the small M×M cores, and reconstructs — O(N²M) instead of O(N³). The subspace basis is the pluggable part: a Transform you write and register.
A @ B on identical random inputs — never a synthetic or cherry-picked case.Transform, implement basis(), call register_transform() — that's the whole interface.Q is an (N, M) orthonormal basis — the only thing a contributed Transform supplies. Everything else in the pipeline is shared, tested infrastructure.
Every submission passes through the same automated gate on identical inputs. No language model ever judges another strategy — ranking is pure measurement, reproducible by anyone with a GPU.
Bounded Frobenius accuracy against the exact product. Fall below the floor and the score is zero — a fast wrong answer is not an improvement.
An empirical N^p fit from --sweep. A claimed sub-cubic strategy must show it in measured latency, not just in algebra.
Admitted only if latency, VRAM, and FLOPs all beat the exact baseline while accuracy holds. One regressing axis disqualifies it — no averaging a win against a loss.
Progress is gated by achievement, not a calendar. Matmul is the open score-bearing arena running right now. Attention is being staged separately as a prototype until the evaluator, bot, GPU validator, and dashboard are track-aware.
Approximate and exact-but-cheaper strategies for C = A × B, scored on full-rank, low-rank, and decaying-spectrum regimes. Open for contributions today.
Adapt the matmul-arena discipline to attention: exact attention baseline, synthetic Q/K/V inputs, hybrid local-window plus spectral-global prototypes, then RTX 5090 validation once the track is official.
Novel hybrid approaches required; spectral or low-rank kernels needed to pass the scaling gate. MSE < 0.005.
Production-grade kernels with true sub-quadratic VRAM scaling and hardware-specific Triton/CUDA tuning. MSE < 0.001.
Fine-grained hardware tuning and optional weight co-optimization (LoRA patches) to recover residual approximation error. MSE < 0.0005.
Add a Transform, self-score it, open a PR. Admitted matmul improvements are merged and — through Gittensor — paid.
Clone the repo, install PyTorch, and reproduce the matmul reference scorecard on your own GPU — the same numbers a reviewer checks.
python -m eval --n 12000 --pairs 3Read the whitepaper to see exactly how scoring and rewards work, or jump straight to contributing a matmul strategy — the scorer decides, not us.