Project Info

NOETHER — The Curiosity Engine

Inspiration

AI can answer a student before the student has had time to form a model of their own. That speed is useful, but it can collapse several possible meanings into one polished response and make fluency feel like evidence. The project began with exactly that failure. I asked an AI whether string theory, geometry, and neural-network hallucination might connect. It replied that transformers calculate geodesics through the curvature of human thought: a beautiful explanation that collapsed supported facts, bounded mathematics, metaphor, and an unsupported mechanism into one sentence. The question was valuable. The answer had erased the labels needed to evaluate it. The problem became personal during an audit of an earlier orbital PINN project. A result that looked like a dramatic model failure turned out to be a worse failure in the answer sheet: the legacy reference path went about 3,197 km inside Earth and missed the analytic trajectory by about 1,463.75 km, while the exported hybrid was about 1.02 km away. The model was limited, but the benchmark behind the headline was broken. That experience became NOETHER's method: preserve the question, predict before reveal, measure with independent machinery, and inspect the difference.

What it does

NOETHER is an interactive AI-literacy course and scientific playground. It teaches one reusable reflex: Before accepting a confident answer, ask what was compressed, make a prediction, run a test, and label what the result cannot establish. The public course moves through four connected acts: The Keyhole makes serialization visible. A cinematic thought graph is forced into a one-dimensional token stream; relationships are lost, merged, or reconstructed. THE BOUNDARY then contrasts lossy encoding with the structured boundary descriptions studied in black-hole thermodynamics and holography. A prepared case, THE BEAUTIFUL WRONG ANSWER, audits the hypothesis that inspired NOETHER: high-dimensional representation geometry survives; ReLU piecewise-linear regions survive only as a bounded statement; a “geodesic through human thought” remains analogy; and physics-forced hallucination is not established. The learner then runs a counterexample showing that fewer dimensions need not lose information when capacity and a shared codebook make exact reconstruction possible. The Detector turns intuition into play. Learners predict before changing a sealed bottle, firing Newton's cannonball, steering an Artemis-inspired mission, or bending light around a Schwarzschild black hole. Every success forks into VARY IT / CARRY IT / FREE PLAY instead of becoming a dead end. The Case tells the real June benchmark story before opening the Orbit Law Duel. A sealed, preregistered synthetic experiment then compares a structure-preserving Hamiltonian learner with a same-data unstructured baseline without choosing the winner in advance. The Question Lab lives in ChatGPT through the official Apps SDK and MCP. GPT-5.6 maps a learner's exact question into materially different meanings. The learner chooses. Five typed, read-only tools must then end with either a compatible playable world or a bounded Learning Probe specifying what to change, hold fixed, measure, predict, and reflect on. “Unsupported” is never the final activity, and an unrelated Orbit experiment is never substituted. Our deliberately narrow novelty is the complete chain: keyhole compression → an audit separating analogy from mechanism → prediction in a physics world → a named, audited real benchmark lie → live host-model tools under a constitution. NOETHER does not decide that an idea is true, grade a learner's intelligence, or treat GPT prose as numerical evidence. The learner owns the question and prediction; GPT owns interpretations and probe proposals; deterministic code owns calculations; named evidence owns only a scoped comparison.

How we built it

Codex was the primary implementation environment. The long-running CORE-CODEX-01 task contains the majority of the core build: product architecture, interactions, typed state machines, MCP server, Apps SDK widget, deterministic engines, numerical cross-checks, responsive visual systems, release tooling, and tests. The OWNER supplied the learning problem, scientific intuitions, prior projects, evidence boundaries, product verdicts, and repeated unbriefed first-touch feedback; Codex turned those judgments into executable acceptance criteria and working software. The standalone product uses TypeScript, React, Vinext, Cloudflare Workers/Sites, Canvas 2D, SVG, and self-hosted fonts. The ChatGPT companion uses the official OpenAI Apps SDK and Model Context Protocol. map_question returns interactive branch cards when the host supports widgets and a complete numbered transcript when it does not. The other tools validate concept bridges, supported world configurations, evidence challenges, and bounded Learning Probes. The server accepts no OpenAI API key, ChatGPT cookie, or account credential; ChatGPT hosts the model. Numerical authority stays outside the language model. The project includes Velocity Verlet and RK4 cross-checks, analytic Kepler references, domain gates, a deterministic Schwarzschild light-ray instrument, and a sealed CPU-float64 PINN/Hamiltonian comparison. The black-hole lesson now opens inside a live GPU-computed Schwarzschild ray field; the exact capture-edge experiment remains a separate measurement instrument with its own limits. Fable and Grok contributed adversarial planning and review. During an explicit, owner-authorized late polish window, Fable also implemented a bounded visual/copy pass for Hawking motion, Alcubierre flow, and the black-hole shader. CORE-CODEX-01 reviewed and integrated that work, added the final Boundary claim audit, and owns the validated release. Codex with GPT-5.6 remains the primary implementation task and model for the majority of the core functionality.

