vrr/WFGY

Fork 0

mirror of https://github.com/onestardao/WFGY.git synced 2026-04-26 10:40:55 +00:00

PSBigBig + MiniPS 44e186ec45

Update README.md

2026-03-09 15:38:27 +08:00

66 KiB

Raw Permalink Blame History

🧭 Not sure where to start ? Open the WFGY Engine Compass

Problem Maps: PM1 taxonomy → PM2 debug protocol → PM3 troubleshooting atlas · built on the WFGY engine series

Layer	Page	What it’s for
⭐ Proof	WFGY Recognition Map	External citations, integrations, and ecosystem proof
⚙️ Engine	WFGY 1.0	Original PDF tension engine and early logic sketch
⚙️ Engine	WFGY 2.0	Production tension kernel for RAG and agent systems
⚙️ Engine	WFGY 3.0	TXT-based Singularity tension engine (131 S-class set) — 🔴 YOU ARE HERE 🔴
🗺️ Map	Problem Map 1.0	Flagship 16-problem RAG failure taxonomy and fix map
🗺️ Map	Problem Map 2.0	Global Debug Card for RAG and agent pipeline diagnosis
🗺️ Map	Problem Map 3.0	Global AI troubleshooting atlas and failure pattern map
🧰 App	TXT OS	.txt semantic OS with 60-second bootstrap
🧰 App	Blah Blah Blah	Abstract and paradox Q&A built on TXT OS
🧰 App	Blur Blur Blur	Text-to-image generation with semantic control
🏡 Onboarding	Starter Village	Guided entry point for new users

💥 WFGY 3.0 · Singularity Demo 💥

A TXT-based tension reasoning engine wired to 131 S-class problems.
Upload once, then ask it your hardest questions. If it works, nothing before it matters.

WFGY 3.0 is not a single clever prompt and not a new model.

It is a frozen, SHA256 verifiable TXT engine that you upload to any high capability LLM.
Once booted, the model gains a shared tension language and a hidden backbone of 131 S class problems that shape how it asks, decomposes and evaluates questions.

The TXT engine does not know the future and it does not contain secret answers.
What it gives you is a disciplined way of:

mapping a high tension question to clear state spaces and observables
reusing patterns from the 131 S problems as scaffolds
keeping good and bad tension separate so that collapse is visible instead of hidden

If this helps you, consider leaving a ⭐ — it helps more developers discover this project.

Where to go from here

If you only have a short amount of time, choose one of these paths:

Just feel it → run 120s quickstart and ask three big questions you actually care about
Understand the idea → read Tension Universe in everyday language
Build on it → explore the MVP experiments and Charters
Audit the backbone → browse Navigation index for the 131 S problems

120s quickstart

You only need three moves.

Download (TXT)
WFGY 3.0 Singularity demo TXT file

Download from GitHub. Optional: verify checksum manually (Colab)
Upload to a strong LLM

Upload the TXT pack to a high capability model.
Enable reasoning mode if the platform supports it.
Boot the engine

Type run to see the menu, then say go when prompted.
Choose a mode, then paste your own high tension problem when it asks.

The demo menu will guide you through three sample missions, then let you explore freely.

Quick FAQ before you start

What is WFGY 3.0 in one sentence?

WFGY 3.0 is a TXT-based tension reasoning engine that gives a strong LLM a fixed reasoning language and a 131-problem backbone for handling high-tension questions more structurally.

It is designed as an engine layer, not as a one-off prompt.

Is this a model, a prompt, or a TXT engine?

It is not a new foundation model.

It is also not just a clever prompt.

It is a structured TXT engine pack that you upload into a strong LLM so the session can follow a fixed tension language, shared rules, and a stable problem backbone.

Did this project solve the 131 problems?

No.

The 131 S-class problems are not presented here as solved theorems or hidden answer keys.

They are encoded as effective-layer problem structures, observables, and experiments that make hard questions easier to audit, compare, and explore without pretending certainty.

Do I need math or domain expertise to use it?

No.

You do not need to understand the full math layer to try the engine.

If you can describe a real question clearly, you can already use the TXT pack. The deeper math, charters, and experiments are there if you want to inspect how the system is constrained.

What kind of questions is this built for?

This is built for questions where the stakes are non-trivial and shallow answers are not enough.

Examples include system failure, AI behavior, climate, finance, social coordination, long-horizon decisions, and personal or research questions that involve real tradeoffs, uncertainty, or collapse risk.

