Skip to content
Other

Alcyone-W

an AI model at the intersection of particle physics, topology, and Lean 4

3 min read

Researcher Teerth Sharma has introduced an experimental AI model called Alcyone-W — the first architecture in the JEPA family (Joint-Embedding Predictive Architecture — AI models that predict the hidden part of input data) that restores not abstract embeddings, but the exact topology of a hidden region. The model works with CMS detector particle collision data (CERN Open Data): it turns particle momenta into a 32×64 grid landscape, masks a fragment of it, and predicts the number of energy "lakes", their persistence, and volume. The system combines a trainable 5.9-million-parameter W-JEPA convolutional encoder and a frozen scientific language model facebook/galactica-6.7b (6.66 billion parameters), which converts textual particle descriptions into additional terrain channels. Unlike classical JEPAs, target metrics here are calculated strictly mathematically using algorithms formally proven within the Lean 4 verification system. This development will interest researchers in physical ML, topological data analysis, and neuro-symbolic AI.

Key features

  • Topological targets without training collapse: the model predicts the number of basins (basins), their persistence (persistence), and energy volume (water), which are computed via an exact hydraulic algorithm without relying on an unstable teacher network.
  • A hybrid of vision, language, and formal logic: the frozen Galactica-6.7B encodes textual descriptions of particles (such as muons and jets) via PCA into 8 terrain channels, while 1,818 lemmas in Lean 4 and Haskell guarantee calculation correctness.
  • Built-in agent with numerical verification: the repository includes a runtime for Galactica with 4 tools (watershed, charge, describe, calc) that forces the model to call tools and flags any numbers not backed by code.
  • Honest limitations reporting: the author published all pre-specified verification criteria — for example, noting that a standard MLP using kinematics is still more accurate on jet multiplicity tasks, and that the charge channel is absent in the current version.

What you can do

  • Reproduce LHC data experiments: run the ready-made script on the provided sample of 512 test CMS NanoAOD events and compare topology predictions with exact calculations.
  • Explore formally verified ML: use the WatershedLemmas library in Lean 4 and Haskell mirrors with QuickCheck tests as an example of integrating theorem proving into a machine learning pipeline.
  • Test the neuro-symbolic agent: ask questions about collision event properties via agent.py, where computations rely on Gauss's law and hydraulic lemmas instead of LLM hallucinations.

Example

import sys; sys.path.insert(0, "code")
from alcyone import WatershedJEPA, exact_summary, window_mask

m = WatershedJEPA(".", galactica="facebook/galactica-6.7b")
z = m.encode(x) # x: (N, 15, 8) [pT, eta, phi, mass, charge, type, btag, valid]
win = window_mask(12, 24, len(x))
pred = m.predict_summary(x, win)
true = exact_summary(x, win)
Read moreDetails
Basin count accuracy on 512 CMS events: 0.945 (vs 0.572 when picking the most frequent class) and 0.936 on 4,096 validation windows.
Trained on 2.24 million CMS Open Data events (38,155 steps); Galactica-6.7B weights (CC BY-NC 4.0) are not included in the repository and must be downloaded separately.
Limitations: the model is strictly tailored to the CMS NanoAOD format, partially "peeks" through the edges of the hidden window, and does not account for particle electric charge in the terrain.
Discuss Telegram 1

Will it run?

Runs in F32

Fits without quantisation.

  • F32weights 0.0 GB · ready files0.5 GB
  • BF16weights 0.0 GB0.5 GB
  • FP8 / INT8recommendedweights 0.0 GB0.5 GB
  • 4-bitweights 0.0 GB0.5 GB

Tip: go 8-bit.FP8 / INT8 is within about a percent of full precision in quality, takes half the memory and runs faster on RTX 40/50 and H100. Full precision only pays off for fine-tuning.

What to get for this model

Massed ComputeOpen Massed Compute

Your own GPU: FP8 / INT8 — from RTX 2060 · F32 — from RTX 2060

Massed Compute hourly prices, November 2026. The discounted price applies with the coupon at checkout.

Estimate: weights plus working memory. Long videos, high resolutions and long contexts need more.

Run it on Massed Compute

The script downloads the model to the rented machine. How to run it is in the model card.

  1. 1. Rent a machine with a fitting GPU

    Open Massed Compute
  2. 2. Paste the script into the machine's terminal

    Connect over SSH (the Massed Compute panel shows the command) or open a terminal on the machine's desktop.

    HF_TOKEN / CIVITAI_TOKENThe script starts with token lines: paste yours between the quotes. The Hugging Face token is for gated models, the Civitai one for Civitai models.

    # teerthsharma/Alcyone-W
    mkdir -p ~/models
    curl -LsSf https://astral.sh/uv/install.sh | sh
    source "$HOME/.local/bin/env"
    uv tool install "huggingface_hub[cli]"
    hf download teerthsharma/Alcyone-W --local-dir ~/models/Alcyone-W
    # The model is in ~/models. How to run it is in the model card (link above).
    Add more LoRAs to Alcyone-W
  3. 3. Use it

    The model is in ~/models. How to run it is in the model card (link above).

Stop the machine in the panel when you are done: it bills by the minute while it runs.

How to speed it up

Picked for this model type. Choose your hardware above to see what fits you exactly.

  • FlashAttention 44.0.0b40from November 18, 2026new release

    fastest exact attention on B200

    Kernels for Blackwell (beta). Exact attention without quantisation — fine for everything, LLMs included.

    How to enable: pip install flash-attn-4; vLLM and SGLang pick it up themselves.

    Earlier generations (2)
    • FlashAttention 3 — The Hopper (H100/H200) version with FP8.
    • FlashAttention 2 — The standard for RTX 30/40/50 and A100: exact attention without the memory cost of long contexts.
  • torch.compile2.15.0from October 28, 2026new release

    10–30% for free

    Compiles the model for your GPU. Slower first run, faster afterwards.

    How to enable: model = torch.compile(model); in ComfyUI the TorchCompileModel node.

Model family

New posts about versions of galactica-6.7b (quants, finetunes, LoRAs) will show up under the bell.

Fine-tunes 4All on Hugging Face

About the model

teerthsharma/Alcyone-W
Author
teerthsharma
Category
Other
Released
Posted

On NeyroLearn

Hugging Face

01

Ask AI about this model

Answered by Gemini 4 · the chat is kept only in this tab

Comments