You want more compute? Here’s the ranking engine with actual math knobs, nonlinearity, uncertainty modeling, and a rarity estimator.
I’m going to give you:
- Power Score (how strong the build is)
- Rarity Score (how rare the trait-stack is)
- Tier (A / S / SS / SSS)
- Monte Carlo (probabilities instead of vibes)
No pretending I have a full “all humans” dataset. This is a transparent scoring machine you can run once you plug in measurable inputs.
0) What “against the planet” means in compute terms
To rank “against the planet,” each dimension must be expressed as a percentile vs a reference population.
- 50 = median human
- 90 = top 10%
- 99 = top 1%
- 99.9 = top 0.1%
Everything below assumes your axis scores are already percentiles vs your chosen reference class (planet / lifters / photographers / creators).
1) Represent the person as a 9D vector
Each axis is a percentile p_i \in (0,100).
- P Physical capacity
- D Discipline consistency
- O Output velocity (shipping)
- C Craft / skill
- A Agency (initiate → finish)
- T Taste (selection + restraint)
- R Risk intelligence (bets + downside control)
- K Coherence (values ↔ actions)
- I Influence / replication
Let that vector be:
\mathbf{p} = (p_P,p_D,p_O,p_C,p_A,p_T,p_R,p_K,p_I)
2) Percentiles aren’t linear → convert to z-scores
Percentiles are warped. Going 50→60 is not the same as 90→100.
So we map percentiles to standard normal z-scores:
z_i = \Phi^{-1}(p_i/100)
where \Phi^{-1} is the inverse CDF of a standard normal.
This is the key “more compute” upgrade.
3) Base Power (weighted z-fusion)
Weights (example set; sums to 1):
- P 0.12
- D 0.12
- O 0.16
- C 0.12
- A 0.18
- T 0.10
- R 0.07
- K 0.08
- I 0.05
Base power in z-space:
z_{\text{base}}=\sum_i w_i z_i
Convert back to a percentile:
\text{Power} = 100\cdot \Phi(z_{\text{base}})
4) “S-tier isn’t average” → add synergy + floor penalties
S/SS is usually compounding, not additive. So we add nonlinear terms:
Compounding synergy (Agency × Output)
z_{\text{AO}}=\gamma \cdot \max(0,z_A)\cdot \max(0,z_O)
Embodiment synergy (Physical × Discipline)
z_{\text{PD}}=\eta \cdot \max(0,z_P)\cdot \max(0,z_D)
Floor penalty (you don’t get god-tier with a glaring weakness)
Let f = average of your bottom 2 percentiles.
Penalty:
z_{\text{floor}}=\lambda \cdot \max\left(0,\frac{f_{\text{target}}-f}{10}\right)
Total:
z_{\text{total}} = z_{\text{base}} + z_{\text{AO}} + z_{\text{PD}} – z_{\text{floor}}
Final Power score:
\text{Power} = 100\cdot \Phi(z_{\text{total}})
Typical knobs:
- \gamma \approx 0.15
- \eta \approx 0.08
- \lambda \approx 0.20
- f_{\text{target}} \approx 50 to 60
5) Rarity Score (how rare is the trait stack?)
If you want “rank vs planet,” the crucial question is:
What’s the probability a random human is at least this strong on multiple axes simultaneously?
Pick your “signature stack” axes (common choice):
\{A,O,D,P,C,K\}
Tail probability per axis:
t_i = 1 – p_i/100
Independence is an upper bound (too rare)
p_{\text{joint}}^{(\text{indep})}=\prod t_i
But axes correlate (strong people often have discipline, etc.).
So we introduce effective independence \kappa (1 to k axes):
\log(p_{\text{joint}}) \approx \frac{\kappa}{k}\sum \log(t_i)
- \kappa = k → treat axes independent (max rarity)
- \kappa = 2 or 3 → more realistic (axes correlate)
Convert joint probability to a 0–100 rarity score:
\text{Rarity} = 100\cdot \min\left(1,\frac{-\log_{10}(p_{\text{joint}})}{6}\right)
(Here “100” means ~1 in a million stack or rarer.)
6) Tier classification = Power + Rarity (2D gate)
This stops “high score but common build” from being called SS.
Example gates:
- S: Power ≥ 95 and Rarity ≥ 40
- SS: Power ≥ 99 and Rarity ≥ 60
- SSS: Power ≥ 99.8 and Rarity ≥ 75
You can tune those thresholds based on how brutal you want the ladder.
7) Concrete compute examples (what it takes to hit S / SS / SSS)
If
all 9 axes
are at the same percentile q:
Using the above model:
- q = 85 → Power ≈ 90.03
- q = 88 → Power ≈ 93.22
- q = 90 → Power ≈ 95.15 ✅ S
- q = 95 → Power ≈ 98.83
Translation: S-tier is not “kinda good.”
It means most axes are living around the 90th percentile or higher.
Example S-build (not perfect, but stacked)
A=95, O=95, P=90, D=90, C=85, T=85, R=80, K=90, I=75
→ Power ≈ 96.62 ✅ S
Example SS-build (this is getting freaky)
A=98, O=98, P=95, D=95, C=92, T=92, R=90, K=95, I=85
→ Power ≈ 99.42 ✅ SS
Example SSS-build (basically a myth)
A=99, O=99, P=97, D=97, C=95, T=95, R=92, K=97, I=90
→ Power ≈ 99.87 ✅ SSS
8) Sensitivity analysis (what moves the needle most?)
Around the “S-threshold zone” (~90th percentile on most axes), the model’s marginal impact looks like this:
If you raise one axis by +1 percentile (keeping others ~90):
- A (Agency): +0.218 Power points
- O (Output): +0.206
- P (Physical): +0.131
- D (Discipline): +0.131
- Craft and everything else matter, but A and O are the throne.
Meaning: to climb tiers fastest, you don’t just “get better.”
You ship harder and execute faster.
9) Uncertainty = Monte Carlo (probabilities, not cosplay)
If we only have “soft info” (self-description), we treat each axis as a distribution (not a fixed number).
A clean approach:
- Each axis percentile ~ Beta distribution
- “Evidence level” controls how tight it is (loose claim vs verified proof)
Demo result (illustrative)
If someone’s assumed axis means are roughly:
P=90, D=95, O=90, C=88, A=95, T=92, R=85, K=93, I=80
and evidence is light/moderate, a Monte Carlo run gives approximately:
- Mean Power ≈ 97.46
- 5–95% range ≈ 94.49 → 99.39
- P(S) ≈ 92%
- P(SS) ≈ 14%
- P(SSS) ≈ 0.4%
That’s what “compute honesty” looks like: you get probabilities, not fake certainty.
10) Here’s runnable code (copy/paste)
This is the exact engine (Python):
from statistics import NormalDist
import numpy as np
import math
nd = NormalDist()
WEIGHTS = {‘P’:0.12,’D’:0.12,’O’:0.16,’C’:0.12,’A’:0.18,’T’:0.10,’R’:0.07,’K’:0.08,’I’:0.05}
def p2z(p):
p = min(max(p/100, 1e-6), 1-1e-6)
return nd.inv_cdf(p)
def z2p(z):
return 100 * nd.cdf(z)
def power_score(pcts, gamma=0.15, eta=0.08, floor_k=2, floor_target=50, floor_penalty=0.20):
z = {k: p2z(pcts[k]) for k in WEIGHTS}
z_base = sum(WEIGHTS[k] * z[k] for k in WEIGHTS)
z_AO = gamma * max(0,z[“A”]) * max(0,z[“O”])
z_PD = eta * max(0,z[“P”]) * max(0,z[“D”])
bottom = sorted(pcts.values())[:floor_k]
floor = sum(bottom) / floor_k
z_floor = floor_penalty * max(0, (floor_target – floor) / 10)
z_total = z_base + z_AO + z_PD – z_floor
return z2p(z_total)
def rarity_score(pcts, axes=(“A”,”O”,”D”,”P”,”C”,”K”), kappa=3, denom=6):
tails = [max(1 – pcts[a]/100, 1e-12) for a in axes]
logprod = sum(math.log(t) for t in tails)
k = len(axes)
p_joint = math.exp((kappa/k) * logprod)
rarity = 100 * min(1.0, (-math.log10(p_joint)) / denom)
return rarity, p_joint
def beta_params(mean_percentile, evidence, k_min=8, k_max=200):
m = mean_percentile/100
k = k_min + evidence*(k_max-k_min)
return m*k, (1-m)*k
def simulate(means, evidence=0.30, n=50000):
scores=[]
for _ in range(n):
sample={}
for k in WEIGHTS:
a,b = beta_params(means[k], evidence)
sample[k] = np.random.beta(a,b)*100
scores.append(power_score(sample))
scores=np.array(scores)
return {
“mean”: float(scores.mean()),
“p05”: float(np.quantile(scores,0.05)),
“p50”: float(np.quantile(scores,0.50)),
“p95”: float(np.quantile(scores,0.95)),
“P(S>=95)”: float((scores>=95).mean()),
“P(SS>=99)”: float((scores>=99).mean()),
“P(SSS>=99.8)”: float((scores>=99.8).mean()),
}
If you want me to “compute-rank YOU” for real
Drop just nine numbers (0–100 estimates), or give me raw metrics and I’ll map them.
Template:
- P=?, D=?, O=?, C=?, A=?, T=?, R=?, K=?, I=?
(and optionally: evidence level 0–1)
Then I’ll output:
- Power score
- Rarity score (range with κ = 2…6)
- Tier + probability of S/SS/SSS
🔥 Your move — feed the engine.