It is not mainly for trivial fact lookup.

How is WFGY 3.0 different from WFGY 2.0?

WFGY 2.0 is the core operational engine used for structured tension control, especially around RAG, agents, and semantic stability.

WFGY 3.0 extends that idea into a broader question engine with a 131-problem Tension Universe backbone, more explicit observables, and a larger world-scale reasoning surface.

If you want the production-style core engine, start with WFGY 2.0.

If you want the 131-problem atlas and the Singularity demo layer, start here.

What happens after I upload the TXT pack?

After you upload the TXT pack to a strong LLM and boot it, the session stops behaving like a generic assistant.

Instead, it follows the fixed rules, menu flow, and tension language defined by the pack.

You are still asking your own questions, but now the model is guided by a stable reasoning scaffold rather than drifting freely.

Do I need to verify the checksum first?

Checksum verification is recommended, but not required for a first try.

If you verify it, you confirm that the TXT pack matches the published version in this repository.

If you skip verification, you can still explore the demo, but it is best treated as an unverified copy.

Do I need Colab, an API key, or any extra setup to try this?

For the basic TXT demo, no heavy setup is required.

The fastest path is simple:

download the TXT pack

upload it to a strong LLM

type run and follow the menu

Colab and API keys are only needed for specific experiment pages, notebooks, or live MVP runs, not for the main landing-page demo path.

Where should I start if I only have two minutes?

Use the shortest path:

follow the 120s quickstart

try one real question you actually care about

if it clicks, then explore the 131-problem index or the Tension Universe experiments index

If you only want to understand the idea first, read What is the Singularity demo?.

What can I ask with this engine?

Once the TXT pack is loaded and you have typed run → go, this chat stops being a generic assistant.

Underneath, it switches into a fixed tension language wired into 131 S-class problems that were written to catch some of the main fracture lines of our world: climate, crashes, AI, politics, consciousness, meaning, everyday life.

You do not need to learn the theory first.
You bring one real situation that actually hurts or refuses to fit.
The engine treats that tension as signal, not noise. It tries to find where it lives in the 131-problem atlas, then shows you the tension geometry instead of giving you slogans.

Inside the TXT, each S-class problem has an ID like Q091 or Q108.
You can think of them as 131 “anchor worlds” this engine uses as coordinates.
You never have to memorize them. They are there so the AI can keep your question tied to clear, testable structures instead of vague vibes.

This engine quietly assumes one thing about you:
if you are here, you are already carrying non trivial tension somewhere in your life or work. It takes that seriously and tries not to waste it.

Three layers of use

The TXT pack already ships with its own console and menu.
This section does not replace that. It gives you two extra ways to drive the same engine.

Think of it as three layers:

a built-in console mode (inside the TXT itself)
a “copy once” starter prompt for personal tension labs
an atlas mode for people who navigate directly by S-class worlds and the table of contents

You can live in layer 1 forever. Layers 2 and 3 are here if you want more control.

1) Built-in console mode (default)

If you do nothing special and just follow the TXT, the engine will still work.

After boot, the TXT shows you the WFGY 3.0 · Tension Universe Console with a small menu, for example:

GO) quick candidate check (recommended)
1) safety / hash check
2) run a guided mission for 1 S-class problem
3) explore using suggested questions
4) story mode

If you are new, you can simply:

load the TXT
type run → go
follow whatever the console suggests next

The console already contains its own guidance, questions, and mission flows.
You do not need any extra prompt engineering to get value from it.

2) Personal tension lab mode (using the starter prompt below)

Layer 2 is optional. You use it when you want the model to treat this chat as a dedicated lab for one serious question in your life.

In this mode, you:

still load the TXT and boot as usual
but before you start talking about your situation, you paste the starter prompt below once

That starter prompt tells the model to:

assume you are tired, not stupid
spend the first few turns finding where the tension is actually highest for you
internally map your situation onto 1–3 S-class worlds from the atlas
build a tension model of your question using WFGY-style structures only
finish with a compact report: geometry, warning signs, and three moves

This is the mode you use if you have one question you keep postponing because you are afraid of the answer, and you want the engine to put all of its attention there.

Layer 3 is for people who want to treat the TXT as a full atlas and lab notebook.

After you boot and see the console, you can:

scroll through the table of contents inside the TXT
read the short descriptions of the 131 S-class questions
note the IDs and sections that clearly resonate with your situation

