Skip to content

Cheat Sheet — Power Formulas

The full Soeng chain (QI → MAI → XIA → XIE → ZI → PANG) in one page, plus the downstream consumers (RING, META, WAR).

Each step composes modular exponentiation with reads of balances divided by Entropy. Read bottom-up if you want to see what finally matters.

Layer 0 — inputs

Input What it is Source
SHIO.balanceOf(x) How much of the venue's SHIO token x holds. SHIO
QING.balanceOf(x) How much of the QING token x holds. QING
Fomalhaute The Fomalhaute SHIO token (modulus source). XIE
Fornax The Fornax token (feeds Omicron/Omega into XIE). XIE
Tethys Feeds Omega/Eta into ZI. ZI
Yuan(QING) bal(user) + 10·bal(LAU) + 40·bal(YUE) for the QING's underlying asset. CHOA
User.Entropy Per-user entropy counter. LAU
QING.Entropy() Per-QING entropy counter. QING

Step 1 — QI (energy)

Qi(user)  = SHIO.balanceOf(user)  / User.Entropy
Qi(QING)  = SHIO.balanceOf(QING)  / QING.Entropy()

Source: QI.

Step 2 — MAI (venue-specific power)

Mai(user @ QING) = QING.balanceOf(user) / User.Entropy

Source: MAI.

MAI is also the unit of chat reward — up to 1 token per message. See Cheat Sheet: Caps.

Step 3 — XIA / XIE (combined charge + reactions)

Charge = modExp( Qi(QING), Mai(user @ QING), Fomalhaute.balanceOf(...) )

Omicron = Fornax.balanceOf(user) / User.Entropy
Omega   = Fornax.balanceOf(QING) / QING.Entropy()

XIE.Charge() returns (Charge, Omicron, Omega). Sources: XIA, XIE.

The Fomalhaute balance is the modulus of the modExp — it never acts as a numerator. Holding more Fomalhaute doesn't increase Charge; it widens the codomain.

Step 4 — ZI (spin)

Iota    = modExp( Omicron, Charge, Yuan(QING) )
Omicron = modExp( Omega,   Charge, Yuan(QING) )     ← recomputed
Omega   = Tethys.balanceOf(user) / User.Entropy     ← replaced
Eta     = Tethys.balanceOf(QING) / QING.Entropy()

ZI.Spin() returns (Iota, Omicron, Eta, Omega). Source: ZI.

Notice:

  • Yuan(QING) is the modulus in both ZI's modExp ops. Bigger Yuan = wider codomain, but also (practically) different outputs.
  • Omicron and Omega are overwritten, not additively stacked. ZI erases whatever XIE put in.

Step 5 — PANG (push)

Iota    = modExp( ZI.Iota,    QING.Entropy(), Yuan(QING) )
Omicron = modExp( ZI.Omicron, Charge,         Yuan(QING) )
Eta     = ZI.Eta       ← passthrough
Omega   = ZI.Omega     ← passthrough
Charge  = XIE.Charge   ← passthrough

PANG.Push(QingWaat) returns (Iota, Omicron, Phoebe, Omega, Charge) where Phoebe is the original input passed through the chain (often represented as Eta here). Source: PANG.

QING.Entropy() appears as an exponent in PANG's Iota — not a divisor. So a high-entropy QING produces a very different Iota, but not in a monotone way (modExp is nonlinear). Don't assume "more entropy = more Iota".

Step 6a — RING.Eta() (moment)

Chao   = YUE.React(Phobos)                           // accumulates Hypobar/Epibar in YUE
(Iota, Omicron, Phoebe, Omega, Charge) = PANG.Push(Phobos.Waat())
Chao   = Chao   / Omicron
Charge = Charge / Omega
Moments[Soul] = Iota       ← stored
Iota   = Iota * Iota       ← return-value squared
return (Phoebe, Iota, Chao, Charge)

Source: RING.

Key behaviours:

  • Every Eta() call overwrites your Moments[Soul] with the pre-squared Iota.
  • Chao divides by Omicron; a large Omicron shrinks Chao (and therefore the squared Yeo scaling later).
  • The squared Iota is what downstream callers see as RING's Iota return.

Step 6b — META.Beat()

(Phoebe, Iota1, Chao, Charge1) = RING.Eta()
(Yeo, Omicron, Dione, Omega, Charge) = PANG.Push(QingWaat)
Charge = Charge1 * Charge / Iota1
Deimos = modExp( Dione, Phoebe, Yuan(QING) )
Yeo    = Yeo / Chao
return (Dione, Charge, Deimos, Yeo)

Source: META.

Key behaviours:

  • Yeo scales inversely with Chao. Bigger Chao → smaller Code range.
  • Deimos uses Phoebe (from Eta) as exponent, Dione as base, Yuan(QING) as modulus.

Step 6c — WAR.Faa()

Buzz = WORLD.Tail(Caude, Position)
if Buzz == 0: return 0
(Phoebe, Iota, Chao, Charge) = META.Ring().Eta()      // fresh Eta
Waat = modExp( Phoebe, Charge, Meridians[89] )
if Waat > _taan[Caude][Position]:
    H2O.Mint(Chi, Iota)                // Iota here is the SQUARED Iota from Eta()
    CO2 += Chao
return Waat

Source: WAR.

Key behaviours:

  • H2O minted = squared Iota from Eta. So a small pre-squared Iota of 3 yields 9 H2O; 10 yields 100. It's quadratic in pre-squared Iota.
  • The _taan high-score is monotonic per position — once beaten high, harder to beat again.
  • CO2 += Chao every time a new high is set. The more frequent the high-score beats, the faster CO2 accumulates.

What the chain means, in three sentences

  1. Balances divided by entropy produce raw per-player numbers at each stage (QI, MAI, XIE-Omicron/Omega, ZI-Omega/Eta).
  2. modExp mixes them together with nonlinear feedback; the modulus gets bigger and more context-dependent as you move down the chain (Fomalhaute → Yuan → Meridians[89]).
  3. Iota is the reward currency of the chain. PANG's Iota feeds RING's Moments (and is squared), META's Deimos/Yeo, and WAR's H2O mint amount.

Practical optimization cheats