Bundle review table

Test 03 — Mesh resilience is articulation (H46)

Supplied working report; original verdicts not validated.

Review status: Needs review. This is an archival source note, not a passed proof.

README.md

# Test 03 — Mesh resilience is articulation (H46)

**Verdict: refuted.** Across nine networks, articulation-point density does
not predict fragmentation under node loss in the direction claimed. The
controlled coefficient is negative, the simple association is nil, and the
pre-specified bypass edge rule bought ten times *less* resilience than random
edges. One post-hoc corrected rule supports the mechanism and is labelled as
post-hoc.

## Result

A 2% random node loss leaves 2.4% to 23.0% of nodes outside the largest
component (F = 0.0242 on as-skitter to 0.2300 on ca-GrQc). Fitting F on
standardised kappa/n, log10 n and m/n across the nine graphs (n = 9, 5 residual
degrees of freedom, R² = 0.678) gives **b1 = −0.2381**, a 10,000-label
two-sided permutation **p = 0.0280**, partial R² = 0.552. The sign is negative:
more articulation points per node went with *less* fragmentation, the opposite
of the prediction. A two-test Benjamini–Hochberg family gives q = 0.028 for this
coefficient and q = 0.0001 for the edge test.

The simple association is weaker: Spearman rho +0.117 for kappa/n,
against −0.217 for log10 n and −0.250 for m/n — the worst of the three, where
P1 says it should be best.

Two features explain the instability. kappa/n and m/n are nearly the same
variable (r = −0.958): sparse road and peer-to-peer graphs (kappa/n 0.15–0.19,
m/n 1.4–3.7) sit against dense web and internet graphs (0.058–0.066,
m/n 6.5–7.1). And F at 2% includes pre-existing fragmentation — ca-GrQc starts
at 0.207, web-Stanford at 0.095. Subtracting that baseline flips b1 to +0.0055
(p = 0.097, partial R² = 0.339).

## Design

Nine SNAP networks, all SHA-256 checked: ca-GrQc (n = 5,242),
p2p-Gnutella06, -04, -24 and -30 (8,717 to 36,682), web-Stanford (281,903),
roadNet-PA (1,088,092), roadNet-TX (1,379,917) and as-skitter (1,696,415). All
are unordered pair lists; roadNet-PA/TX list every edge twice and web-Stanford
has 319,861 duplicate lines, removed before analysis. The largest has
11,095,298 distinct edges, held as arrays.

For each graph: exact articulation points by iterative Tarjan (813 on ca-GrQc
to 259,525 on roadNet-TX), components, redundancy, and F = 1 − S_max/n after
removing 0.5, 1, 2 and 5% of nodes over 20 seeds. Attacks were random,
highest-degree, and a degree × two-hop-degree proxy (a cheap stand-in for
betweenness, not betweenness). The confirmatory point is f = 2%, random attack.

## P1 — kappa/n predicts better than n or m/n: not supported

Univariate R² is 0.047 for kappa/n, 0.098 for log10 n and 0.014 for m/n; |rho|
is 0.117, 0.217 and 0.250. kappa/n beats m/n in R² but loses to node count on
both measures and to m/n on rank correlation. In the joint model its partial R²
is largest (0.552), but that is shared variance: two-predictor models explain
0.126–0.211, while adding kappa last lifts R² from 0.126 to 0.678. A predictor
that only works beside its near-duplicate is not shown better.

## P2 — the association survives controlling for size and redundancy: not supported

It survives arithmetically (p = 0.028) but not in the claimed direction and not
robustly. Leave-one-out: dropping ca-GrQc gives −0.023 (p = 0.860), dropping
web-Stanford gives p = 0.072, and the other seven leave b1 between −0.225 and
−0.287. With degree-attack F, b1 = −0.240 (p = 0.271); at f = 5% it is −0.235
(p = 0.033). The sign is stable and negative; significance is not.

## P3 — articulation-bypassing edges beat random edges: refuted as pre-specified

The pre-registered rule connected the highest-degree nodes of the two largest
biconnected blocks at each cut vertex. Those are usually one giant block and one
tiny leaf, so it protected little: mean reduction in F was 0.000552 against
0.005575 for 50 random edges (ratio 0.099, p = 0.00005 over 20,000 permutations;
paired sign-flip p = 0.00005). The ratio is 0.093 on ca-GrQc and 0.872 on
p2p-Gnutella06.

Random edges win largely by welding ca-GrQc's many small components onto the
giant one, lowering F without strengthening it. A post-hoc rule connecting the
highest-degree nodes in the two largest components of G − a — the regions a cut
vertex really separates — and confining both strategies to the giant component,
reverses the result: 0.000805 against 0.000251, ratio 3.21, p = 0.00285. That
supports the mechanism but is post-hoc and cannot rescue the pre-specified test.

## What the test cannot see

Nine graphs are a convenience sample, with 5 residual degrees of freedom. kappa/n and m/n are collinear by construction, so no
analysis of these nine can say which matters. F is static and structural: it
sees the largest component, not function, traffic or recovery, and removals are
uniform or rank-based rather than cascading. The edge experiment uses the two
smallest graphs, one fragmented and one connected, so its pooled answer is
dominated by ca-GrQc. Observational throughout: associations, not causes.

## What would change the answer

A sample with independent variation in kappa/n at fixed m/n — matched pairs, or
synthetic graphs with articulation density dialled independently — would test P1
properly. A baseline-adjusted response and at least ten graphs would make P2
estimable. The post-hoc region rule should be pre-registered and replicated on
more than two graphs before P3's mechanism is believed.

## Files and disclosure

`hypothesis.md` is the pre-registration; `run.py` reruns everything from the
network and writes `results.json`, `data/` and `figures/`. `SOURCE.md` records
URLs, timestamps, hashes, row counts and field discovery. Designed and executed
with AI assistance (DeepSeek, via its coding agent); not peer reviewed.

hypothesis.md

# Hypothesis H46 — Mesh resilience is articulation (pre-registration)

## The claim, verbatim

> "Mesh network resilience is set by the number of articulation points rather than
> by node count or redundancy."

Published at
<https://incoprea.com/research-library/original-theories-vol10-20261030/>
(Original Theories, Volume X, hypothesis H46.)

## Predictions as published

- **P1** fragmentation under node loss is predicted by the articulation-point
  density kappa/n better than by n or by the redundancy ratio m/n;
- **P2** the association survives controlling for size and redundancy;
- **P3** an edge-addition strategy that bypasses articulation points buys more
  resilience than the same number of random edges.

## Operational definitions, fixed before computation

| Quantity | Definition |
|---|---|
| graph | undirected, simple as published; every SNAP file is an unordered pair list ("each unordered pair of nodes is saved once"), so each line is one undirected edge |
| n | number of nodes, including degree-zero nodes (the SNAP headers count them) |
| m | number of edge lines in the file |
| c | number of connected components of the graph |
| kappa | exact number of articulation points (cut vertices), iterative Tarjan |
| kappa/n | articulation-point density, the predictor named by the claim |
| redundancy | m - n + c (cyclomatic number), reported as a column |
| redundancy ratio | m/n, the ratio named in P1 |
| F | fragmentation after node removal, `F = 1 - S_max/n`, where `S_max` is the largest connected component *after* removal and n is the original node count |
| random attack | `round(f*n)` nodes drawn uniformly without replacement, 20 seeds (seed base 20261030 + j) |
| degree attack | the `round(f*n)` highest-degree nodes, ties broken by node id |
| proxy attack | the `round(f*n)` nodes with the largest `deg(v) * sum(deg(u) for u in N(v))`, a degree-x-two-hop-reach proxy for betweenness (ties by node id) |
| f | {0.5, 1, 2, 5} percent; **f = 2% is the pre-specified confirmatory point** |

The proxy is not betweenness. It is a cheap monotone stand-in, named as such
everywhere it appears, and is only used descriptively; the confirmatory model
uses random attack only.

## Pre-specified confirmatory analysis

**Primary model (P1/P2).** With one row per graph and F the mean of the 20 random
attacks at f = 2%:

```
F = b0 + b1 * z(kappa/n) + b2 * z(log10 n) + b3 * z(m/n) + e
```

where `z(.)` is the sample z-score. Fit by ordinary least squares. Report
unstandardised coefficients on the standardised inputs, the partial R^2 of each
term (R^2 full minus R^2 without that term), and a two-sided permutation p for
`b1` from 10,000 random relabellings of F (seed 20261030). This is the
coefficient that P1 and P2 both turn on; P2 is not a separate test.

**Secondary (P1 comparison).** Spearman rho of F with kappa/n, log10 n and m/n,
each with a seeded permutation p. P1 says kappa/n predicts better than the other
two; this is a comparison of effect sizes, not a separate significance claim.

**P3.** On the two smallest graphs, add 50 edges by one of two rules, then
recompute F at f = 2% over the same 20 seeds used for the base graph:

- *random*: 50 distinct non-edges drawn uniformly without replacement
  (seed 20261030);
- *bypass*: deterministic, stated in full. For every articulation point a,
  group a's neighbours by the biconnected block of the incident edge. For each
  pair of distinct blocks at a, form the candidate edge between the
  highest-degree node of each block (ties by node id), scored by the summed
  sizes of the two blocks, then by the summed degrees. Rank all candidates by
  that score (descending), add greedily in rank order, skipping duplicates and
  existing edges, until 50 edges are added. This deliberately cuts across the
  articulation that separates the two regions.

A post-hoc *leaf* variant (same rule but the lowest-degree node of each block)
is reported as sensitivity only.

Response for P3 is the reduction `dF = F_base - F_augmented` (positive = more
resilient), mean over the 20 paired seeds. Primary test: seeded permutation test
on the difference of means (`stats.mean_difference_test`), with a paired
sign-flip permutation as a secondary check.

## Decision rule, written before the numbers exist

**Support** requires all of:

1. `b1 > 0` in the primary model, permutation p < 0.01, and partial R^2 > 0.20;
2. `b1` survives Benjamini–Hochberg at q < 0.05 across the declared family of
   two confirmatory tests (the coefficient test and the P3 difference test);
3. the bypass edge strategy reduces F by at least 2x the random strategy, with
   its own p < 0.05.

**Refute** if either:

- `b1` adds no partial variance once log10 n and m/n are in the model
  (p > 0.05); or
- the two edge strategies are indistinguishable (p > 0.05).

**Mixed** otherwise, quoted with the coefficient and the p-value. Any result in
which the sign of b1 is negative counts as a refutation of the stated direction
even if it is significant, and will be reported as such.

## Declared correction family

Exactly two confirmatory tests: (i) the standardised kappa/n coefficient in the
random-attack model at f = 2%, (ii) bypass minus random `dF` at f = 2%. BH
applies to these two p-values only. Everything else — simple correlations,
targeted-attack F, other removal fractions, the leaf variant, the four-fraction
curves — is secondary/exploratory, reported unadjusted and labelled as such. No
second correction is applied after this family is declared.

## Sensitivity specified in advance

- Repeat the primary model with the **degree-attack** F at f = 2% in place of
  the random-attack F, and report whether the kappa conclusion changes.
- Repeat the primary model at f = 5% (random attack) as a robustness check.

## What this design cannot see

Graphs are a convenience sample of nine published network topologies, not a
random sample of networks; the cross-graph regression has 9 rows and therefore
5 residual degrees of freedom, so a single influential graph can move the
coefficient. Articulation points are computed on the graph as published, which
is a static snapshot; nothing here observes a network failing in the field.
Node removal is uniform or rank-based, not a model of how failures cascade.
F measures only the largest component, not function. No causal claim is
available from this design.

## Disclosure

Designed and executed with AI assistance (DeepSeek, via its coding agent), not
peer reviewed.

Included code and results