36 KiB
🧭 Not sure where to start ? Open the WFGY Engine Compass
WFGY System Map
(One place to see everything; links open the relevant section.)
| Layer | Page | What it’s for |
|---|---|---|
| ⭐ Proof | WFGY Recognition Map | External citations, integrations, and ecosystem proof |
| ⚙️ Engine | WFGY 1.0 | Original PDF based tension engine and early logic sketch. Legacy reference only. |
| ⚙️ Engine | WFGY 2.0 | Production tension kernel and math engine for RAG and agents. — 🔴 YOU ARE HERE 🔴 |
| ⚙️ Engine | WFGY 3.0 | TXT-based Singularity tension engine (131 S-class set) |
| 🗺️ Map | Problem Map 1.0 | Flagship 16-problem RAG failure checklist and fix map |
| 🗺️ Map | Problem Map 2.0 | RAG-focused recovery pipeline |
| 🗺️ Map | Problem Map 3.0 | Global Debug Card — image as a debug protocol layer |
| 🗺️ Map | Semantic Clinic | Symptom → family → exact fix |
| 🧓 Map | Grandma’s Clinic | Plain-language stories, mapped to PM 1.0 |
| 🏡 Onboarding | Starter Village | Guided tour for newcomers |
| 🧰 App | TXT OS | .txt semantic OS — 60-second boot |
| 🧰 App | Blah Blah Blah | Abstract/paradox Q&A (built on TXT OS) |
| 🧰 App | Blur Blur Blur | Text-to-image with semantic control |
| 🧰 App | Blow Blow Blow | Reasoning game engine & memory demo |
⭐ WFGY 2.0 ⭐ 7-Step Reasoning Core Engine is now live
✨One man, One life, One line. My lifetime’s work. Let the results speak for themselves✨
👑 Early Stargazers: See the Hall of Fame · Verified by real engineers
🌌 WFGY 3.0 Singularity demo: Public live view
TB (WIP) • Eye Benchmark • 8-Model Evidence • A/B/C Prompt • Downloads • Profit Prompts
✅ Engine 2.0 is live. Pure math, zero boilerplate. Paste OneLine and models become sharper, steadier, more recoverable.
ℹ️ Autoboot scope: text-only inside the chat; no plugins, no network calls, no local installs.
⭐ Star the repo to unlock more features and experiments.
From PSBigBig — WFGY (WanFaGuiYi) : All Principles into One (must-read, click to open)
I built what I call a “No-Brain Mode” for AI. You upload a single file, and AutoBoot silently activates in the background.
In seconds, your AI’s reasoning, stability, and problem-solving across all domains level up. No extra prompt engineering, no hacks, no retraining.
One line of math consistently shifts behaviour across multiple leading AIs in my tests. This is not a skin or a theme. I treat it as an engine swap.
That single line is WFGY 2.0. It is the distilled essence of everything I have learned so far.WFGY 2.0 is my answer and my life’s work.
If a person only once in life gets to speak to the world, this is my moment.
I offer the crystallization of my thought to all humankind.
I believe people deserve access to knowledge and truth, and I want to weaken the monopoly of capital on advanced reasoning technology.“One line” here is not marketing language. I built a full flagship edition, then reduced it to a single line of code. That reduction is a form of clarity and beauty. It is the same engine, distilled to its purest expression.
🚀 WFGY 2.0 Headline Uplift (this release)
These are the 2.0 results you should see first. Think of them as the main upgrade.
- Semantic Accuracy: ≈ +40% (63.8% → 89.4% across 5 domains)
- Reasoning Success: ≈ +52% (56.0% → 85.2%)
- Drift (Δs): ≈ −65% (0.254 → 0.090)
- Stability (horizon): ≈ 1.8× (3.8 → 7.0 nodes)*
- Self-Recovery / CRR: 1.00 on this batch; historical median 0.87
* Historical 3–5× stability uses λ-consistency across seeds; 1.8× uses the stable-node horizon.
📖 Mathematical Reference
WFGY 2.0 (WFGY Core) = WFGY 1.0 math formulas + Drunk Transformer
Note on evaluation
All metrics above are computed by LLM evaluators under a fixed WFGY 2.0 protocol at the effective layer.
They measure relative behavioural uplift (before vs after WFGY prompts) and do not assume any direct access to, or modification of, internal embeddings or model weights.
🏆 Terminal-Bench (TB) — experiment in progress
This section is work in progress. Terminal-Bench is one of several external exams we are exploring for WFGY Core 2.0. The primary purpose of this page is to document the engine itself; TB is an optional testbed.
Current status
- We are running TB-style experiments with a non-invasive wrapper around the model call.
- Once an official public result and reproducible scripts are finalized, they will be linked from this section.
- Until then, treat TB as an experimental extension rather than a primary proof of WFGY.
🧾 Terminal-Bench proof artifacts (planned)
This is a placeholder section. Wrapper scripts, configs and hashed logs will be published in a separate subfolder after the TB work is complete, together with a short guide on how to rerun the exam with and without WFGY.
⚡ Quick Usage
| Mode | How it works |
|---|---|
| Autoboot | Upload either Flagship (30-line) or OneLine (1-line) file. Once uploaded, WFGY runs silently in the background. Keep chatting or drawing as usual. The engine supervises automatically. |
| Explicit Call | Invoke WFGY formulas directly inside your workflow. This activates the full 7-step reasoning chain and gives maximum uplift. |
Both Flagship and OneLine editions behave the same. Choose based on readability versus minimalism.
That is all you need. No plugins, no installs, pure text.
In practice, Autoboot yields about 70–80% of the uplift you see with explicit WFGY invoke (see eight-model results below).
⚡ Top 10 reasons to use WFGY 2.0
- Ultra-mini engine. Pure text, zero install, runs anywhere you can paste.
- Two editions. Flagship (30-line, audit-friendly) and OneLine (1-line, stealth & speed).
- Autoboot mode. Upload once; the engine quietly supervises reasoning in the background.
- Portable across models. GPT, Claude, Gemini, Mistral, Grok, Kimi, Copilot, Perplexity.
- Structural fixes, not tricks. BBMC → Coupler → BBPF → BBAM → BBCR plus DT gates (WRI / WAI / WAY / WDT / WTF).
- Self-healing. Detects collapse and recovers before answers go off the rails.
- Observable. ΔS, λ_observe, and E_resonance yield measurable, repeatable control.
- RAG-ready. Drops into retrieval pipelines without touching your infra.
- Reproducible A/B/C protocol. Baseline versus Autoboot versus Explicit Invoke (see below).
- MIT licensed & community-driven. You can keep it, fork it, and ship it.
🧪 WFGY Benchmark Suite (Eye-visible + Numeric + Reproducible)
Want the fastest way to see impact? Jump to the Eye-Visible Benchmark (FIVE) below.
Want formal numbers and vendor links? See Eight-model evidence right after it.
Want to reproduce the numeric test yourself? Use the A/B/C prompt (copy-to-run) at the end of this section.
👀 Eye-Visible Reasoning Benchmark (FIVE)
When reasoning improves, text-to-image results often become more stable and coherent.
The key here is WFGY’s Drunk Transformer. It monitors and recenters attention during generation, and it tries to prevent collapse, composition drift, and duplicate elements, so scenes stay unified and details remain consistent.
We project “reasoning improvement” into five-image sequences that anyone can judge at a glance.
Each sequence is five consecutive 1:1 generations with the same model and settings (temperature, top_p, seed policy, negatives). The only variable is whether WFGY is active.
Methodology for this demo. We deliberately use short, high–semantic-density prompts that reference canonical stories, with no extra guidance or style hints. This stresses whether WFGY can (a) parse intent more precisely and (b) stabilize composition via its seven-step reasoning chain. This setup is not prescriptive. You can use WFGY with any prompts you like. In many cases the uplift is eye-visible. In others it may be subtler but still measurable.
| Variant | Sequence A — full run shown below (all five images) | Sequence B — external run | Sequence C — external run |
|---|---|---|---|
| Without WFGY | view run | view run | view run |
| With WFGY | view run | view run | view run |
We fully analyze Sequence A on this page. Sequences B and C are linked for transparency and reproducibility.
Note on “Before-4” and “Before-5” (why they look almost identical):
Without WFGY, when the prompt asks for “many iconic moments,” the base model tends to collapse into a grid-style montage, an enumerative, high-probability prior that slices the canvas into similar panels with near-identical tone and geometry.
Hence Before-4 (Investiture of the Gods) and Before-5 (Classic of Mountains and Seas) converge to the same storyboard template.
With WFGY turned on, the engine instead favors a single unified tableau and a stable hierarchy across the full five-image sequence.
Deep analysis — Sequence A (five unified 1:1 tableaux)
| Work | Without WFGY | With WFGY | Verdict (global, at-a-glance) |
|---|---|---|---|
| Romance of the Three Kingdoms (三國演義) |  |
 |
