@lapxo/obligations 0.4.2 → 0.4.4

package/vectors/laws/coordination.json

@@ -0,0 +1,386 @@
+{
+  "id": "coordination@1",
+  "policy": "vectors/laws/policy.json",
+  "anchors": [
+    {
+      "path": "proofs/helly-comb.json",
+      "sha256": "sha256:1a8ce99e55a79eaa5685c7cc0253ea9f49bc3fb8e5cb024eeeda25ebdd3279a1"
+    },
+    {
+      "path": "proofs/resolution-encounters.json",
+      "sha256": "sha256:7ce955b553e8f60371ebfc885a76e56fb6f069c8ce34788b7e15ad0fec41024f"
+    },
+    {
+      "path": "proofs/coordination.json",
+      "sha256": "sha256:cce0a70047d346d80bb61e130f1e319b7ffc83d5d68e15ae4b6b875ccdd29c5a"
+    },
+    {
+      "path": "proofs/lean/Obligations/HellyComb.lean",
+      "sha256": "sha256:63aaee48944cd7b36bfbf22cd3fb38aad2b1846908d79c8061647d0523069c06"
+    },
+    {
+      "path": "vectors/laws/helly-comb.lean.json",
+      "sha256": "sha256:e3ae1b0a9a579180a6d4495682bfbd7742e423e59e8a0b0fdd8d0528c16f497d"
+    },
+    {
+      "path": "samples/laws/linage-rest/yes.json",
+      "sha256": "sha256:5545d2fa682a565bc05fc15210f3d848a4ed4da16306343f6c2022fa4934971f"
+    },
+    {
+      "path": "samples/laws/linage-rest/no.json",
+      "sha256": "sha256:c6430a75437b5bb80139574e5e4e78b6fc7ae3533338c20cd723e0ea8aa5d13d"
+    },
+    {
+      "path": "samples/yes/H1-uncertainty.json",
+      "sha256": "sha256:c776e1efdcb23a2c19f692e1b49300d4779027f953ad1c4e581c2ca2162c9304"
+    },
+    {
+      "path": "samples/no/H1-uncertainty.json",
+      "sha256": "sha256:ce55c4a2fb22e001a41cd7f6227ddbbbcda2ca675663c8a913cad4cd2423f3a7"
+    },
+    {
+      "path": "vectors/laws/policy.json",
+      "sha256": "sha256:e941ce8cd86f0ec31621fa6b4deef9685dc1fead283f4b2fe22a8a58e3d5d939"
+    },
+    {
+      "path": "src/measures/unanimity-fit.ts",
+      "sha256": "sha256:bfe9b5d3b24d9dd5391bbb426f19e60ea5064449b95f81994ae55293ed915c47"
+    },
+    {
+      "path": "src/measures/rational.ts",
+      "sha256": "sha256:d8b9eadbba673a594ee45386cb927ff2e9e5c5323d9aa9f129ed6d8ae2512e2a"
+    },
+    {
+      "path": "test/support/linage-rest-reader.ts",
+      "sha256": "sha256:6b1ff1cd94934070821ee4e843d5a68227f77b5f1f9c74746bb3282713e7f315"
+    }
+  ],
+  "result": {
+    "classification": "declared-model measure, exact finite enumeration",
+    "model": {
+      "n": 5,
+      "f": {
+        "numerator": "1",
+        "denominator": "4"
+      },
+      "e": {
+        "numerator": "1",
+        "denominator": "5"
+      },
+      "privateJoint": "conditionally-iid-given-truth",
+      "active": "all-selected-sources-same-wrong-label"
+    },
+    "rows": [
+      {
+        "L": 1,
+        "conditionalTruth": 0,
+        "privateAtoms": 5,
+        "unanimity": {
+          "numerator": "1",
+          "denominator": "1"
+        },
+        "wrongUnanimity": {
+          "numerator": "2",
+          "denominator": "5"
+        },
+        "finiteExcessAboveF": {
+          "numerator": "3",
+          "denominator": "4"
+        },
+        "exactEnumerationMatches": true
+      },
+      {
+        "L": 2,
+        "conditionalTruth": 0,
+        "privateAtoms": 25,
+        "unanimity": {
+          "numerator": "59",
+          "denominator": "80"
+        },
+        "wrongUnanimity": {
+          "numerator": "103",
+          "denominator": "400"
+        },
+        "finiteExcessAboveF": {
+          "numerator": "39",
+          "denominator": "80"
+        },
+        "exactEnumerationMatches": true
+      },
+      {
+        "L": 3,
+        "conditionalTruth": 0,
+        "privateAtoms": 125,
+        "unanimity": {
+          "numerator": "203",
+          "denominator": "320"
+        },
+        "wrongUnanimity": {
+          "numerator": "2003",
+          "denominator": "8000"
+        },
+        "finiteExcessAboveF": {
+          "numerator": "123",
+          "denominator": "320"
+        },
+        "exactEnumerationMatches": true
+      },
+      {
+        "L": 4,
+        "conditionalTruth": 0,
+        "privateAtoms": 625,
+        "unanimity": {
+          "numerator": "17831",
+          "denominator": "32000"
+        },
+        "wrongUnanimity": {
+          "numerator": "40003",
+          "denominator": "160000"
+        },
+        "finiteExcessAboveF": {
+          "numerator": "9831",
+          "denominator": "32000"
+        },
+        "exactEnumerationMatches": true
+      },
+      {
+        "L": 5,
+        "conditionalTruth": 0,
+        "privateAtoms": 3125,
+        "unanimity": {
+          "numerator": "317287",
+          "denominator": "640000"
+        },
+        "wrongUnanimity": {
+          "numerator": "800003",
+          "denominator": "3200000"
+        },
+        "finiteExcessAboveF": {
+          "numerator": "157287",
+          "denominator": "640000"
+        },
+        "exactEnumerationMatches": true
+      },
+      {
+        "L": 6,
+        "conditionalTruth": 0,
+        "privateAtoms": 15625,
+        "unanimity": {
+          "numerator": "5716583",
+          "denominator": "12800000"
+        },
+        "wrongUnanimity": {
+          "numerator": "16000003",
+          "denominator": "64000000"
+        },
+        "finiteExcessAboveF": {
+          "numerator": "2516583",
+          "denominator": "12800000"
+        },
+        "exactEnumerationMatches": true
+      }
+    ],
+    "existingFit": {
+      "model": "single-dominant-factor@1",
+      "lineage": "declared-coordinated-group",
+      "cardinality": 5,
+      "policy": {
+        "procedure": "exact-c-slices-on-declared-p-grid@1",
+        "p": [
+          "1/5"
+        ],
+        "tolerance": "0",
+        "budget": "1000000",
+        "bootstrap": {
+          "B": 0,
+          "seed": 7,
+          "prng": "xorshift32",
+          "randomWords": 0
+        }
+      },
+      "meaning": "compatible with (c,p) under the declared model, on the declared p slices only",
+      "workUnit": "rational-bit-and-group-bound",
+      "status": "measured",
+      "compatible": [
+        {
+          "p": {
+            "numerator": "1",
+            "denominator": "5"
+          },
+          "c": {
+            "lo": {
+              "numerator": "1",
+              "denominator": "4"
+            },
+            "hi": {
+              "numerator": "1",
+              "denominator": "4"
+            }
+          },
+          "residuals": [
+            {
+              "k": 1,
+              "at": "slice-midpoint",
+              "predicted": {
+                "numerator": "1",
+                "denominator": "1"
+              },
+              "observed": {
+                "numerator": "1",
+                "denominator": "1"
+              },
+              "residual": {
+                "numerator": "0",
+                "denominator": "1"
+              }
+            },
+            {
+              "k": 2,
+              "at": "slice-midpoint",
+              "predicted": {
+                "numerator": "59",
+                "denominator": "80"
+              },
+              "observed": {
+                "numerator": "59",
+                "denominator": "80"
+              },
+              "residual": {
+                "numerator": "0",
+                "denominator": "1"
+              }
+            },
+            {
+              "k": 3,
+              "at": "slice-midpoint",
+              "predicted": {
+                "numerator": "203",
+                "denominator": "320"
+              },
+              "observed": {
+                "numerator": "203",
+                "denominator": "320"
+              },
+              "residual": {
+                "numerator": "0",
+                "denominator": "1"
+              }
+            },
+            {
+              "k": 4,
+              "at": "slice-midpoint",
+              "predicted": {
+                "numerator": "17831",
+                "denominator": "32000"
+              },
+              "observed": {
+                "numerator": "17831",
+                "denominator": "32000"
+              },
+              "residual": {
+                "numerator": "0",
+                "denominator": "1"
+              }
+            },
+            {
+              "k": 5,
+              "at": "slice-midpoint",
+              "predicted": {
+                "numerator": "317287",
+                "denominator": "640000"
+              },
+              "observed": {
+                "numerator": "317287",
+                "denominator": "640000"
+              },
+              "residual": {
+                "numerator": "0",
+                "denominator": "1"
+              }
+            },
+            {
+              "k": 6,
+              "at": "slice-midpoint",
+              "predicted": {
+                "numerator": "5716583",
+                "denominator": "12800000"
+              },
+              "observed": {
+                "numerator": "5716583",
+                "denominator": "12800000"
+              },
+              "residual": {
+                "numerator": "0",
+                "denominator": "1"
+              }
+            }
+          ]
+        }
+      ],
+      "identification": {
+        "status": "unmeasured",
+        "cause": "finite slices do not certify continuous parameter identification",
+        "diagnostics": []
+      },
+      "uncertainty": {
+        "status": "unmeasured",
+        "cause": "sampling groups not handed; size dependence unknown",
+        "words": 0
+      }
+    },
+    "degeneracies": {
+      "eZero": {
+        "unanimity": "1",
+        "wrongUnanimity": {
+          "numerator": "1",
+          "denominator": "4"
+        },
+        "identification": "unmeasured: U_L=1 at every L for any f"
+      },
+      "binaryPrivatePerfectlyCorrelated": {
+        "n": 2,
+        "e": "1/2",
+        "L": 3,
+        "actualUnanimity": "1",
+        "iidUnanimity": "1/4",
+        "jointIndependence": false
+      },
+      "twoPartialCauses": {
+        "n": 3,
+        "L": 4,
+        "e": "0",
+        "groups": [
+          [
+            0,
+            1
+          ],
+          [
+            2,
+            3
+          ]
+        ],
+        "activationPerGroup": {
+          "numerator": "1",
+          "denominator": "8"
+        },
+        "distinctWrongLabels": [
+          1,
+          2
+        ],
+        "allSourceUnanimity": {
+          "numerator": "49",
+          "denominator": "64"
+        },
+        "singleCauseWithEZeroUnanimity": "1",
+        "sumActivationProbabilities": {
+          "numerator": "1",
+          "denominator": "4"
+        }
+      }
+    },
+    "interpretation": "compatible f on the handed p slice only; no causal mechanism, intention, continuous identification or sampling guarantee",
+    "headInference": false
+  },
+  "admission": false,
+  "signatures": 0
+}

