Power Function

Language English Español Português العربية Русский 中文

This page answers:Which type is this business's growth structure, and how high is the ceiling?

Base ① User scale —— high = there are enough people you can reach and keep, and the pool can carry real scale
Base ② Replicability —— high = the same playbook works again as-is with another client or in another city
Base ③ Channel expansion —— high = once one channel works, you can open many more
Base ④ Geographic expansion —— high = in another place you can sell the same thing all over again
Base ⑤ Scale effect —— high = the bigger you get, the lower the unit cost
Exponent ⑥ Repeat purchase —— high = the same people buy again and again, not a one-off deal
Exponent ⑦ Spread coefficient —— high = users bring new users in on their own
Exponent ⑧ Efficiency gain —— high = you get faster as you go, and the same effort produces more and more
Exponent ⑨ Cost decline —— high = it gets cheaper as you go, and cost falls with scale
Exponent ⑩ Value accumulation —— high = what you did earlier settles into a later advantage, instead of vanishing once it is done

This page looks at the "growth structure", not at "how much you make right now".
The engine splits the 10 scores into two groups: the base (user scale / replicability / channel expansion / geographic expansion / scale effect) decides "how many times each expansion multiplies", the exponent (repeat purchase / spread coefficient / efficiency gain / cost decline / value accumulation) decides "how many times the expansion can happen". Each group is averaged (total 0~100), then each is ÷10 normalised to 0~10, and finally G = normalised base ^ normalised exponent (written in the source code base_norm ** exp_norm; when the base is 0, G is given as 0 directly).
The four quadrants are decided by the two groups' "raw totals", not by the normalised values (source lines 78-97): base total ≥80 and exponent total ≥80 → 🚀 power-function type; otherwise, if the base total is ≥60 → 📈 scale type; otherwise, if the exponent total is ≥60 → 💎 boutique type; none of them → 📉 linear type. Note this is a first-match-wins elif: base 75, exponent 95 lands in the scale type, not the power-function type — if the base is not enough, no exponent is high enough to override it.
🧱 How to read the "ceiling" (the convention is spelled out here): the source code has no "ceiling multiple" field; it only outputs a G with no unit. This page reads G directly as the ceiling multiple, and the convention is just G itself: ceiling multiple = base ^ exponent = normalised base ^ normalised exponent. The meaning is "how far the magnitude can be scaled under this growth structure": base 8, exponent 3 → 512, read as "the structure's upper bound is roughly 512× in magnitude". Every +1 to the exponent multiplies the ceiling by the base — so the bigger the base and the higher the exponent, the more brutal the combination. Under this convention the upper limit is when both groups are at full marks (100/100): G = 10^10 = 10000000000; that is the mathematical ceiling, not a realistic expectation.
It does not answer "how much you make right now". A business with very high current profit but a linear-type structure still gets 📉 on this page — what it judges is "can this thing keep getting bigger", not "how much came in this month".

What this page ports and what it does not (told straight)
· Ported: all the computation in lines 37-121 of PowerFunctionModule.run() (domestic algorithm-port machine /opt/algorithms/functional/power_function.py, 126 lines, sha256 1701def0…47573, read-only) — the 5+5 dimension key names, the default 50 for missing fields, the two group averages, the ÷10 normalisation, G = base_norm ** exp_norm (base 0 → G=0), power_value = base_norm × exp_norm, the four-quadrant 80/80/60/60 banding and the strategy / rating text, plus the round digits (total 2 decimals, G 4, power_value 2). Python's round() is "round half to even", and this page aligns with it via pyRound() — see the comparison report in the build directory.
· Not ported: the data_bus access channel (this page uses 10 input boxes directly instead of an upstream module feeding the numbers), ModuleInfo / the pricing fields (source PRICE=0.0), and the per-dimension analysis echo in the result — this page already shows every item you filled in.
· Explanations this page added itself (the source code has no matching text): ① the "high = …" line after each dimension is a plain-language explanation; the source code only has the dimension name; ② the name "ceiling multiple" — the source code only outputs G and never gave it a name.

Unconfirmed (what we are not sure about, flagged here)
· Unconfirmed ①: the source code has no range validation, and never says these 10 items must be 0~100. This page copies it without trimming — entering >100 or a negative number still computes (there is just a one-line note in the result), because the source code really does not block it.
· Unconfirmed ②: the G value has no unit. The source code never says it equals money, a user count, or a multiple of any concrete quantity — this page reads it as "ceiling multiple" only to give an intuitive way of saying it, which does not mean the source code endorses that meaning.
· Unconfirmed ③: the source file header lists 3 source documents (数学逻辑与评估工具完整梳理.md / 需求幂函数验证_V1.md / 21壳定价精算-5色幂函数反推.md), and we did not read them this time, so the origin of the four 80 / 60 thresholds is unconfirmed.
· Unconfirmed ④: the line chart at the foot of the page plots each of the 10 dimensions after ÷10 (on the same scale as the base / exponent normalisation); it is this page's display sampling, not a source-code output — the source code only outputs two averages.

[Evidence section · where to look each number up]
① Source: domestic algorithm-port machine /opt/algorithms/functional/power_function.py (127 lines, read-only): PowerFunctionModule.run() = lines 37-121; the 5 base dimensions = lines 45-51; the 5 exponent dimensions = lines 52-58; the two group averages = lines 64-65; G = base_norm ** exp_norm = line 72; the four quadrants 80/80/60/60 = lines 78-97.
② Three categories
· [Verifiable] The 5+5 dimension key names, the default 50 for missing fields, the two group averages, the ÷10 normalisation, G and power_value, the four quadrants and the first-match-wins elif, the strategy and rating text, the round digits — all checkable line by line.
· [Display convention of this page] The line chart at the foot of the page (the 10 dimensions after ÷10) is a page sample, not a source-code output (the source code only outputs two averages); "ceiling multiple" is the name this page gives to a dimensionless G, and the source code has no such field.
· [No source found] The origin of the two quadrant thresholds 80 / 60 (and of the "default 50 for missing fields"): the source file header only lists 3 source document names (数学逻辑与评估工具完整梳理.md / 需求幂函数验证_V1.md / 21壳定价精算-5色幂函数反推.md), and we did not read those three files this time → no basis found for the threshold origin.
③ How to check it yourself: fill all 10 items with 80 → base 80, exponent 80 → it should rule 🚀 power-function type, G = 8^8 = 16,777,216; then change the 5 base items to 60 and keep the exponent at 80 → base ≥60 matches first → it should land in 📈 scale type (not the power-function type). This pair verifies the first-match-wins elif behaviour.

What you can do next

Network Effect

Compute network value from the size of your network, and show how far you are from the critical point

Why this link: Follow-on picked by hand (network-effect)

Leverage

What you can do, who might need it, and whether you can actually reach them — live tentacles and dead tentacles

Why this link: Follow-on picked by hand (leverage)
Generated by /opt/slices_build/build.py from the spec /_shared/slices/power-function.json — to change this page, edit the spec and re-run the generator; never hand-edit the HTML.