关于「实证闭环:季度受众重叠审计、合并与拆分判定与证伪方案」,《站群竞争相图》给出的定量结论是什么?

结论:第八章给出季度受众重叠审计、站群内耗相图判定器与预注册检验方案。书中以标注框区分已发表的证据、可运行的 Python 计算(21 段程序)、原典与作者的假说。

数据口径:立项命题经核对后修正:系数大于一时,只有被经营者撑住的内部平衡点低于单站,自由竞争的结局是只剩一个站;两个系数之积小于一只是共存的必要条件,示意网格中满足它的格子仍有 0.627 以一方出局告终。 书中站、账号、访客、成本与经营者均为示意;全部计算由书中程序生成;本书是非个人化经营建议,只讨论以真实主体运营、彼此关系公开的合规品牌矩阵,不涉及马甲账号与刷量。

English version

对照数据表

下表数字由本章 Python 程序原样打印,可重新运行复现。 程序只用 Python 标准库

Site Matrix Competition Portrait (B-251)
sites M S T D L; capacity sum 35000 visitors a month
overlap a_ij (row feels column):
M S T D L
M1.000 1.230 0.577 1.010 0.435
S0.575 1.000 0.056 0.595 0.063
T0.425 0.087 1.000 0.412 1.137
D0.987 1.245 0.548 1.000 0.425
L0.180 0.056 0.641 0.180 1.000
M-S1.230 / 0.575 M excludes S
M-T0.577 / 0.425 coexist
M-D1.010 / 0.987 M excludes D
M-L0.435 / 0.180 coexist
S-T0.056 / 0.087 coexist
S-D0.595 / 1.245 coexist
S-L0.063 / 0.056 coexist
T-D0.412 / 0.548 coexist
T-L1.137 / 0.641 coexist
D-L0.425 / 0.180 coexist
product rule a_ij a_ji < 1 misleads on 2 pairs
free competition settles on ML13126 visitors, 0.375 of capacity sum
advice per site:
M keep
S fold into M or reposition
T fold into M or reposition
D fold into M or reposition
L keep
pause test needed for: S-D, T-L
查看完整验算程序
# Chapter 8. p81: the demo of the Site Matrix Competition Portrait.
# Same functions as distill/tool.py (without its command line): five
# illustrative sites of Chapter 4 (M main, S narrow sub-site, T tail
# site, D near copy, L second-language site), overlaps from audience
# profiles (p21), pair verdicts (p11, p13), subsets closed to re-entry
# and a check by simulation (p43), margin warnings (p22, p62).
import math
from itertools import combinations

DEMO_P = ("M:20,18,16,14,12,10,6,4;S:40,35,15,10,0,0,0,0;"
          "T:0,0,5,10,15,20,25,25;D:22,18,15,14,12,9,6,4;"
          "L:5,0,0,0,5,10,30,50")
DEMO_K = "M:12000,S:5000,T:6000,D:8000,L:4000"


def parse_profiles(s):
    out = {}
    for item in s.split(";"):
        name, vals = item.split(":")
        out[name.strip()] = [float(v) for v in vals.split(",")]
    return out


def parse_map(s):
    out = {}
    for item in s.split(","):
        if item.strip():
            k, v = item.split(":")
            out[k.strip()] = float(v)
    return out


def parse_referral(s):
    out = {}
    for item in s.split(";"):
        if item.strip():
            pair, v = item.split(":")
            i, j = pair.split(",")
            out[(i.strip(), j.strip())] = float(v)
    return out


def overlaps(prof, referral):
    names = list(prof)
    al = {}
    for i in names:
        den = math.fsum(x * x for x in prof[i])
        for j in names:
            num = math.fsum(x * y for x, y in zip(prof[i], prof[j]))
            al[(i, j)] = 1.0 if i == j else num / den
    for key, v in referral.items():
        al[key] = al[key] - v
    return names, al


def verdict(i, j, al, cap):
    hold_i = al[(j, i)] > cap[j] / cap[i]
    hold_j = al[(i, j)] > cap[i] / cap[j]
    if hold_i and hold_j:
        return "bistable"
    if hold_i:
        return i + " excludes " + j
    if hold_j:
        return j + " excludes " + i
    return "coexist"


def solve(sub, al, cap):
    m = [[al[(i, j)] for j in sub] + [cap[i]] for i in sub]
    k = len(sub)
    for c in range(k):
        p = max(range(c, k), key=lambda r: abs(m[r][c]))
        if abs(m[p][c]) < 1e-12:
            return None
        m[c], m[p] = m[p], m[c]
        for r in range(k):
            if r != c:
                f = m[r][c] / m[c][c]
                m[r] = [x - f * y for x, y in zip(m[r], m[c])]
    return {sub[i]: m[i][k] / m[i][i] for i in range(k)}