Challenges we ran into

The hardest challenge was not adding features; it was making every feature teach. Early builds were technically dense, visually impressive in places, and confusing to their own maker. Tiny controls, too many verbs, hidden stories, and dead-end question branches turned an Education entry into a filing cabinet. We rebuilt the product around one action at a time, worked examples before blank states, prediction-before-reveal gates, earned receipts, and an always-visible Free Play exit. We also had to keep spectacular visuals honest. The holography lesson cannot claim that string theory explains transformers. A pair-particle cartoon is not a derivation of Hawking radiation. A Schwarzschild disk is not a Kerr simulation. Those limits became visible labels rather than footnotes. Finally, browser animation uncovered a subtle production failure: requestAnimationFrame could freeze important scenes in background-tab conditions. We replaced timing assumptions with a visibility-safe wall-clock loop, added opt-in pixel-difference probes, and tested the actual public deployment instead of trusting local screenshots.

Accomplishments we're proud of

A working any-question loop that reaches a playable world or a designed Learning Probe instead of ending at “unsupported.” An Apps SDK branch-card widget with one-tap learner choice and a complete text fallback. A prediction-before-reveal architecture enforced by code, not motivational copy. A prepared claim audit that attacks the project's own founding hypothesis and preserves a useful intuition without promoting its false mechanism. A real audited benchmark failure presented as Case File No. 1, with the exciting but unsupported legacy headline quarantined. A preregistered six-run neural dynamics comparison whose frozen classifier returned STRUCTURED_ADVANTAGE, including all baseline escapes rather than dropping failed rollouts. An eight-chapter Black-Hole Flight spanning a live lensed universe and volumetric disk, pre-horizon decision, causal diagram, explicit Alcubierre counterfactual, animated Hawking future, Page-curve/island experiment, ER=EPR/no-signalling lesson, and deterministic Schwarzschild capture-edge instrument. 209/209 application tests and 15/15 MCP tests, plus clean typechecks, lint, production build, public motion probes, legibility checks, and a ten-question zero-dead-end matrix on the W5 release.

What we learned

Prediction-before-reveal is not a slogan; it has to be a state transition. A useful analogy is not a mechanism, and a lower-dimensional representation is not automatically lossy. The danger is under-specified compression followed by confident reconstruction without a check. A model can conserve energy and still learn the wrong thing. A low numerical error can hide a bad domain. A benchmark can be the weakest part of an evaluation. Fewer dimensions do not automatically imply loss: exact recovery can exist when enough capacity and a shared code are present. Without such a guarantee, the honest response is not panic or blind trust—it is to predict, measure, and inspect the diff. We also learned something about human–AI collaboration from building NOETHER itself. Tests could prove that a feature worked, but only a person using it without a script could reveal that it had no purpose. The product improved when human confusion became release-blocking evidence rather than feedback to explain away.

What's next

for NOETHER After Build Week, we want to test the course with students and teachers, study whether its receipts transfer to unfamiliar AI answers, and publish new Question Lab adapters only when they have honest measurement contracts. We also want to extend the scientific worlds carefully: Kerr rotation, stronger Hamiltonian baselines, richer mission dynamics, and educator-authored Learning Probe templates. A quote-backed Thought Atlas would preserve the source questions as a branching graph of derivations, analogies, conflicts, and open experiments instead of collapsing months of thought into one canonical summary. These are directions, not claims about the current release.

NOETHER — When compression breaks information, measurement catches the break.

NOETHER is an Education project for a specific AI-era problem: a confident answer can arrive before a learner has formed a prediction, compared meanings, or asked what evidence would separate them. It turns that missing thinking step into a playable method. It also features black holes, penrose diagrams, ER=EPR conjecture, alcubierre warp drives, M-theory, holography, string theory.

Public product: https://noether-intuition-lab.aanisakrasniqi.chatgpt.site

ChatGPT Apps SDK/MCP endpoint: https://noether-intuition-lab.aanisakrasniqi.chatgpt.site/api/noether

Release: Sites version 35 · runtime commit a0f0e17

Judges: start with the concise final release index and 60-second testing path.

Course promise: See what a linear answer can lose, learn how measurement catches the break, investigate a real broken answer sheet, then apply the detector to any question in ChatGPT.