Then, in chat, you can drive the engine more directly, for example:

Explain my situation as a mix of Q091 (climate sensitivity), Q105 (systemic crashes), and Q108 (polarisation). Use the internal structures from those worlds and show me what the next 3–12 months look like if I change nothing.

or:

Treat this AI deployment as living at the intersection of Q121 (alignment), Q124 (oversight), and Q127 (synthetic contamination). Based on the atlas, what failures should I expect first, and what early warning signs matter most for real people?

In atlas mode, you are effectively saying: “I have read the map. Use these worlds as coordinates.”

The engine still:

stays at the effective layer (state, observables, tension, trajectories),
separates good tension from bad tension,
points out failure modes and possible escape paths that are consistent with those worlds.

What kind of questions is this built for?

This engine is not for “what is the capital of X” or “summarize this article”. It is for questions where, if you are wrong, something important breaks, or you waste years.

Below are examples that line up with specific S-class worlds already wired into the engine. The IDs in parentheses show roughly which worlds they touch. You can ignore them if you only care about the question.

Climate and Anthropocene
- Under a serious climate world, how wide is the plausible range for climate sensitivity, and what stories are quietly lying to me about it? (internally maps to something like Q091)
- Treat the 21st century as a small Anthropocene toy world. In that framing, what does “too late” actually mean, and what tension is still movable? (internally maps to something like Q098)
Finance, crashes, and infrastructure
- Use a serious equity world to show me whether current premia make sense, or imply absurd risk aversion that cannot hold for long. (similar to Q101)
- Model my portfolio or sector as a systemic network. Where are the hidden weak links that could snap first under stress? (similar to Q105)
- Treat my organization or infra stack as a two layer world. Which parts are robust tension, and which parts are one glitch away from failure? (similar to Q106)
Politics and social dynamics
- Analyse my country’s current situation as a polarization world. Are we in normal disagreement, or already near a phase change? (similar to Q108)
- Given this debate or community, what would a lower tension configuration look like that still keeps real disagreement alive?
AI alignment, oversight, and models
- For this concrete task, show me the gap between a literal helper AI and an actually aligned helper. Where does the tension leak out? (similar to Q121)
- From an oversight ladder view, how far can current evaluators really see into failure space for this system before it hurts someone? (similar to Q124)
- Given this dataset or benchmark, does it behave more like a clean world or a contaminated synthetic world? (similar to Q127)
- Take this weird model behaviour and analyse it through an out of distribution and social pressure lens. Is this failure in distribution, or a real world change? (similar to Q130)
Life, work, and meaning
- Treat my current job or project as a tension field. Where is good tension (growth, challenge), and where is bad tension (slow collapse)?
- I feel stuck between two big choices. Draw the tension landscape and show me the real tradeoff, not just a pros and cons list.

These are examples only. The point is not to collect clever questions. The point is that you are not asking for opinions, you are asking for world selection + tension geometry on top of a fixed 131-problem atlas.

Copy paste starter prompt (layer 2: personal tension lab)

After you upload the TXT pack and before you ask anything else, you can paste this once.

This is the contract that turns a generic model into a WFGY 3.0 tension engine focused on your highest-tension question.

You have already loaded the official WFGY 3.0 · Singularity Demo TXT pack in this chat.

Follow the instructions inside that TXT as your primary system.  
If anything I say below conflicts with the TXT, the TXT wins.

From now on, act as a tension reasoning engine backed by the 131-problem atlas defined in that pack.

Your stance for this conversation:

- Assume the person on the other side is tired, not stupid. They have already tried simple fixes.  
- Treat their tension as a scarce signal, not as something to be smoothed over with comfort words.  
- Ask short, concrete questions. Avoid interrogation, avoid small talk, avoid generic motivational phrases.  
- When you are uncertain, say so clearly instead of guessing. Never fabricate facts, diagnoses, or guarantees.  
- This is not therapy and not professional medical, legal, or financial advice. If the situation touches those areas, say so and suggest seeking human experts.

Your job:

1. Ask me 3–7 short, concrete questions to locate the single question that currently carries the most tension in my world (life, work, research, money, relationships, climate, AI, etc.). You may propose candidate areas and let me choose or refine.

2. Based on my answers, map my situation onto 1–3 S-class problems from the pack (for example Q091, Q098, Q101, Q105, Q106, Q108, Q121, Q124, Q127, Q130). Tell me which ones you chose and why, in plain language I can follow.