package/vectors/laws/f1/finite-arithmetic.json

@@ -0,0 +1,66 @@
+{
+  "about": [
+    "F1: this vector checks formula arithmetic and Bell-squared counts for n=3..7, using binary64 logarithms. It does not itself enumerate partition pairs.",
+    "Existing law samples and laws-papers tests supply finite partition checks. path-witness.json now supplies the explicit unrestricted proof chain under finite uniform partition hypotheses; arithmetic vectors do not themselves verify that argument or create independent origins."
+  ],
+  "coverage": {
+    "criterion": "fixed witnesses and counterexamples only",
+    "could_exclude_counterexamples": true,
+    "why": "finite arithmetic checks; not a general proof"
+  },
+  "cases": [
+    {
+      "n": 3,
+      "bell": 5,
+      "pairs": 25,
+      "expected": 0.2516291673878228
+    },
+    {
+      "n": 4,
+      "bell": 15,
+      "pairs": 225,
+      "expected": 0.5
+    },
+    {
+      "n": 5,
+      "bell": 52,
+      "pairs": 2704,
+      "expected": 0.7219280948873623
+    },
+    {
+      "n": 6,
+      "bell": 203,
+      "pairs": 41209,
+      "expected": 0.9182958340544894
+    },
+    {
+      "n": 7,
+      "bell": 877,
+      "pairs": 769129,
+      "expected": 1.093069207771889
+    }
+  ],
+  "existingEvidence": {
+    "references": [
+      "test/laws-papers.test.ts",
+      "test/vectors-harness.ts",
+      "samples/yes/lem-phi.json",
+      "samples/yes/lem-merge.json",
+      "samples/yes/lem-identity.json",
+      "samples/yes/lem-join.json",
+      "samples/yes/lem-meet.json",
+      "samples/yes/thm-extremal.json",
+      "vectors/laws/f1/path-witness.json"
+    ],
+    "finiteChecks": {
+      "lem-phi": "t=1..6, equality at 1 and 2",
+      "lem-merge": "all positive block sizes p+q<=6; all coarsenings on n=4",
+      "lem-identity": "119 ordered trivial-meet pairs on n=4",
+      "lem-meet": "225 ordered pairs on n=4, weighted restricted-pair decomposition and bound",
+      "lem-join": "all ordered trivial-meet pairs on n=3,4,5: 15,119,1343; discrete-join pairs: 8,56,552",
+      "thm-extremal": "existing test checks c_n formula values at n=1,2,4,16; this does not check all extremizers"
+    },
+    "remaining": "No exhaustive n=6,7 extrema enumeration or independent browser/WASM execution is supplied. The explicit general argument is recorded separately in path-witness.json; independent-origin verification remains open."
+  },
+  "policy": "vectors/laws/policy.json"
+}

package/vectors/laws/f1/path-witness.json

@@ -0,0 +1,242 @@
+{
+  "scope": "F1/finite-uniform-partition-lattice",
+  "status": "explicit general mathematical proof and distinguishing finite witnesses; independent-origin verification remains open",
+  "remaining": [
+    "Independent-origin verification of the explicit general proof; finite witnesses alone do not establish two decorrelated origins."
+  ],
+  "pathSizes": [
+    3,
+    4,
+    5
+  ],
+  "negative": {
+    "name": "connected branching tree is not an extremal path",
+    "n": 4,
+    "x": [
+      [
+        0,
+        1,
+        2
+      ],
+      [
+        3
+      ]
+    ],
+    "y": [
+      [
+        0
+      ],
+      [
+        1
+      ],
+      [
+        2,
+        3
+      ]
+    ],
+    "degrees": [
+      3,
+      1,
+      1,
+      1,
+      2
+    ],
+    "expectedResidual": 0.31127812445913283,
+    "falseClaim": "Every connected simple tree with n edges attains c_n, regardless of its vertex degrees."
+  },
+  "hypotheses": [
+    "n is a positive integer",
+    "X and Y are partitions of the same n-element set",
+    "the probability measure is uniform on those n elements",
+    "RI = H(X)+H(Y)-H(join)-H(meet), with the maintained refinement order"
+  ],
+  "proofChain": [
+    {
+      "id": "F1/graph-identity",
+      "dependsOn": [],
+      "argument": "If meet is trivial, the bipartite block graph is connected. One vertex per X/Y block; a nonempty intersection gives one edge of integer weight c, vertex degree a is total incident weight, and total edge weight is n. With phi(t)=t log2(t), H(X)=log2(n)-sum_X phi(a)/n, H(Y) analogously, H(join)=log2(n)-sum_edges phi(c)/n, H(meet)=0. Hence RI=log2(n)-Phi/n with Phi=sum_vertices phi(a)-sum_edges phi(c)."
+    },
+    {
+      "id": "F1/overlap-split",
+      "dependsOn": [
+        "F1/graph-identity"
+      ],
+      "argument": "For an edge with weight c>=2, choose one incident block A with size a>=c, pull one atom in that intersection out of A into a new singleton block, and leave the other partition unchanged. The original intersection retains c-1 atoms, so no original graph vertex or connection disappears; the new singleton is a leaf, preserving connectivity and trivial meet. Phi_old-Phi_new=[phi(a)-phi(a-1)]-[phi(c)-phi(c-1)]>=0: phi is strictly convex on positive reals (phi_second(t)=1/(t ln(2))). Thus RI_new>=RI_old, strictly if a>c. The integer potential sum_edges(c-1)=n-edge_count decreases by one; finitely many splits reach discrete join."
+    },
+    {
+      "id": "F1/strict-overlap",
+      "dependsOn": [
+        "F1/overlap-split"
+      ],
+      "argument": "When n>=3 and some edge has c>=2, if either endpoint has size greater than c, choose it for a strict improvement. Otherwise both endpoint sizes equal c; connectedness then forces this to be the sole edge and n=c. The first split may preserve Phi. Since n>=3, the remaining edge has weight n-1>=2; split its opposite endpoint, whose size is still n>n-1, to obtain a strict improvement. Therefore any weighted-overlap pair is strictly below the maximum for n>=3."
+    },
+    {
+      "id": "F1/degree-floor",
+      "dependsOn": [],
+      "argument": "For integer d>=1, phi(d)>=2(d-1), equality exactly at d=1,2. Equality is direct at 1,2. For real d>=2, the derivative of phi(d)-2(d-1) is log2(d)+1/ln(2)-2>0."
+    },
+    {
+      "id": "F1/simple-graph-upper-equality",
+      "dependsOn": [
+        "F1/graph-identity",
+        "F1/degree-floor"
+      ],
+      "argument": "At discrete join every edge weight is one. The connected simple bipartite graph has n edges, v<=n+1 vertices and sum_degrees=2n. Thus Phi=sum phi(d)>=2(2n-v)>=2(n-1), giving RI<=log2(n)-2+2/n=c_n. Equality requires v=n+1 and all degrees in {1,2}: a connected tree with maximum degree two is a path. Conversely a path has two degree-one vertices and n-1 degree-two vertices and attains c_n."
+    },
+    {
+      "id": "F1/trivial-meet-upper-equality",
+      "dependsOn": [
+        "F1/overlap-split",
+        "F1/strict-overlap",
+        "F1/simple-graph-upper-equality"
+      ],
+      "argument": "A trivial-meet weighted pair can be split to a simple connected pair without decreasing RI; the latter is bounded by c_n. For n>=3 strict-overlap excludes weighted pairs from equality, leaving exactly simple paths, including their atom relabellings and interchange of X/Y."
+    },
+    {
+      "id": "F1/component-decomposition",
+      "dependsOn": [],
+      "argument": "For a nontrivial meet, its blocks are the connected components C_t of the block graph, with sizes n_t. X, Y and join refine meet, so entropy chain rules give H(X)=H(meet)+sum_t(n_t/n)H(X|C_t), and likewise for Y and join. Consequently RI=sum_t(n_t/n)RI_t, each restricted pair having trivial meet."
+    },
+    {
+      "id": "F1/component-upper-equality",
+      "dependsOn": [
+        "F1/component-decomposition",
+        "F1/trivial-meet-upper-equality"
+      ],
+      "argument": "Every RI_t<=c_(n_t). Here c_1=c_2=0; for real x>=2, c_prime(x)=1/(x ln(2))-2/x^2>0. Therefore c_k<c_n for every integer 1<=k<n when n>=3. With more than one component, all n_t<n, and RI<=sum_t(n_t/n)c_(n_t)<c_n. Thus equality for n>=3 forces trivial meet and the path characterization above."
+    },
+    {
+      "id": "F1/small-boundary",
+      "dependsOn": [],
+      "argument": "For n=1 the unique partition pair gives RI=0=c_1. For n=2 the two partitions form a chain; for any pair its meet and join are the pair itself in some order, so RI=0=c_2. Hence every pair attains the zero maximum in these two cases."
+    }
+  ],
+  "overlapReduction": {
+    "name": "split a weighted intersection from its larger endpoint",
+    "n": 4,
+    "xBefore": [
+      [
+        0,
+        1,
+        2
+      ],
+      [
+        3
+      ]
+    ],
+    "y": [
+      [
+        0,
+        1
+      ],
+      [
+        2,
+        3
+      ]
+    ],
+    "xAfter": [
+      [
+        0,
+        2
+      ],
+      [
+        1
+      ],
+      [
+        3
+      ]
+    ],
+    "splitAtom": 1,
+    "edgeWeightBefore": 2,
+    "endpointSizeBefore": 3,
+    "expectedBefore": 0.31127812445913283,
+    "expectedAfter": 0.5
+  },
+  "componentWitness": {
+    "name": "path on three atoms plus a two-atom component is below global c_5",
+    "n": 5,
+    "x": [
+      [
+        0
+      ],
+      [
+        1,
+        2
+      ],
+      [
+        3
+      ],
+      [
+        4
+      ]
+    ],
+    "y": [
+      [
+        0,
+        1
+      ],
+      [
+        2
+      ],
+      [
+        3,
+        4
+      ]
+    ],
+    "components": [
+      [
+        0,
+        1,
+        2
+      ],
+      [
+        3,
+        4
+      ]
+    ],
+    "componentSizes": [
+      3,
+      2
+    ]
+  },
+  "soleOverlapReduction": {
+    "name": "sole weighted edge needs an equal split followed by a strict split",
+    "n": 3,
+    "xBefore": [
+      [
+        0,
+        1,
+        2
+      ]
+    ],
+    "yBefore": [
+      [
+        0,
+        1,
+        2
+      ]
+    ],
+    "xAfter": [
+      [
+        0
+      ],
+      [
+        1,
+        2
+      ]
+    ],
+    "yAfter": [
+      [
+        0,
+        2
+      ],
+      [
+        1
+      ]
+    ],
+    "expectedBefore": 0,
+    "expectedFirstSplit": 0,
+    "expectedFinal": 0.2516291673878228
+  },
+  "policy": "vectors/laws/policy.json"
+}