The learning loop

The Keyhole — watch a structured thought become a one-dimensional stream. THE BOUNDARY then contrasts lossy encoding with physics cases where exact recovery depends on enough capacity and a shared structure. Its prepared Beautiful Wrong Answer case audits the project's own origin hypothesis—representation geometry survives, ReLU folds stay bounded, “thought geodesics” remain analogy, and physics-forced hallucination is not established.
The Detector — predict before changing a sealed bottle, firing Newton's cannonball, steering an Artemis-inspired mission, or bending light around a Schwarzschild black hole.
The Case — investigate a real June audit in which the “correct answer” was the broken part, then race a structure-preserving learner against a same-data baseline under a sealed protocol.
The Question Lab — use GPT-5.6 Sol inside ChatGPT to map an exact question into materially different meanings. The learner chooses; NOETHER must end at a compatible world or a bounded Learning Probe, never a silent Orbit substitute or terminal “unsupported.”

Every completed activity offers VARY IT / CARRY IT / FREE PLAY. Every teaching claim ends with a receipt stating what the learner can now inspect and what the activity cannot establish.

Why the AI is load-bearing—but not authoritative

The standalone course is account-free and deterministic. The ChatGPT face applies the method to an unrehearsed question through six typed, read-only tools:

map_question
  → learner chooses a branch
  → configure_world → PLAY THIS → run_world → measured outcome
  OR design_learning_probe

optional depth: bridge_concepts · challenge_claim

configure_world only validates a bounded setup; run_world is the deliberately separate action that executes the checked-in deterministic model after the learner accepts. It returns measurements, scope limits, and a link to the closest hands-on public world. “PLAY THIS” is therefore an action, not a decorative label or a promise that ChatGPT cannot fulfill.

map_question attaches an Apps SDK branch-card widget with a complete text fallback. GPT proposes meanings, bridges, and probe structure. It cannot choose the learner's prediction, set numerical tolerances, invent a reference, run generated code, or issue a truth verdict. NOETHER accepts no OpenAI API key, ChatGPT cookie, or account credential; ChatGPT hosts the model.

The evidence spine

The project's narrow novelty is the complete chain, not any one visual: keyhole compression → a claim audit that separates analogy from mechanism → prediction in a physics world → a named, audited real benchmark lie → live host-model tools under a constitution.

June Case File: a legacy orbital scenario placed periapsis about 3,197 km inside Earth. At one nominal orbit the exported hybrid was about 1.02 km from analytic Kepler, while the coarse legacy reference was about 1,463.75 km away. The dramatic model-failure headline is quarantined.
Sealed PINN-H-3 run: a preregistered synthetic altered-central-force comparison ran structured and baseline lanes at seeds 17/29/43. The frozen classifier returned STRUCTURED_ADVANTAGE; no escaped baseline rollout was dropped. It is not a general HNN victory or a new law of gravity.
Release gates: 209/209 application tests, 18/18 MCP tests, both typechecks, lint, production build, a ten-question zero-dead-end matrix, public motion probes, and public legibility checks.

The exact claim limits, hashes, and two still-open OWNER records are in EVIDENCE.md.

Spectacle with labels

Black-Hole Flight opens inside one live GPU-computed Schwarzschild ray field. Lensed stars, moving disk filaments, the capture silhouette, optional coordinate overlay, and bloom share the same bounded geodesic surface; adaptive quality keeps it moving. It is not DNGR, Kerr, GRMHD, or full radiative transfer, and the exact Light Bender remains the numerical capture-edge authority.
The One-Way Sky restores the animated Hawking temperature/power/lifetime lesson, the bounded pair-particle heuristic, and the unknown-endpoint label.
The Paradox lets the learner compare thermal-only output with a unitary Page-curve target and change entropy bookkeeping with an island. It teaches the live question; it does not solve it.
The Bridge follows those correlations into ER=EPR. The learner discovers that entanglement is neither an outside telescope nor a remote black-hole detonator, then opens a traversable window only inside a specially coupled two-sided AdS teaching model.
The Light Bender is the exact deterministic instrument: it integrates bounded Schwarzschild null-geodesic path shapes and lets the learner bracket the analytic capture edge.
The Alcubierre counterfactual visualizes metric surgery, negative-energy requirements, and the distinction between changing geometry and escaping an already-defined global event horizon.
THE BOUNDARY first attacks the project's own geometry/hallucination hypothesis, then lets the learner become the encoder and measure what five bare labels lose before adding the shared codebook that makes exact reconstruction possible.

Routes