def settled(names, al, cap):
    rows = []
    for size in range(1, len(names) + 1):
        for sub in combinations(names, size):
            n = solve(list(sub), al, cap)
            if n is None or min(n.values()) <= 0:
                continue
            closed = all(cap[i] - math.fsum(al[(i, j)] * n[j]
                                            for j in sub) <= 0
                         for i in names if i not in sub)
            if closed:
                rows.append((math.fsum(n.values()), sub, n))
    rows.sort(key=lambda r: (-r[0], r[1]))
    return rows


def simulate(names, al, cap):
    n = {i: 1000.0 for i in names}
    for _ in range(12000):
        g = {i: 0.3 * n[i] * (1 - math.fsum(al[(i, j)] * n[j]
                                            for j in names) / cap[i])
             for i in names}
        n = {i: max(n[i] + 0.05 * g[i], 0.0) for i in names}
        if max(n.values()) > 1e7:
            return None
    return n


def analyse(prof, cap, referral, margin):
    names, al = overlaps(prof, referral)
    pairs = []
    misleading = 0
    near = []
    for i, j in combinations(names, 2):
        v = verdict(i, j, al, cap)
        prod = al[(i, j)] * al[(j, i)]
        if prod < 1 and v != "coexist":
            misleading += 1
        gap = min(abs(al[(i, j)] - cap[i] / cap[j]),
                  abs(al[(j, i)] - cap[j] / cap[i]))
        if gap < margin:
            near.append(i + "-" + j)
        pairs.append({"pair": i + "-" + j, "a_ij": round(al[(i, j)], 3),
                      "a_ji": round(al[(j, i)], 3), "verdict": v})
    rows = settled(names, al, cap)
    sim = simulate(names, al, cap)
    if sim is None:
        keep = []
    else:
        keep = [i for i in names if sim[i] > 0.01 * cap[i]]
    advice = {}
    for i in names:
        if i in keep:
            advice[i] = "keep"
        else:
            j = max(keep, key=lambda s: al[(i, s)] * sim[s]) if keep \
                else "-"
            advice[i] = "fold into " + j + " or reposition"
    capsum = math.fsum(cap.values())
    return {
        "sites": names,
        "capacity_sum": round(capsum),
        "overlap": [[round(al[(i, j)], 3) for j in names] for i in names],
        "pairs": pairs,
        "product_rule_misleads": misleading,
        "closed_subsets": [{"sites": "".join(s), "total": round(t)}
                           for t, s, _ in rows],
        "settled": "".join(keep),
        "settled_total": round(math.fsum(sim[i] for i in keep))
        if keep else None,
        "share_of_capacity": round(math.fsum(sim[i] for i in keep)
                                   / capsum, 3) if keep else None,
        "advice": advice,
        "near_edge": near,
        "unbounded": sim is None,
    }


def report(r):
    names = r["sites"]
    lines = ["Site Matrix Competition Portrait (B-251)",
             "sites %s; capacity sum %d visitors a month"
             % (" ".join(names), r["capacity_sum"]),
             "overlap a_ij (row feels column):",
             "     " + "".join("%7s" % n for n in names)]
    for i, row in zip(names, r["overlap"]):
        lines.append("  %-3s" % i + "".join("%7.3f" % v for v in row))
    for p in r["pairs"]:
        lines.append("  %-5s %5.3f / %5.3f  %s"
                     % (p["pair"], p["a_ij"], p["a_ji"], p["verdict"]))
    lines.append("product rule a_ij a_ji < 1 misleads on %d pairs"
                 % r["product_rule_misleads"])
    if r["unbounded"]:
        lines.append("mutual feeding too strong: model unbounded")
    else:
        lines.append("free competition settles on %s: %d visitors, "
                     "%.3f of capacity sum"
                     % (r["settled"], r["settled_total"],
                        r["share_of_capacity"]))
    lines.append("advice per site:")
    for k, v in r["advice"].items():
        lines.append("  %-3s %s" % (k, v))
    if r["near_edge"]:
        lines.append("pause test needed for: " + ", ".join(r["near_edge"]))
    lines.append("status: candidate only; a person signs off first")
    return lines


r = analyse(parse_profiles(DEMO_P), parse_map(DEMO_K), {}, 0.05)
for line in report(r):
    print(line)

唯一数据源与引用

范雅福(Fan, Y.). (2026). 《洛特卡沃尔泰拉竞争相图、多子站多账号矩阵内耗与共生壁垒判定母典》第 8 章「实证闭环:季度受众重叠审计、合并与拆分判定与证伪方案」(版本 1.0.0). 5D Library. DOI 待发布

DOI 待发布 · 专著页正式发布后上线(本站暂无专著页) · 5DL-B-251 · v1.0.0 · CC-BY-NC-ND-4.0

BibTeX
@book{fan2026251,
  author    = {Fan, Yafu},
  title     = {Lotka-Volterra Competition Phase Portraits: Cannibalisation within Multi-Site, Multi-Account Matrices versus Symbiotic Barriers},
  year      = {2026},
  publisher = {5D Library},
  edition   = {1.0.0},
  note      = {DOI pending}
}

本书其他章节结论