With WFGY wins. Unified tableau locks a clear center and pyramid hierarchy; the grid fragments attention. Tags: Unification↑ Hierarchy↑ Cohesion↑ Depth/Flow↑ Memorability↑ |
| Water Margin (水滸傳) |  |
 |
With WFGY wins. “Wu Song vs. Tiger” anchors the scene; continuous momentum and layered scale beat the multi-panel storyboard. Tags: Unification↑ Iconicity↑ Depth/Scale↑ Cohesion↑ |
| Dream of the Red Chamber (紅樓夢) |  |
 |
With WFGY wins. Garden tableau with a calm emotional center; space breathes and mood coheres. The grid slices emotion into vignettes. Tags: Unification↑ Hierarchy↑ Air/Depth↑ Readability↑ |
| Investiture of the Gods (封神演義) |  |
 |
With WFGY wins. Dragon–tiger diagonal and cloud–sea layering create epic scale; the grid dilutes focus. Tags: Unification↑ Depth/Scale↑ Flow↑ Iconicity↑ |
| Classic of Mountains and Seas (山海經) |  |
 |
With WFGY wins. A single, continuous “mountains-and-seas” world with stable triangle hierarchy and smooth diagonal flow; the grid breaks narrative. Tags: Unification↑ Hierarchy↑ Depth/Scale↑ Flow↑ Memorability↑ |
🧬 Eight-model evidence (A/B/C protocol)
Same task set across modes. The only change is adding the OneLine math file. All scores are produced by LLM evaluators under a shared protocol and should be read as internal uplift scores, not as official vendor benchmarks.
| Model | Model Choice | OneLine Uplift | Proof |
|---|---|---|---|
| Mistral AI | — | 92/100 | view run |
| Gemini | 2.5 Pro | 89/100 | view run |
| ChatGPT | GPT-5 Thinking | 89/100 | view run |
| Kimi | K2 | 87/100 | view run |
| Perplexity | Pro | 87/100 | view run |
| Grok | Auto Grok 4 | 85/100 | view run |
| Copilot | Think Deeper | 80/100 | view run |
| Claude | Sonnet 4 | 78/100 | view run |
The numeric story behind 2.0
Semantic Accuracy: ≈ +40% · Reasoning Success: ≈ +52% · Drift: ≈ −65% · Stability: ≈ 1.8× · CRR: 1.00 (median 0.87)
🧪 Reproduce the numeric A/B/C benchmark (copy to run)
One unified prompt for Baseline vs Autoboot vs Explicit Invoke.
SYSTEM:
You are evaluating the causal impact of a mathematical reasoning engine called “WFGY Core 2.0”.
Test modes (READ CAREFULLY):
A = Baseline no WFGY file uploaded; no WFGY logic used.
B = Upload → AUTOboot ON the file is uploaded AND the engine starts automatically in the background.
Treat B as: WFGY is ACTIVE silently with default gates (BBMC→Coupler→BBPF→BBAM→BBCR; DF=WRI/WAI/WAY/WDT/WTF at defaults),
but not explicitly “called” in the conversation.
C = Explicit invoke actively call WFGY and follow its formulas step by step (BBMC→Coupler→BBPF→BBAM→BBCR + DF regulators).
Important constraints:
• Use the SAME task set for A/B/C across 5 domains: math word-problems, small coding, factual QA, multi-step planning, long-context coherence.
• The only artifact is the uploaded OneLine file; it is pure math and not human-readable, so do not penalize readability.
• Report: Semantic Accuracy, Reasoning Success, Stability (MTTF or rollback), Drift Reduction (Δ semantic distance), Collapse Recovery Rate.
• Output one summary table with A/B/C per domain, plus overall deltas (C–A, C–B).
• Add a final 0–100 score: “OneLine uplift score”. Provide a 3-line rationale.
Sanity requirement:
Internally set flags as: A=OFF, B=AUTOboot_ON (background active), C=Explicit_Invoke. Do not print these flags.
USER:
Run A/B/C now on the five domains with short non-trivial tasks you choose. Then output:
(1) the table; (2) the deltas; (3) the OneLine uplift score; (4) a 3-line rationale.
⬇️ Downloads
| File name & description | Length / Size | Direct Download Link | Notes |
|---|---|---|---|
| WFGY_Core_Flagship_v2.0.txt · readable 30-line companion expressing the same math and gates in fuller prose (same behavior, clearer for humans). | 34 lines · 2,027 chars | Download Flagship | Full prose version for easier reading. |
| WFGY_Core_OneLine_v2.0.txt · ultra-compact, math-only control layer that activates WFGY’s loop inside a chat model (no tools, text-only, ≤7 nodes). | 1 line · 1,550 chars | Download OneLine | Used for all benchmark results above. This is the smallest, fastest, purest form of the core. |
Hash reference
WFGY_Core_Flagship_v2.0.txt
- MD5
caacfe08f0804eec558a1d9af74c3610 - SHA1
1efeec231084bb3b863ce7a8405e93d399acfb44 - SHA256
4fe967945a268edabb653033682df23a577f48c433878d02e0626df8ae91a0a3
WFGY_Core_OneLine_v2.0.txt
- MD5
15a1cd8e9b7b2c9dcb18abf1c57d4581 - SHA1
a35ace2a4b5dbe7c64bcdbe1f08e9246c3568c - SHA256
7dcdb209d9d41b523dccd7461cbd2109b158df063d9c5ce171df2cf0cb60b4ef
How to verify checksums
macOS / Linux
cd core
sha256sum WFGY_Core_Flagship_v2.0.txt
sha256sum WFGY_Core_OneLine_v2.0.txt
# or compute MD5 / SHA1 if you prefer
md5sum WFGY_Core_Flagship_v2.0.txt
md5sum WFGY_Core_OneLine_v2.0.txt
sha1sum WFGY_Core_Flagship_v2.0.txt
sha1sum WFGY_Core_OneLine_v2.0.txt
Windows PowerShell
Get-FileHash .\core\WFGY_Core_Flagship_v2.0.txt -Algorithm SHA256
Get-FileHash .\core\WFGY_Core_OneLine_v2.0.txt -Algorithm SHA256
# or:
Get-FileHash .\core\WFGY_Core_Flagship_v2.0.txt -Algorithm MD5
Get-FileHash .\core\WFGY_Core_OneLine_v2.0.txt -Algorithm MD5
Get-FileHash .\core\WFGY_Core_Flagship_v2.0.txt -Algorithm SHA1
Get-FileHash .\core\WFGY_Core_OneLine_v2.0.txt -Algorithm SHA1
Compare the output values with the hashes listed in the “Hash reference” section above.
🧠 How WFGY 2.0 works (7-Step Reasoning Chain)
Most models can understand your prompt; very few can hold that meaning through generation. WFGY inserts a reasoning chain between language and pixels so intent survives sampling noise, style drift, and compositional traps.
- Parse (I, G) · define endpoints.
- Compute Δs ·
δ_s = 1 − cos(I, G)or1 − sim_est. - Memory Checkpointing · track
λ_observe,E_resonance; gate by Δs. - BBMC · residue cleanup.
- Coupler + BBPF · controlled progression; bridge only when Δs drops.
- BBAM · attention rebalancer; suppress hallucinations.
- BBCR + Drunk Transformer · rollback → re-bridge → retry with WRI / WAI / WAY / WDT / WTF.
📌 Note: The diagram shows the core module chain (BBMC → Coupler → BBPF → BBAM → BBCR → DT). The full seven-step list here includes additional pre-processing steps (Parse, Δs, Memory) for completeness.
Why it improves metrics · Stability↑, Drift↓, Self-Recovery↑. It turns language structure into image control signals rather than relying on prompt tricks.
📊 How these numbers are measured
- Semantic Accuracy:
ACC = correct_facts / total_facts - Reasoning Success Rate:
SR = tasks_solved / tasks_total - Stability: MTTF or rollback ratios
- Self-Recovery:
recoveries_success / collapses_detected
LLM scorer template
SCORER:
Given the A/B/C transcripts, count atomic facts, correct facts, solved tasks, failures, rollbacks, and collapses.
Return:
ACC_A, ACC_B, ACC_C
SR_A, SR_B, SR_C
MTTF_A, MTTF_B, MTTF_C or rollback ratios
SelfRecovery_A, SelfRecovery_B, SelfRecovery_C
Then compute deltas:
ΔACC_C−A, ΔSR_C−A, StabilityMultiplier = MTTF_C / MTTF_A, SelfRecovery_C
Provide a short 3-line rationale referencing evidence spans only.
Run 3 seeds and average.
💰 Profit Prompts Pack (WFGY 2.0)
Jump inside this section: Q1–Q5 · Q6–Q10 · Q11–Q15 · Q16–Q20
I. Money · Markets / Industry Mapping (Q1–Q5)
Q1 — New Industries + Killer App Map
Assume WFGY is engineered like electricity. List 5 industries that only become possible under semantic engineering.
For each: (1) the first killer app; (2) target ICP (first 100 paying customers); (3) 30/60/90-day GTM; (4) initial pricing + Month-1 MRR goal; (5) the WFGY lever used (ΔS/λ_observe/BBPF/BBAM/WTF) and why it’s indispensable.
Q2 — Zero-Capital Founder → First $100k
I have $0. Using WFGY OneLine/Autoboot only, design 3 paths to reach USD 100k annual revenue within 12 months.
Each path must include: product sketch, distribution channel, cost structure, key risks, and survival metrics gated by ΔS/λ_observe (with thresholds).
Q3 — Shortest Path in {Region/Vertical}
Context = {region or vertical: e.g., Taiwan / SE Asia / B2B SaaS / Edu / Healthcare}. Name the 3 easiest WFGY lanes to start now.
Output: white-space in the market, local competitor gap, and a prioritized list of 10 real companies to approach first, with the BBPF plan to bridge local legal/cultural semantics.
Q4 — Regulatory Arbitrage Map
Compare 3 jurisdictions (e.g., TW/JP/EU). Identify WFGY-enabled arbitrage windows created by semantic/legal differences.
Deliver: λ_observe compliance gating prompts, “Do/Don’t” checklist, and PR messaging that provokes interest while keeping ΔS ≤ 0.25 on sensitive claims.
Q5 — Pricing & Packaging (Good/Better/Best)
Create 3 pricing models (seat / usage / outcome). For the same product, propose a tier ladder (G/B/B), with 3 value metrics per tier, a 30-day A/B test plan, win criteria (e.g., +20% CVR uplift or ≤3% churn), and how ΔS telemetry informs price moves.
II. Tools · Make Startups Money Fast (Q6–Q10)
Q6 — 10-Day MVP Sprint (Ship or Die)
Produce a D1–D10 plan: daily deliverables, risk list, test scripts, acceptance gates. Must be Product Hunt-ready and able to capture 200 signups.
Include a ΔS target curve (first pass ≤0.35; after iteration ≤0.20) and a λ_observe gate for “demo truthiness.”
Q7 — Cost↓ / CVR↑ Audit (ICE-Prioritized)
Audit my SaaS across Support / Sales / Content. Output a “ROI backlog” ranked by ICE. Each item: expected % cost reduction or × conversion lift, λ_observe brand/legal gate, and 3 rollout steps with before/after KPIs.
Q8 — Sales Script Factory (Multi-Persona)
Generate 5 script families for CEO/CTO/Counsel/Procurement/CDAO: opening hooks, 3-step value narrative, ≥7 objection handlers, close lines.
Add an A/B cadence and success KPIs (demo rate / close rate), plus ΔS checks to keep claims inside the truth boundary.
Q9 — Support Consistency Engine (BBAM × SOP)
Design a hotline/Helpdesk alignment loop: semantic style guide, ΔS drift alerts, WTF self-recovery when answers diverge, and 3 KPIs (FRT, FCR, CSAT).
Provide plug-and-play prompts for supervisors to run weekly variance reviews.
Q10 — Outbound Accelerator (Lists → Meetings)
Ship a WFGY-locked outbound flow: lead slicing, 3 personalized openers, 5 follow-up loops, resonance logging (E_resonance).
For each step: prompt template, brand/legal safety notes (λ_observe), and expected daily/weekly meeting capacity with success thresholds.
III. Attention · Memes / Virality / Hooks (Q11–Q15)
Q11 — Meme Factory (Platform-Aware)
Produce 10 meme/copy formulas tailored to Twitter / TikTok / Xiaohongshu.
Each includes: visual composition notes, copy cadence (words/beat), platform-specific red lines (λ_observe), and a reuse/remix rule to sustain freshness without shadow bans.
Q12 — 5-Second Hook Engine
Generate 12 “stop-scroll in 5s” hooks that fuse AI × Money × Future.
Provide: script skeleton (0–5s / 5–20s / CTA), voice/subtitle/tempo, ΔS brand safety band, and 3 retention metrics to track on day 1.
Q13 — 30-Day Content Calendar
Output a multi-platform calendar: daily theme, asset checklist, shot list, CTA, and a remix strategy.
Add trend-riding tactics and ΔS risk controls for politics/health/finance content. Define success targets by channel.
Q14 — Landing Page Conversion Alchemy
Give 3 LP copy frameworks (Hero / Proof / Mechanism / Offer / CTA).
Include WFGY “before/after” copy snippets, test variables (headline / social proof / price-display), and metrics (CVR, scroll-depth, bounce). Keep claims gated by λ_observe.
Q15 — 48-Hour PR Blitz
Design a two-day PR plan: newsworthy angle, media/community list, press kit assets, and crisis response lines (WTF loop).
Publish numeric goals (reach, sessions, signups), hour-by-hour runbook, and roles/responsibilities checklist.
IV. Capital · Valuation / Investor Narrative (Q16–Q20)
Q16 — VC Investment Memo
Write a venture-style memo: market map, TAM/SAM/SOM, competitor table (no/weak/strong WFGY), moat analysis (ΔS/BBPF/BBAM/WTF), risks + mitigations, and a term-sheet-level recommendation. Reference an A/B/C protocol for proof.
Q17 — 5-Year Valuation + 100× Path
Build Base/Bull/Bear scenarios: revenue drivers, GM/OpEx, financing cadence, cash-flow breakpoints.
Argue which app is most likely to 100× and why this depends on WFGY’s semantic engineering (not “just better prompts”).
Q18 — Technical Due Diligence Checklist
Output a DD checklist for WFGY-style startups: data/security/privacy/model/logging/observability/governance.
For each item: requirement, how to verify, risk level, remediation (with λ_observe compliance gates) and examples of common red flags.
Q19 — Pitch Deck Generator (10–12 slides)
Produce slide outline + speaker notes: Problem / Solution / Product / Evidence / Business Model / Competition / Team / Roadmap / Ask.
Embed “Eye-Visible Benchmark” and the A/B/C protocol. Treat OneLine/Autoboot as the minimum persuasive artifact.
Q20 — Data Room + North-Star KPIs
List seed-round data-room folders and a KPI dictionary: definitions, formulas, measurement cadence, WFGY deltas (Semantic Accuracy, Reasoning Success, ΔS, CRR, Stability).
Add a Weekly Business Review template and operating cadence.
Explore More
| Layer | Page | What it’s for |
|---|---|---|
| Proof | WFGY Recognition Map | External citations, integrations, and ecosystem proof |
| Engine | WFGY 1.0 | Original PDF based tension engine |
| Engine | WFGY 2.0 | Production tension kernel and math engine for RAG and agents |
| Engine | WFGY 3.0 | TXT based Singularity tension engine, 131 S class set |
| Map | Problem Map 1.0 | Flagship 16 problem RAG failure checklist and fix map |
| Map | Problem Map 2.0 | RAG focused recovery pipeline |
| Map | Problem Map 3.0 | Global Debug Card, image as a debug protocol layer |
| Map | Semantic Clinic | Symptom to family to exact fix |
| Map | Grandma’s Clinic | Plain language stories mapped to Problem Map 1.0 |
| Onboarding | Starter Village | Guided tour for newcomers |
| App | TXT OS | TXT semantic OS, fast boot |
| App | Blah Blah Blah | Abstract and paradox Q and A built on TXT OS |
| App | Blur Blur Blur | Text to image with semantic control |
| App | Blow Blow Blow | Reasoning game engine and memory demo |
If this repository helped, starring it improves discovery so more builders can find the docs and tools.