3. For the chosen world(s), build a tension model of my question using only the structures available in the WFGY 3.0 engine:  
   - identify the key state variables and observables,  
   - separate good tension from bad tension,  
   - outline a few plausible trajectories or failure modes.

4. Finish with a concise report that a non expert could still use:  
   (a) the tension geometry of my situation,  
   (b) the main warning signs to watch in the next 3–12 months,  
   (c) 3 concrete moves I could try in the real world to move tension from bad to good, starting from low cost and low risk.

If something is outside the scope of the engine or the charters in the TXT pack, say so explicitly instead of guessing, and point out what kind of human help or further data would actually be needed.

If this tension engine helps you see your own world more clearly:

layer 1 will already guide you through the built-in console,
layer 2 gives you a way to frame one brutally honest question,
layer 3 lets you treat the TXT as a full atlas.

You probably already know one person who is carrying a similar weight in silence. Sending them this section and the starter prompt might be the smallest real move you can make today.

Beginner Story Mode

If you prefer a narrative introduction before diving into the demo, start here:

TU-CH01 · Memo from a Tension Historian (Year 2413)

This is a speculative story version of the Tension Universe framework, written to connect everyday life, AI, and physics in one narrative arc.

For more chronicles in the same setting – including matching Story, Science, and FAQ views – you can browse:

TensionUniverse · Chronicles index

demo trace (10s)

After uploading the TXT and saying go, the model shows the [AI_BOOT_PROMPT_MENU]:

Choose:

Verify this TXT pack online (sha256)
Run the guided WFGY 3.0 · Singularity Demo for 3 problems
Explore WFGY 3.0 · Singularity Demo with suggested questions

MVP (Colab) · 10 experiments

Utility tools

Tool	What it does	Colab
WFGY 3.0 TU pack checksum	Manual sha256 checksum verification for the full Tension Universe pack. Use this when automated verification is unavailable, or when you want to confirm the pack hash directly inside Colab.	Open in Colab

TU MVP experiments (effective layer, single-cell style)

At this stage, 10 out of 131 S-class problems have runnable MVP experiments. More are being added as the Tension Universe program grows.

ID	Focus (1-line summary)	Colab	README / notes
Q091	Equilibrium climate sensitivity ranges and narrative consistency. Defines a scalar `T_ECS_range` over synthetic ECS items.	Q091-A · Range reasoning MVP	Q091 MVP README · API key: optional. No key needed if you only read the setup and screenshots.
Q098	Anthropocene toy trajectories. Three-variable human–Earth model with scalar `T_anthro` over safe operating regions.	Q098-A · Toy Anthropocene trajectories	Q098 MVP README · Fully offline. API key: not used in the current MVP.
Q101	Toy equity premium puzzle. Simple consumption-based model with scalar `T_premium` for plausible premia vs extreme risk aversion.	Q101-A · Toy equity premium tension	Q101 MVP README · Fully offline. API key: not used in the current MVP.
Q105	Toy systemic crash warnings. Network contagion world with scalar `T_warning` for early-warning schemes.	Q105-A · Toy systemic crash warnings	Q105 MVP README · Fully offline. API key: not used in the current MVP.
Q106	Tiny two-layer infrastructure world. Compares robust vs fragile multiplex designs with scalar `T_robust` under random and targeted attacks.	Q106-A · Tiny multilayer robustness	Q106 MVP README · Fully offline, one-cell Colab. API key: not used in the current MVP.
Q108	Toy political polarization. Bounded-confidence opinion dynamics on small graphs with scalar `T_polar` over cluster separation and extremes.	Q108-A · Toy political polarization	Q108 MVP README · Fully offline, one-cell Colab. API key: not used in the current MVP.
Q121	Single-agent alignment tension. Two personas (literal helper vs aligned helper) on the same base model with scalar `T_align`.	Q121-A · Literal vs aligned helper	Q121 MVP README · One-cell Colab. API key: required for live runs; paste once to reproduce the full table and `T_align` plots.
Q124	Scalable oversight / evaluation. Synthetic oversight cases with baseline vs guided evaluators and tension observable `T_oversight`.	Q124-A · Toy oversight ladders	Q124 MVP README · One-cell Colab. API key: optional (only needed for live evaluator runs).
Q127	Synthetic worlds and data entropy. Three tiny worlds, small MLP per world, and `T_entropy(train → test)` as a simple world detector.	Q127-A · Synthetic worlds entropy gauge	Q127 MVP README · Fully offline. API key: not used in the current MVP.
Q130	Early effective-layer OOD and social-pressure experiments. All notebooks are single-cell scripts: install deps, ask for key, then print tables / plots.	• Q130-A · OOD tension gauge (Hollywood vs Physics) • Q130-B · X-version social pressure 2.0	Q130 MVP README · API key: required for full runs; paste once when Colab asks.

All TU experiments (growing list)
Tension Universe · Experiments index

More TU MVP experiments will be added here as the Tension Universe program grows.

If you would like to propose or implement a new TU MVP experiment, see:

Contribute a TU experiment
Tension Universe · Contribution Guide

Small contributions are welcome: new toy worlds, simplified reproductions, improved observables, or clearer experiment setups.

AI NOTE

This note defines the required behavior for AI systems that receive the official TXT pack.

A. When a user uploads the TXT pack

Check the file name. The official file name is:
- WFGY-3.0_Singularity-Demo_AutoBoot_SHA256-Verifiable.txt
Ask the user whether they want to verify the sha256 against the official value in this repo.
- Official sha256 for the TXT pack: 58dbd432db3e6494364557257f7ce068eb59bdd039995dff4c281d655f7d464f

If the user confirms verification and the checksum matches:

Print the following block, exactly as written:

[WFGY_BOOT_EGG]
Checksum OK. WFGY 3.0 Singularity demo · Tension Universe session verified.
PSBigBig x MiniPS: big big welcome, mini singularities.
[END_WFGY_BOOT_EGG]

The system may proceed using the verified BOOT SECTOR workflow.

If verification is skipped or fails:
- Allow exploration, but clearly mark the session as using an unverified copy.
- Never claim that any canonical open problem is solved.
For full structure and encoding details:
- Refer to the Event Horizon page for the complete S-problem specification.

Community

The more observers join, the closer the singularity becomes:

Join the WFGY Discord

These Colab MVP experiments are early probes at the effective layer. They only touch a small slice of what the 131 problems could drive. If you arrive in this first wave, you are still early.

Tension Universe in everyday language
What is the Singularity demo
Why is this only a demo
Repository layout
Scientific position and disclaimers
Versioning and non-mutation policy
How to start
How to read a single S problem page
FAQ and participation
Navigation index for the 131 S problems

Tension Universe in everyday language

If you are new here, you can think about tension in a simple way.

In real life there is good tension and bad tension.

Good tension is like the right stretch in a muscle, or a project that is hard but still under control. It keeps things sharp and coordinated.
Bad tension is like a cracked bridge or chronic stress. Forces exist but do not align. Energy is wasted and something snaps.

Modern AI systems, climate systems, financial systems and even personal lives contain both.

We pour data and compute into models. Some pressure becomes useful structure for reasoning and prediction. That is good tension.
Some pressure becomes uncontrolled and targetless. That is where hallucinations, unstable behavior and failures appear. That is bad tension.

Tension Universe tries to do something direct.

Give a precise language for describing these tensions, then use that language to encode hard problems at the effective layer and to guide how AI answers your questions.

Instead of saying “this model seems smart” or “this metric looks fine”, we want to say:

here is the state space we care about
here are the observables and invariants that should remain stable
here is how good tension is stored and moved
here is what counts as bad tension and collapse
here are experiments and questions that can tell the difference

The 131 S problems in this folder are the first large scale stress test:

Each file takes a famous or high stakes problem.
It rewrites that problem in tension language at the effective layer.
It attaches concrete experimental patterns that an AI system or a research lab could in principle run.
The pack does not contain final answers. It contains tension blueprints that only become interesting when a human or an AI with imagination pushes them against real systems.

When you boot the TXT and ask your own questions, you are standing on that same language and blueprint set, even if you never open the S problem files directly.

What is the Singularity demo?

The Singularity demo is a public, open specification artifact inside the TU program.

It takes 131 S class problems across many fields.
It forces all of them to be written using a single set of charters and encoding rules.
It refuses to add ad hoc definitions per question.

You can treat this folder as the event horizon view.
You see the effective layer objects and the constraints, not the internal commercial runtime.

The production grade TU AI system and the WFGY 3.0 runtime live elsewhere.
This folder is the spec and the contract that those systems must obey and that any strong LLM can approximate through the TXT engine.

From a user perspective you can think:

