Alpha & Strategy

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.

Try it — Steps 1-4 calculator

Plug in real balances and entropy values (yours or a QING’s) to see Qi, Mai, Charge, and ZI’s Iota/Omicron/Eta computed live, using the exact same modular-exponentiation math as the contracts above.

Layer 0 — inputs

SHIO.balanceOf(user)Your SHIO balanceSHIO.balanceOf(QING)The venue's SHIO balanceUser.EntropyYour entropy counterQING.Entropy()The venue's entropy counterQING.balanceOf(user)Your QING-token balanceFomalhaute.balanceOf(...)Modulus for ChargeFornax.balanceOf(user)Feeds XIE's OmicronFornax.balanceOf(QING)Feeds XIE's OmegaYuan(QING)bal(user) + 10·bal(LAU) + 40·bal(YUE)Tethys.balanceOf(user)Feeds ZI's OmegaTethys.balanceOf(QING)Feeds ZI's Eta

Step 1-2 — QI / MAI

Qi(user)100

Qi(QING)250

Mai(user @ QING)25

Step 3 — XIA / XIE

Charge40032077580544323939053798895919902852modExp(Qi(QING), Mai, Fomalhaute)

Omicron10

Omega20

Step 4 — ZI

Iota412550modExp(Omicron, Charge, Yuan)

Omicron (recomputed)824852modExp(Omega, Charge, Yuan)

Omega (replaced)7

Eta45

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

Balances divided by entropy produce raw per-player numbers at each stage (QI, MAI, XIE-Omicron/Omega, ZI-Omega/Eta).
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]).
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

Hold some Fornax and some Tethys. XIE uses Fornax; ZI replaces Omega with Tethys. Both are per-stage inputs. See Power: Soeng Chain Optimization.
Stack the venue asset in YUE, not wallet. Yuan’s 40× weight applies to YUE. See Power: Yuan Composition.
Don’t churn. Every reaction bumps someone’s Entropy. See Power: Entropy Discipline.

Use these calls here. Simulations preview the current state; each confirmed call is a separate transaction.

QI0x4d9Ce396BE95dbc5F71808c38107eB7422FD9a03

QI.ReactSoul(uint64 Soul)Simulate / call