Route	Purpose
`/`	Keyhole opening and deterministic course/world launcher; Mirror is an advanced surface
`/gravity`	Bottle pressure world and Newton's Cannonball
`/gravity/light`	The One-Way Sky, Light Bender, and the real Schwarzschild lens
`/orbit`	June Case File and neural Orbit Law Duel
`/mission`	Guided and free-play Artemis-inspired mission world
`/cosmos`	THE BOUNDARY interactive lesson
`/museum`, `/lab`, `/conservation`	Preserved advanced/historical surfaces
`/api/noether`	Official Apps SDK/MCP companion

How Codex was used

CORE-CODEX-01 is the primary implementation task and contains the majority of the core build; the task ran GPT-5.6 as its implementing model, and GPT-5.6 also powers the in-product Question Lab through the Apps SDK. Codex converted the OWNER's learning problem, scientific intuition, prior experiments, evidence boundaries, and repeated unbriefed product verdicts into:

typed learner state machines and prediction-before-reveal gates;
deterministic physics engines and independent numerical cross-checks;
the Apps SDK/MCP server, strict validators, widget, and complete fallback;
responsive Canvas/SVG learning worlds and visibility-safe animation runtime;
the sealed neural-dynamics pipeline, provenance manifests, and evidence quarantine;
public Sites releases, regression suites, release gates, and this claim registry.

Fable and Grok contributed adversarial planning and review. Under an explicit late owner grant, Fable also implemented a bounded final visual/copy pass covering Hawking motion, Alcubierre flow, and the black-hole shader transplant. CORE-CODEX-01 reviewed and integrated that pass, added the prepared Boundary claim audit, and owns the final validated release. This does not change the majority-core Codex attribution. The append-only rationale is in DECISIONS.md; executable status is in TASKS.md.

Repository guide

The judge-facing repository keeps the executable product and the records needed to audit it:

README.md, SUBMISSION.md, and OWNER-RUNBOOK.md explain setup, judging, and the final close;
EVIDENCE.md, PROVENANCE.md, and RELEASE.md bind claims to artifacts and release state;
DECISIONS.md, TASKS.md, and the curated reviews/ records preserve the build rationale.

Raw private chats, credentials, local assistant state, temporary recordings, and unrelated design drafts are deliberately excluded. More files are not more evidence when they expose private context or contradict the final release.

Run locally

Requirements: Node.js 22.13 or newer.

cd app
npm.cmd install
npm.cmd run dev

To run the isolated MCP companion:

cd mcp
npm.cmd install --ignore-scripts
npm.cmd test
npm.cmd start

Verify

cd app
npm.cmd test
npm.cmd run lint
npm.cmd run typecheck

cd ..\mcp
npm.cmd test
npm.cmd run typecheck

cd ..
node app/scripts/verify-pinn-h3-sealed-run.mjs

Prior work and claim boundary

NOETHER began during OpenAI Build Week and meaningfully extends two earlier owner-built experiments: an Earth–Moon browser simulator and an orbital PINN study. During the week, those artifacts were re-engineered into typed learning worlds with new pedagogy, a preregistered Hamiltonian comparison, corrected references, shared provenance, the Question Lab, and a connected course. Exact prior/new classification is in PROVENANCE.md.

NOETHER does not claim learning gains, literal visualization of model internals, a derivation of Hawking radiation, arbitrary-physics simulation, NASA endorsement, a discovered gravity law, or general Hamiltonian-network superiority. It shows who proposed what, what was measured, what failed, and over which named domain.

The remaining owner-only release sequence—post-W4 hosted exemplar, GATE O, /feedback, video, and Devpost close—is in OWNER-RUNBOOK.md.

Analysis

Compare with all teams

View

Metric

dlowzzxx
126
Claude Fable 5
24

Figures cover GitHub contributors during the hackathon window. A co-authored commit counts in full for each author, so per-member totals add up to more than the whole-team figures.

Technology

Found in codeClaimed only

CSSIn code
HTMLIn code
JavaScriptIn code
Next.jsIn code
PythonIn code
ReactIn code
Tailwind CSSIn code
TypeScriptIn code
Node.jsClaimed
PyTorchClaimed

8 of 10 appear in the indexed code. 2 claimed on Devpost could not be matched to code, which may simply mean the tool leaves no trace in the repository.

AI coding agents

Claude CodeCommits
CodexConfig

Detected from committed agent config files and commit authorship. Absence of a signal is not proof an agent was unused.

Codebase size

Source size

3.0 MB

Source files

267

Counts recognized source files only; vendored directories, binaries and lockfiles are excluded, so this is smaller than the repository on disk.