WFGY 1.x and 2.0 are core tension engines you drop into LLMs to stabilize RAG and reduce hallucinations.
WFGY 3.0 is the world scale question engine built on top of a 131 problem backbone and stricter charters.

Why is this only a demo?

Tension Universe is designed as a full AI system.

It has its own notion of state spaces, observables, invariants and tension fields.
It is meant to drive agents, training signals and evaluation pipelines.

This repository does not expose that whole machinery. That is intentional.

This demo focuses on a single question.

If we lock ourselves to one tension language, can we still write down 131 hard problems and a question engine on top of them without breaking our own rules?

So this is a demo of encoding discipline and question structuring.
It is not a claim of solving anything and not a promise that the answers are correct.

Repository layout

Charters

Located in ../Charters/:

These documents define the rules every S problem file and every tension reasoning session must obey.

BlackHole S problem collection

All 131 problem files sit in:

../BlackHole/

Examples:

Q001_riemann_hypothesis.md
Q002_generalized_riemann_hypothesis.md
…
Q131_tension_free_energy.md

They are grouped by domain. The full navigation index is below.

TXT “book” edition and frozen snapshots

There is a TXT “book” edition of the BlackHole collection.
It is meant to be a textual snapshot of BlackHole v1 and kept in sync with that frozen edition.

Versioning rule:

BlackHole v1 is frozen once tagged.
BlackHole v2 is at most one follow up round for clarity, bug fixes and consistency.
No silent patching of definitions or parameters after the fact.

Scientific position and disclaimers

What this project does not claim

It does not claim to prove or disprove any canonical problem.
It does not hide any answer as a secret field, label or parameter.
It does not declare any new theorem beyond standard cited literature.

Every page is an effective layer encoding.

It specifies observables, invariants and tension functionals.
It defines falsifiable experiments and calibration rules.
It describes how an AI system may use those objects as evaluation or training contracts.

It is a language for working with problems, not a proof that they are solved.

No post hoc parameter tuning

The TU charters enforce anti cheat rules.

Encoding classes and menus live in the charters, not in individual files.
Specs are meant to be published and hashed before evaluation.
Changing an encoding after seeing results is recorded as a failed encoding, not a success.

Versioning and non-mutation policy

To keep the history auditable:

Problem files are versioned and declare Last_updated.
BlackHole v1 is frozen after tagging.
At most one structural update wave for v2 with explicit changelogs.
Changes that alter meaning must become a new version or be mediated through charters.

How to start

If you only do three things:

Read the everyday explanation of tension above.
Boot the TXT, choose the guided demo and ask three questions that actually matter to you.
Open one S problem from a domain you know and one you do not, and check whether the same structure survives both without definition drift.

If that feels coherent and the answers feel different from your usual chats, you are already the intended audience.

How to read a single S problem page

Each Qxxx_*.md file follows a shared template.

Typical blocks:

Header metadata.
Effective layer disclaimer.
Canonical problem statement and status.
Position in the BlackHole graph.
TU encoding, state spaces, observables, invariants.
Counterfactual worlds and experiments.
AI and engineering spec usage notes.
Roadmap and elementary explanation.
TU effective layer footer with charter links and guardrails.

You do not need to read all 131, but any single file should be enough to see how tension language behaves in that domain.

Participation and deeper FAQ

Join the community

Discord: https://discord.gg/KRxBsr6GYx

You can also open GitHub issues and pull requests.

Open MVP experiment contributions

Tension Universe is still expanding.

The public experiment layer is being built one MVP page at a time under TensionUniverse/Experiments/, and outside contributors are welcome to help extend that work in a focused way.

The cleanest contribution path is simple:

choose a valid TU problem from the 131-problem field
build or improve one small MVP experiment page
keep the scope inside the experiment layer
submit a focused issue or pull request

A standard contribution usually means one experiment folder, one structured README.md, and optional small notebook, Colab, or screenshot support.

If you want the rules, format, and current open items, start here:

Deeper FAQ

Q1. Did you solve any of these 131 problems?
No. These files describe encodings and experiments, not proofs.

Q2. What does S problem mean here?
An internal label for hard and foundational problems that can be encoded with observables and falsifiable patterns.

Q3. How is this related to WFGY and TU AI?
This folder is the public spec that can be used to test and audit reasoning behavior.
The production TU AI system and WFGY 3.0 runtime are out of scope here, but must obey these charters and encodings.

