README.md

metadata

title: Coherent Compute Engine
emoji: 🌖
colorFrom: pink
colorTo: red
sdk: gradio
sdk_version: 6.2.0
app_file: app.py
pinned: false
license: other
short_description: Live coherence + throughput benchmark (no precomputed result
thumbnail: >-
  https://cdn-uploads.huggingface.co/production/uploads/685edcb04796127b024b4805/  

README.md — Coherent Compute Engine

Coherent Compute Engine is a live benchmark Space that measures real compute throughput and stability for a coherent state update rule — with no precomputed results and no estimates.

It’s designed to be understandable, verifiable, and brutally honest:

• Everything is computed now, on the Space machine.
• Baselines (Python loop + vectorised NumPy) are measured live on the same machine.
• Results can be downloaded as a receipt (JSON) with a SHA-256 hash.

What an “item” is

One item = one coherent update of [Ψ, E, L] per oscillator per step.

So:

items/sec = (N oscillators × steps) / elapsed_seconds

We report throughput in billions of items/sec (“B/s”).

What this Space measures

For the chosen oscillator count and step count, it reports:

• Throughput (B/s): billions of coherent updates per second
• Coherence (|C|): a stability proxy computed from a normalised dot product of sampled Ψ before/after
• Mean Energy: bounded mean proxy from E in [0, 1.5]
• Elapsed Time (s)
• Engine: numba when available; otherwise numpy
• Verification baselines (optional):
  • Baseline (Vectorised NumPy)
  • Baseline (Python loop, capped) — safety-capped and subset-based to keep the Space responsive
  • Speedup factors vs those baselines

Receipts: verification you can download

Each run emits a small JSON “receipt” containing:

• input settings (N, steps)
• engine name
• measured metrics
• runtime info
• SHA-256 hash of the canonical JSON

This supports the “don’t trust it, verify it” approach.

Why baselines exist (and why they’re not a contest)

Baselines are verification anchors:

• They show what “normal” Python looks like (slow floor)
• They show what vectorised NumPy looks like (standard reference)
• They show what the engine path achieved under the same rules

No claims about beating GPUs or other systems. Just measured, reproducible data.

Running locally

pip install -r requirements.txt
python app.py
Safety rails

To keep the Space stable:
    •	oscillator count is clamped to a safe max
    •	steps are clamped
    •	Python loop baseline is time-capped and subset-based

That ensures the Space stays responsive while still measuring real throughput.

⸻

Built by RFTSystems.
  
  Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference