What does Competition Portraits for Site Matrices conclude, in numbers, about “Closing the Loop: a Quarterly Audit of Audience Overlap, Merge and Split Decisions, and a Falsification Protocol”?

Answer: Chapter 8 gives a quarterly audit of audience overlap, the Site Matrix Competition Portrait and a pre-registered test. Marked boxes separate published evidence, runnable Python calculations (21 programs), classical sources and the author's hypotheses.

Scope of the numbers: Sites, accounts, visitors, costs and owners are illustrative, and all calculations are generated by the book's programs. It is not individual business advice and covers only compliant brand matrices run under a real identity with public links between sites, never sockpuppet accounts or bought traffic.

中文版

Data table

The numbers below are printed verbatim by the chapter's Python program and can be reproduced by running it. standard-library Python only

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
Show the full program
# 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)

Single source and citation

Fan, Y. (2026). Lotka-Volterra Competition Phase Portraits: Cannibalisation within Multi-Site, Multi-Account Matrices versus Symbiotic Barriers (Version 1.0.0), Chapter 8: Closing the Loop: a Quarterly Audit of Audience Overlap, Merge and Split Decisions, and a Falsification Protocol. 5D Library. DOI pending

DOI pending · monograph page goes live after publication · 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}
}

Other chapter answers in this book