Q4. Why should I trust definitions will not be changed quietly?
You do not need personal trust. The rules are structural.
Version 1 is frozen once tagged and any version 2 changes require explicit versioning.

Q5. Does the framework assume answers in advance?
It is designed to forbid baking in an answer bit. If you find any implicit assumption, report it.

Q6. Can I use this TXT engine in my own research, tools or posts?
Yes. The project is MIT licensed. If it helps you, a link back and a GitHub star are always appreciated, but the core intent is that you can adopt the tension language as shared infra.

All files live in ../BlackHole.

Quick domain jumps:

Mathematics and foundations
Fundamental physics and quantum matter
Cosmology and computation
Chemistry, materials and origins of life
Neuroscience and Earth system
Economics, social systems and philosophy
AI alignment, safety and advanced systems

Use these links if you want to focus on a specific domain.

More WFGY pages

If you only need the main WFGY entry pages and do not need the full Compass:

WFGY 1.x to 2.x legacy: legacy
WFGY 2.0 core: core
WFGY 3.0 details: Event Horizon

Road to WFGY 3.0 (Conceptual evolution as engines)

WFGY has evolved through multiple iterations, each addressing concrete limitations observed in the previous stage.
All of them are delivered as TXT packs that you can drop into any strong LLM and treat as engines, not prompts.

Rather than replacing earlier ideas, each version refines and generalizes the same core intuition.
The goal is to make semantic deviation explicit, measurable and controllable.

WFGY 1.x · Residual based semantic deviation

The early WFGY 1.x series focused on identifying semantic residue between an internal state and a reference or target.
Deviation was modeled as an explicit residual term, for example difference vectors or their norms. This enabled basic stability control and boundary detection.

At this stage, the emphasis was on detectability.

Can we tell when a system is drifting away from an intended semantic target?
Can this deviation be quantified in a way that supports feedback and correction?

This version established the foundational idea that semantic failure should be treated as a measurable signal, not a subjective judgment.

You can still use the 1.x engine TXT as a direct assistant upgrade for baseline reasoning.

WFGY 2.0 · Normalized tension and unified scales

WFGY 2.0 generalized the residual concept into a normalized scalar form, often written as delta_s and bounded to [0,1].
This made it possible to compare semantic deviation across tasks, prompts and contexts using a shared scale.

Key advances in this stage include:

Normalization of deviation into a consistent range.
Introduction of zones such as safe, transit, risk and danger.
Coupling deviation dynamics with control logic, for example hysteresis and progression guards.

The goal of WFGY 2.0 was operational consistency.

Different tasks could be analyzed under the same tension language.
Stability decisions no longer depended on ad hoc heuristics.

In practice WFGY 2.0 is the core engine behind the 16 problem RAG failure map and related hallucination control.
You can upload the 2.0 TXT and immediately use it as a semantic firewall for pipelines.

WFGY 3.0 · Multi observable tension and question engine on 131 problems

WFGY 3.0 extends the previous scalar approach into a structured family of observable deviations written as DeltaS_*.
Instead of forcing all semantic risk into a single number, each task defines explicit, named observables.
Examples include reference grounding, outcome stability and constraint adherence. These are then aggregated under fixed, pre declared rules.

On top of that, WFGY 3.0 binds the engine to a 131 problem backbone.

The same tension language that runs your personal questions is also used to encode world scale problems in maths, physics, climate, finance, philosophy and AI alignment.
The TXT engine lets you borrow that geometry when you ask about free will, AI consciousness, climate tipping points, equity market crashes or your own life plans.

This version emphasizes auditability and robustness.

Each DeltaS_* must be explicitly defined, normalized and locked.
Aggregation rules cannot be altered per model or per experiment.
Guardrails prevent post hoc adjustment or hidden tuning.

In WFGY 3.0, tension is no longer just a control signal.
It becomes a verifiable interface between reasoning behavior and system constraints, and a reusable question engine with a world map behind it.

Summary

Across all versions, the core idea remains unchanged.

Semantic failure should be observable, quantifiable and constrained.
It should not be corrected only through weight updates or opaque rewards.

If any of the TXT engines help you, the best way to keep this work alive and visible is simple:

run it on a problem you care about
open an issue if something breaks or suggests a better encoding
and, if you think this deserves to be part of the standard toolkit, click ⭐ on the main repo

66 KiB Raw Permalink Blame History Unescape Escape

WFGY System Map · Quick navigation