diff --git a/research/bounded-pending-fanout-seed53/CERTIFICATE.json b/research/bounded-pending-fanout-seed53/CERTIFICATE.json new file mode 100644 index 0000000000..c8c8ed1c97 --- /dev/null +++ b/research/bounded-pending-fanout-seed53/CERTIFICATE.json @@ -0,0 +1,8818 @@ +{ + "base": "ce7ad1b6ab09452c3478723a2e96ed5ff212dc08", + "capacity": 2, + "factors": { + "A0": [ + "A0f0", + "A0f1" + ], + "A1": [ + "A1f0", + "A1f1", + "A1f2" + ], + "A2": [ + "A2f0", + "A2f1", + "A2f2", + "A2f3" + ], + "A3": [ + "A3f0", + "A3f1", + "A3f2", + "A3f3", + "A3f4" + ], + "A4": [ + "A4f0", + "A4f1", + "A4f2", + "A4f3", + "A4f4", + "A4f5" + ], + "B": [ + "Bf0", + "Bf1", + "Bf2", + "Bf3", + "Bf4", + "Bf5", + "Bf6" + ] + }, + "format": "bounded-pending-fanout-v1", + "outputs": 5, + "plans": { + "bounded": { + "commit_after": [ + 3, + 4, + 8, + 9, + 12 + ], + "dirty_rows": 4, + "leaf_commit_after": [ + 69, + 79, + 191, + 219, + 351 + ], + "leaves": [ + [ + "A0f1", + 7, + 1, + 1 + ], + [ + "A0f0", + 6, + 7, + 1 + ], + [ + "A0f1", + 7, + 1, + -1 + ], + [ + "A0f0", + 6, + 7, + -1 + ], + [ + "A1f1", + 7, + 8, + 1 + ], + [ + "A1f2", + 8, + 2, + 1 + ], + [ + "A1f1", + 7, + 8, + -1 + ], + [ + "A1f2", + 8, + 2, + -1 + ], + [ + "A1f0", + 6, + 7, + 1 + ], + [ + "A1f2", + 8, + 2, + 1 + ], + [ + "A1f1", + 7, + 8, + 1 + ], + [ + "A1f2", + 8, + 2, + -1 + ], + [ + "A1f1", + 7, + 8, + -1 + ], + [ + "A1f0", + 6, + 7, + -1 + ], + [ + "Bf0", + 0, + 8, + 1 + ], + [ + "Bf1", + 8, + 9, + 1 + ], + [ + "Bf2", + 9, + 7, + 1 + ], + [ + "Bf1", + 8, + 9, + -1 + ], + [ + "Bf2", + 9, + 7, + -1 + ], + [ + "Bf0", + 0, + 8, + -1 + ], + [ + "Bf2", + 9, + 7, + 1 + ], + [ + "Bf1", + 8, + 9, + 1 + ], + [ + "Bf2", + 9, + 7, + -1 + ], + [ + "Bf1", + 8, + 9, + -1 + ], + [ + "Bf3", + 7, + 9, + 1 + ], + [ + "Bf4", + 9, + 8, + 1 + ], + [ + "Bf3", + 7, + 9, + -1 + ], + [ + "Bf4", + 9, + 8, + -1 + ], + [ + "Bf5", + 8, + 9, + 1 + ], + [ + "Bf6", + 9, + 6, + 1 + ], + [ + "Bf5", + 8, + 9, + -1 + ], + [ + "Bf6", + 9, + 6, + -1 + ], + [ + "Bf4", + 9, + 8, + 1 + ], + [ + "Bf3", + 7, + 9, + 1 + ], + [ + "Bf4", + 9, + 8, + -1 + ], + [ + "Bf3", + 7, + 9, + -1 + ], + [ + "Bf6", + 9, + 6, + 1 + ], + [ + "Bf5", + 8, + 9, + 1 + ], + [ + "Bf6", + 9, + 6, + -1 + ], + [ + "Bf5", + 8, + 9, + -1 + ], + [ + "Bf1", + 8, + 9, + 1 + ], + [ + "Bf2", + 9, + 7, + 1 + ], + [ + "Bf1", + 8, + 9, + -1 + ], + [ + "Bf2", + 9, + 7, + -1 + ], + [ + "Bf0", + 0, + 8, + 1 + ], + [ + "Bf2", + 9, + 7, + 1 + ], + [ + "Bf1", + 8, + 9, + 1 + ], + [ + "Bf2", + 9, + 7, + -1 + ], + [ + "Bf1", + 8, + 9, + -1 + ], + [ + "Bf0", + 0, + 8, + -1 + ], + [ + "Bf5", + 8, + 9, + 1 + ], + [ + "Bf6", + 9, + 6, + 1 + ], + [ + "Bf5", + 8, + 9, + -1 + ], + [ + "Bf6", + 9, + 6, + -1 + ], + [ + "Bf3", + 7, + 9, + 1 + ], + [ + "Bf4", + 9, + 8, + 1 + ], + [ + "Bf3", + 7, + 9, + -1 + ], + [ + "Bf4", + 9, + 8, + -1 + ], + [ + "Bf6", + 9, + 6, + 1 + ], + [ + "Bf5", + 8, + 9, + 1 + ], + [ + "Bf6", + 9, + 6, + -1 + ], + [ + "Bf5", + 8, + 9, + -1 + ], + [ + "Bf4", + 9, + 8, + 1 + ], + [ + "Bf3", + 7, + 9, + 1 + ], + [ + "Bf4", + 9, + 8, + -1 + ], + [ + "Bf3", + 7, + 9, + -1 + ], + [ + "A0f0", + 6, + 7, + 1 + ], + [ + "A0f1", + 7, + 1, + 1 + ], + [ + "A0f0", + 6, + 7, + -1 + ], + [ + "A0f1", + 7, + 1, + -1 + ], + [ + "A1f0", + 6, + 7, + 1 + ], + [ + "A1f1", + 7, + 8, + 1 + ], + [ + "A1f2", + 8, + 2, + 1 + ], + [ + "A1f1", + 7, + 8, + -1 + ], + [ + "A1f2", + 8, + 2, + -1 + ], + [ + "A1f0", + 6, + 7, + -1 + ], + [ + "A1f2", + 8, + 2, + 1 + ], + [ + "A1f1", + 7, + 8, + 1 + ], + [ + "A1f2", + 8, + 2, + -1 + ], + [ + "A1f1", + 7, + 8, + -1 + ], + [ + "A2f0", + 6, + 8, + 1 + ], + [ + "A2f1", + 8, + 7, + 1 + ], + [ + "A2f0", + 6, + 8, + -1 + ], + [ + "A2f1", + 8, + 7, + -1 + ], + [ + "A2f2", + 7, + 8, + 1 + ], + [ + "A2f3", + 8, + 3, + 1 + ], + [ + "A2f2", + 7, + 8, + -1 + ], + [ + "A2f3", + 8, + 3, + -1 + ], + [ + "A2f1", + 8, + 7, + 1 + ], + [ + "A2f0", + 6, + 8, + 1 + ], + [ + "A2f1", + 8, + 7, + -1 + ], + [ + "A2f0", + 6, + 8, + -1 + ], + [ + "A2f3", + 8, + 3, + 1 + ], + [ + "A2f2", + 7, + 8, + 1 + ], + [ + "A2f3", + 8, + 3, + -1 + ], + [ + "A2f2", + 7, + 8, + -1 + ], + [ + "A3f0", + 6, + 8, + 1 + ], + [ + "A3f1", + 8, + 7, + 1 + ], + [ + "A3f0", + 6, + 8, + -1 + ], + [ + "A3f1", + 8, + 7, + -1 + ], + [ + "A3f2", + 7, + 8, + 1 + ], + [ + "A3f3", + 8, + 9, + 1 + ], + [ + "A3f4", + 9, + 4, + 1 + ], + [ + "A3f3", + 8, + 9, + -1 + ], + [ + "A3f4", + 9, + 4, + -1 + ], + [ + "A3f2", + 7, + 8, + -1 + ], + [ + "A3f4", + 9, + 4, + 1 + ], + [ + "A3f3", + 8, + 9, + 1 + ], + [ + "A3f4", + 9, + 4, + -1 + ], + [ + "A3f3", + 8, + 9, + -1 + ], + [ + "A3f1", + 8, + 7, + 1 + ], + [ + "A3f0", + 6, + 8, + 1 + ], + [ + "A3f1", + 8, + 7, + -1 + ], + [ + "A3f0", + 6, + 8, + -1 + ], + [ + "A3f3", + 8, + 9, + 1 + ], + [ + "A3f4", + 9, + 4, + 1 + ], + [ + "A3f3", + 8, + 9, + -1 + ], + [ + "A3f4", + 9, + 4, + -1 + ], + [ + "A3f2", + 7, + 8, + 1 + ], + [ + "A3f4", + 9, + 4, + 1 + ], + [ + "A3f3", + 8, + 9, + 1 + ], + [ + "A3f4", + 9, + 4, + -1 + ], + [ + "A3f3", + 8, + 9, + -1 + ], + [ + "A3f2", + 7, + 8, + -1 + ], + [ + "Bf3", + 7, + 9, + 1 + ], + [ + "Bf4", + 9, + 8, + 1 + ], + [ + "Bf3", + 7, + 9, + -1 + ], + [ + "Bf4", + 9, + 8, + -1 + ], + [ + "Bf5", + 8, + 9, + 1 + ], + [ + "Bf6", + 9, + 6, + 1 + ], + [ + "Bf5", + 8, + 9, + -1 + ], + [ + "Bf6", + 9, + 6, + -1 + ], + [ + "Bf4", + 9, + 8, + 1 + ], + [ + "Bf3", + 7, + 9, + 1 + ], + [ + "Bf4", + 9, + 8, + -1 + ], + [ + "Bf3", + 7, + 9, + -1 + ], + [ + "Bf6", + 9, + 6, + 1 + ], + [ + "Bf5", + 8, + 9, + 1 + ], + [ + "Bf6", + 9, + 6, + -1 + ], + [ + "Bf5", + 8, + 9, + -1 + ], + [ + "Bf0", + 0, + 8, + 1 + ], + [ + "Bf1", + 8, + 9, + 1 + ], + [ + "Bf2", + 9, + 7, + 1 + ], + [ + "Bf1", + 8, + 9, + -1 + ], + [ + "Bf2", + 9, + 7, + -1 + ], + [ + "Bf0", + 0, + 8, + -1 + ], + [ + "Bf2", + 9, + 7, + 1 + ], + [ + "Bf1", + 8, + 9, + 1 + ], + [ + "Bf2", + 9, + 7, + -1 + ], + [ + "Bf1", + 8, + 9, + -1 + ], + [ + "Bf5", + 8, + 9, + 1 + ], + [ + "Bf6", + 9, + 6, + 1 + ], + [ + "Bf5", + 8, + 9, + -1 + ], + [ + "Bf6", + 9, + 6, + -1 + ], + [ + "Bf3", + 7, + 9, + 1 + ], + [ + "Bf4", + 9, + 8, + 1 + ], + [ + "Bf3", + 7, + 9, + -1 + ], + [ + "Bf4", + 9, + 8, + -1 + ], + [ + "Bf6", + 9, + 6, + 1 + ], + [ + "Bf5", + 8, + 9, + 1 + ], + [ + "Bf6", + 9, + 6, + -1 + ], + [ + "Bf5", + 8, + 9, + -1 + ], + [ + "Bf4", + 9, + 8, + 1 + ], + [ + "Bf3", + 7, + 9, + 1 + ], + [ + "Bf4", + 9, + 8, + -1 + ], + [ + "Bf3", + 7, + 9, + -1 + ], + [ + "Bf1", + 8, + 9, + 1 + ], + [ + "Bf2", + 9, + 7, + 1 + ], + [ + "Bf1", + 8, + 9, + -1 + ], + [ + "Bf2", + 9, + 7, + -1 + ], + [ + "Bf0", + 0, + 8, + 1 + ], + [ + "Bf2", + 9, + 7, + 1 + ], + [ + "Bf1", + 8, + 9, + 1 + ], + [ + "Bf2", + 9, + 7, + -1 + ], + [ + "Bf1", + 8, + 9, + -1 + ], + [ + "Bf0", + 0, + 8, + -1 + ], + [ + "A2f2", + 7, + 8, + 1 + ], + [ + "A2f3", + 8, + 3, + 1 + ], + [ + "A2f2", + 7, + 8, + -1 + ], + [ + "A2f3", + 8, + 3, + -1 + ], + [ + "A2f0", + 6, + 8, + 1 + ], + [ + "A2f1", + 8, + 7, + 1 + ], + [ + "A2f0", + 6, + 8, + -1 + ], + [ + "A2f1", + 8, + 7, + -1 + ], + [ + "A2f3", + 8, + 3, + 1 + ], + [ + "A2f2", + 7, + 8, + 1 + ], + [ + "A2f3", + 8, + 3, + -1 + ], + [ + "A2f2", + 7, + 8, + -1 + ], + [ + "A2f1", + 8, + 7, + 1 + ], + [ + "A2f0", + 6, + 8, + 1 + ], + [ + "A2f1", + 8, + 7, + -1 + ], + [ + "A2f0", + 6, + 8, + -1 + ], + [ + "A3f2", + 7, + 8, + 1 + ], + [ + "A3f3", + 8, + 9, + 1 + ], + [ + "A3f4", + 9, + 4, + 1 + ], + [ + "A3f3", + 8, + 9, + -1 + ], + [ + "A3f4", + 9, + 4, + -1 + ], + [ + "A3f2", + 7, + 8, + -1 + ], + [ + "A3f4", + 9, + 4, + 1 + ], + [ + "A3f3", + 8, + 9, + 1 + ], + [ + "A3f4", + 9, + 4, + -1 + ], + [ + "A3f3", + 8, + 9, + -1 + ], + [ + "A3f0", + 6, + 8, + 1 + ], + [ + "A3f1", + 8, + 7, + 1 + ], + [ + "A3f0", + 6, + 8, + -1 + ], + [ + "A3f1", + 8, + 7, + -1 + ], + [ + "A3f3", + 8, + 9, + 1 + ], + [ + "A3f4", + 9, + 4, + 1 + ], + [ + "A3f3", + 8, + 9, + -1 + ], + [ + "A3f4", + 9, + 4, + -1 + ], + [ + "A3f2", + 7, + 8, + 1 + ], + [ + "A3f4", + 9, + 4, + 1 + ], + [ + "A3f3", + 8, + 9, + 1 + ], + [ + "A3f4", + 9, + 4, + -1 + ], + [ + "A3f3", + 8, + 9, + -1 + ], + [ + "A3f2", + 7, + 8, + -1 + ], + [ + "A3f1", + 8, + 7, + 1 + ], + [ + "A3f0", + 6, + 8, + 1 + ], + [ + "A3f1", + 8, + 7, + -1 + ], + [ + "A3f0", + 6, + 8, + -1 + ], + [ + "A4f3", + 7, + 8, + 1 + ], + [ + "A4f4", + 8, + 9, + 1 + ], + [ + "A4f5", + 9, + 5, + 1 + ], + [ + "A4f4", + 8, + 9, + -1 + ], + [ + "A4f5", + 9, + 5, + -1 + ], + [ + "A4f3", + 7, + 8, + -1 + ], + [ + "A4f5", + 9, + 5, + 1 + ], + [ + "A4f4", + 8, + 9, + 1 + ], + [ + "A4f5", + 9, + 5, + -1 + ], + [ + "A4f4", + 8, + 9, + -1 + ], + [ + "A4f0", + 6, + 8, + 1 + ], + [ + "A4f1", + 8, + 9, + 1 + ], + [ + "A4f2", + 9, + 7, + 1 + ], + [ + "A4f1", + 8, + 9, + -1 + ], + [ + "A4f2", + 9, + 7, + -1 + ], + [ + "A4f0", + 6, + 8, + -1 + ], + [ + "A4f2", + 9, + 7, + 1 + ], + [ + "A4f1", + 8, + 9, + 1 + ], + [ + "A4f2", + 9, + 7, + -1 + ], + [ + "A4f1", + 8, + 9, + -1 + ], + [ + "A4f4", + 8, + 9, + 1 + ], + [ + "A4f5", + 9, + 5, + 1 + ], + [ + "A4f4", + 8, + 9, + -1 + ], + [ + "A4f5", + 9, + 5, + -1 + ], + [ + "A4f3", + 7, + 8, + 1 + ], + [ + "A4f5", + 9, + 5, + 1 + ], + [ + "A4f4", + 8, + 9, + 1 + ], + [ + "A4f5", + 9, + 5, + -1 + ], + [ + "A4f4", + 8, + 9, + -1 + ], + [ + "A4f3", + 7, + 8, + -1 + ], + [ + "A4f1", + 8, + 9, + 1 + ], + [ + "A4f2", + 9, + 7, + 1 + ], + [ + "A4f1", + 8, + 9, + -1 + ], + [ + "A4f2", + 9, + 7, + -1 + ], + [ + "A4f0", + 6, + 8, + 1 + ], + [ + "A4f2", + 9, + 7, + 1 + ], + [ + "A4f1", + 8, + 9, + 1 + ], + [ + "A4f2", + 9, + 7, + -1 + ], + [ + "A4f1", + 8, + 9, + -1 + ], + [ + "A4f0", + 6, + 8, + -1 + ], + [ + "Bf0", + 0, + 8, + 1 + ], + [ + "Bf1", + 8, + 9, + 1 + ], + [ + "Bf2", + 9, + 7, + 1 + ], + [ + "Bf1", + 8, + 9, + -1 + ], + [ + "Bf2", + 9, + 7, + -1 + ], + [ + "Bf0", + 0, + 8, + -1 + ], + [ + "Bf2", + 9, + 7, + 1 + ], + [ + "Bf1", + 8, + 9, + 1 + ], + [ + "Bf2", + 9, + 7, + -1 + ], + [ + "Bf1", + 8, + 9, + -1 + ], + [ + "Bf3", + 7, + 9, + 1 + ], + [ + "Bf4", + 9, + 8, + 1 + ], + [ + "Bf3", + 7, + 9, + -1 + ], + [ + "Bf4", + 9, + 8, + -1 + ], + [ + "Bf5", + 8, + 9, + 1 + ], + [ + "Bf6", + 9, + 6, + 1 + ], + [ + "Bf5", + 8, + 9, + -1 + ], + [ + "Bf6", + 9, + 6, + -1 + ], + [ + "Bf4", + 9, + 8, + 1 + ], + [ + "Bf3", + 7, + 9, + 1 + ], + [ + "Bf4", + 9, + 8, + -1 + ], + [ + "Bf3", + 7, + 9, + -1 + ], + [ + "Bf6", + 9, + 6, + 1 + ], + [ + "Bf5", + 8, + 9, + 1 + ], + [ + "Bf6", + 9, + 6, + -1 + ], + [ + "Bf5", + 8, + 9, + -1 + ], + [ + "Bf1", + 8, + 9, + 1 + ], + [ + "Bf2", + 9, + 7, + 1 + ], + [ + "Bf1", + 8, + 9, + -1 + ], + [ + "Bf2", + 9, + 7, + -1 + ], + [ + "Bf0", + 0, + 8, + 1 + ], + [ + "Bf2", + 9, + 7, + 1 + ], + [ + "Bf1", + 8, + 9, + 1 + ], + [ + "Bf2", + 9, + 7, + -1 + ], + [ + "Bf1", + 8, + 9, + -1 + ], + [ + "Bf0", + 0, + 8, + -1 + ], + [ + "Bf5", + 8, + 9, + 1 + ], + [ + "Bf6", + 9, + 6, + 1 + ], + [ + "Bf5", + 8, + 9, + -1 + ], + [ + "Bf6", + 9, + 6, + -1 + ], + [ + "Bf3", + 7, + 9, + 1 + ], + [ + "Bf4", + 9, + 8, + 1 + ], + [ + "Bf3", + 7, + 9, + -1 + ], + [ + "Bf4", + 9, + 8, + -1 + ], + [ + "Bf6", + 9, + 6, + 1 + ], + [ + "Bf5", + 8, + 9, + 1 + ], + [ + "Bf6", + 9, + 6, + -1 + ], + [ + "Bf5", + 8, + 9, + -1 + ], + [ + "Bf4", + 9, + 8, + 1 + ], + [ + "Bf3", + 7, + 9, + 1 + ], + [ + "Bf4", + 9, + 8, + -1 + ], + [ + "Bf3", + 7, + 9, + -1 + ], + [ + "A4f0", + 6, + 8, + 1 + ], + [ + "A4f1", + 8, + 9, + 1 + ], + [ + "A4f2", + 9, + 7, + 1 + ], + [ + "A4f1", + 8, + 9, + -1 + ], + [ + "A4f2", + 9, + 7, + -1 + ], + [ + "A4f0", + 6, + 8, + -1 + ], + [ + "A4f2", + 9, + 7, + 1 + ], + [ + "A4f1", + 8, + 9, + 1 + ], + [ + "A4f2", + 9, + 7, + -1 + ], + [ + "A4f1", + 8, + 9, + -1 + ], + [ + "A4f3", + 7, + 8, + 1 + ], + [ + "A4f4", + 8, + 9, + 1 + ], + [ + "A4f5", + 9, + 5, + 1 + ], + [ + "A4f4", + 8, + 9, + -1 + ], + [ + "A4f5", + 9, + 5, + -1 + ], + [ + "A4f3", + 7, + 8, + -1 + ], + [ + "A4f5", + 9, + 5, + 1 + ], + [ + "A4f4", + 8, + 9, + 1 + ], + [ + "A4f5", + 9, + 5, + -1 + ], + [ + "A4f4", + 8, + 9, + -1 + ], + [ + "A4f1", + 8, + 9, + 1 + ], + [ + "A4f2", + 9, + 7, + 1 + ], + [ + "A4f1", + 8, + 9, + -1 + ], + [ + "A4f2", + 9, + 7, + -1 + ], + [ + "A4f0", + 6, + 8, + 1 + ], + [ + "A4f2", + 9, + 7, + 1 + ], + [ + "A4f1", + 8, + 9, + 1 + ], + [ + "A4f2", + 9, + 7, + -1 + ], + [ + "A4f1", + 8, + 9, + -1 + ], + [ + "A4f0", + 6, + 8, + -1 + ], + [ + "A4f4", + 8, + 9, + 1 + ], + [ + "A4f5", + 9, + 5, + 1 + ], + [ + "A4f4", + 8, + 9, + -1 + ], + [ + "A4f5", + 9, + 5, + -1 + ], + [ + "A4f3", + 7, + 8, + 1 + ], + [ + "A4f5", + 9, + 5, + 1 + ], + [ + "A4f4", + 8, + 9, + 1 + ], + [ + "A4f5", + 9, + 5, + -1 + ], + [ + "A4f4", + 8, + 9, + -1 + ], + [ + "A4f3", + 7, + 8, + -1 + ], + [ + "Bf3", + 7, + 9, + 1 + ], + [ + "Bf4", + 9, + 8, + 1 + ], + [ + "Bf3", + 7, + 9, + -1 + ], + [ + "Bf4", + 9, + 8, + -1 + ], + [ + "Bf5", + 8, + 9, + 1 + ], + [ + "Bf6", + 9, + 6, + 1 + ], + [ + "Bf5", + 8, + 9, + -1 + ], + [ + "Bf6", + 9, + 6, + -1 + ], + [ + "Bf4", + 9, + 8, + 1 + ], + [ + "Bf3", + 7, + 9, + 1 + ], + [ + "Bf4", + 9, + 8, + -1 + ], + [ + "Bf3", + 7, + 9, + -1 + ], + [ + "Bf6", + 9, + 6, + 1 + ], + [ + "Bf5", + 8, + 9, + 1 + ], + [ + "Bf6", + 9, + 6, + -1 + ], + [ + "Bf5", + 8, + 9, + -1 + ], + [ + "Bf0", + 0, + 8, + 1 + ], + [ + "Bf1", + 8, + 9, + 1 + ], + [ + "Bf2", + 9, + 7, + 1 + ], + [ + "Bf1", + 8, + 9, + -1 + ], + [ + "Bf2", + 9, + 7, + -1 + ], + [ + "Bf0", + 0, + 8, + -1 + ], + [ + "Bf2", + 9, + 7, + 1 + ], + [ + "Bf1", + 8, + 9, + 1 + ], + [ + "Bf2", + 9, + 7, + -1 + ], + [ + "Bf1", + 8, + 9, + -1 + ], + [ + "Bf5", + 8, + 9, + 1 + ], + [ + "Bf6", + 9, + 6, + 1 + ], + [ + "Bf5", + 8, + 9, + -1 + ], + [ + "Bf6", + 9, + 6, + -1 + ], + [ + "Bf3", + 7, + 9, + 1 + ], + [ + "Bf4", + 9, + 8, + 1 + ], + [ + "Bf3", + 7, + 9, + -1 + ], + [ + "Bf4", + 9, + 8, + -1 + ], + [ + "Bf6", + 9, + 6, + 1 + ], + [ + "Bf5", + 8, + 9, + 1 + ], + [ + "Bf6", + 9, + 6, + -1 + ], + [ + "Bf5", + 8, + 9, + -1 + ], + [ + "Bf4", + 9, + 8, + 1 + ], + [ + "Bf3", + 7, + 9, + 1 + ], + [ + "Bf4", + 9, + 8, + -1 + ], + [ + "Bf3", + 7, + 9, + -1 + ], + [ + "Bf1", + 8, + 9, + 1 + ], + [ + "Bf2", + 9, + 7, + 1 + ], + [ + "Bf1", + 8, + 9, + -1 + ], + [ + "Bf2", + 9, + 7, + -1 + ], + [ + "Bf0", + 0, + 8, + 1 + ], + [ + "Bf2", + 9, + 7, + 1 + ], + [ + "Bf1", + 8, + 9, + 1 + ], + [ + "Bf2", + 9, + 7, + -1 + ], + [ + "Bf1", + 8, + 9, + -1 + ], + [ + "Bf0", + 0, + 8, + -1 + ] + ], + "word": [ + [ + "A0", + -1 + ], + [ + "A1", + -1 + ], + [ + "B", + 1 + ], + [ + "A0", + 1 + ], + [ + "A1", + 1 + ], + [ + "A2", + 1 + ], + [ + "A3", + 1 + ], + [ + "B", + -1 + ], + [ + "A2", + -1 + ], + [ + "A3", + -1 + ], + [ + "A4", + -1 + ], + [ + "B", + 1 + ], + [ + "A4", + 1 + ], + [ + "B", + -1 + ] + ] + }, + "separate": { + "commit_after": [ + 2, + 6, + 10, + 14, + 18 + ], + "dirty_rows": 4, + "leaf_commit_after": [ + 59, + 183, + 319, + 479, + 663 + ], + "leaves": [ + [ + "A0f1", + 7, + 1, + 1 + ], + [ + "A0f0", + 6, + 7, + 1 + ], + [ + "A0f1", + 7, + 1, + -1 + ], + [ + "A0f0", + 6, + 7, + -1 + ], + [ + "Bf0", + 0, + 8, + 1 + ], + [ + "Bf1", + 8, + 9, + 1 + ], + [ + "Bf2", + 9, + 7, + 1 + ], + [ + "Bf1", + 8, + 9, + -1 + ], + [ + "Bf2", + 9, + 7, + -1 + ], + [ + "Bf0", + 0, + 8, + -1 + ], + [ + "Bf2", + 9, + 7, + 1 + ], + [ + "Bf1", + 8, + 9, + 1 + ], + [ + "Bf2", + 9, + 7, + -1 + ], + [ + "Bf1", + 8, + 9, + -1 + ], + [ + "Bf3", + 7, + 9, + 1 + ], + [ + "Bf4", + 9, + 8, + 1 + ], + [ + "Bf3", + 7, + 9, + -1 + ], + [ + "Bf4", + 9, + 8, + -1 + ], + [ + "Bf5", + 8, + 9, + 1 + ], + [ + "Bf6", + 9, + 6, + 1 + ], + [ + "Bf5", + 8, + 9, + -1 + ], + [ + "Bf6", + 9, + 6, + -1 + ], + [ + "Bf4", + 9, + 8, + 1 + ], + [ + "Bf3", + 7, + 9, + 1 + ], + [ + "Bf4", + 9, + 8, + -1 + ], + [ + "Bf3", + 7, + 9, + -1 + ], + [ + "Bf6", + 9, + 6, + 1 + ], + [ + "Bf5", + 8, + 9, + 1 + ], + [ + "Bf6", + 9, + 6, + -1 + ], + [ + "Bf5", + 8, + 9, + -1 + ], + [ + "Bf1", + 8, + 9, + 1 + ], + [ + "Bf2", + 9, + 7, + 1 + ], + [ + "Bf1", + 8, + 9, + -1 + ], + [ + "Bf2", + 9, + 7, + -1 + ], + [ + "Bf0", + 0, + 8, + 1 + ], + [ + "Bf2", + 9, + 7, + 1 + ], + [ + "Bf1", + 8, + 9, + 1 + ], + [ + "Bf2", + 9, + 7, + -1 + ], + [ + "Bf1", + 8, + 9, + -1 + ], + [ + "Bf0", + 0, + 8, + -1 + ], + [ + "Bf5", + 8, + 9, + 1 + ], + [ + "Bf6", + 9, + 6, + 1 + ], + [ + "Bf5", + 8, + 9, + -1 + ], + [ + "Bf6", + 9, + 6, + -1 + ], + [ + "Bf3", + 7, + 9, + 1 + ], + [ + "Bf4", + 9, + 8, + 1 + ], + [ + "Bf3", + 7, + 9, + -1 + ], + [ + "Bf4", + 9, + 8, + -1 + ], + [ + "Bf6", + 9, + 6, + 1 + ], + [ + "Bf5", + 8, + 9, + 1 + ], + [ + "Bf6", + 9, + 6, + -1 + ], + [ + "Bf5", + 8, + 9, + -1 + ], + [ + "Bf4", + 9, + 8, + 1 + ], + [ + "Bf3", + 7, + 9, + 1 + ], + [ + "Bf4", + 9, + 8, + -1 + ], + [ + "Bf3", + 7, + 9, + -1 + ], + [ + "A0f0", + 6, + 7, + 1 + ], + [ + "A0f1", + 7, + 1, + 1 + ], + [ + "A0f0", + 6, + 7, + -1 + ], + [ + "A0f1", + 7, + 1, + -1 + ], + [ + "Bf3", + 7, + 9, + 1 + ], + [ + "Bf4", + 9, + 8, + 1 + ], + [ + "Bf3", + 7, + 9, + -1 + ], + [ + "Bf4", + 9, + 8, + -1 + ], + [ + "Bf5", + 8, + 9, + 1 + ], + [ + "Bf6", + 9, + 6, + 1 + ], + [ + "Bf5", + 8, + 9, + -1 + ], + [ + "Bf6", + 9, + 6, + -1 + ], + [ + "Bf4", + 9, + 8, + 1 + ], + [ + "Bf3", + 7, + 9, + 1 + ], + [ + "Bf4", + 9, + 8, + -1 + ], + [ + "Bf3", + 7, + 9, + -1 + ], + [ + "Bf6", + 9, + 6, + 1 + ], + [ + "Bf5", + 8, + 9, + 1 + ], + [ + "Bf6", + 9, + 6, + -1 + ], + [ + "Bf5", + 8, + 9, + -1 + ], + [ + "Bf0", + 0, + 8, + 1 + ], + [ + "Bf1", + 8, + 9, + 1 + ], + [ + "Bf2", + 9, + 7, + 1 + ], + [ + "Bf1", + 8, + 9, + -1 + ], + [ + "Bf2", + 9, + 7, + -1 + ], + [ + "Bf0", + 0, + 8, + -1 + ], + [ + "Bf2", + 9, + 7, + 1 + ], + [ + "Bf1", + 8, + 9, + 1 + ], + [ + "Bf2", + 9, + 7, + -1 + ], + [ + "Bf1", + 8, + 9, + -1 + ], + [ + "Bf5", + 8, + 9, + 1 + ], + [ + "Bf6", + 9, + 6, + 1 + ], + [ + "Bf5", + 8, + 9, + -1 + ], + [ + "Bf6", + 9, + 6, + -1 + ], + [ + "Bf3", + 7, + 9, + 1 + ], + [ + "Bf4", + 9, + 8, + 1 + ], + [ + "Bf3", + 7, + 9, + -1 + ], + [ + "Bf4", + 9, + 8, + -1 + ], + [ + "Bf6", + 9, + 6, + 1 + ], + [ + "Bf5", + 8, + 9, + 1 + ], + [ + "Bf6", + 9, + 6, + -1 + ], + [ + "Bf5", + 8, + 9, + -1 + ], + [ + "Bf4", + 9, + 8, + 1 + ], + [ + "Bf3", + 7, + 9, + 1 + ], + [ + "Bf4", + 9, + 8, + -1 + ], + [ + "Bf3", + 7, + 9, + -1 + ], + [ + "Bf1", + 8, + 9, + 1 + ], + [ + "Bf2", + 9, + 7, + 1 + ], + [ + "Bf1", + 8, + 9, + -1 + ], + [ + "Bf2", + 9, + 7, + -1 + ], + [ + "Bf0", + 0, + 8, + 1 + ], + [ + "Bf2", + 9, + 7, + 1 + ], + [ + "Bf1", + 8, + 9, + 1 + ], + [ + "Bf2", + 9, + 7, + -1 + ], + [ + "Bf1", + 8, + 9, + -1 + ], + [ + "Bf0", + 0, + 8, + -1 + ], + [ + "A1f1", + 7, + 8, + 1 + ], + [ + "A1f2", + 8, + 2, + 1 + ], + [ + "A1f1", + 7, + 8, + -1 + ], + [ + "A1f2", + 8, + 2, + -1 + ], + [ + "A1f0", + 6, + 7, + 1 + ], + [ + "A1f2", + 8, + 2, + 1 + ], + [ + "A1f1", + 7, + 8, + 1 + ], + [ + "A1f2", + 8, + 2, + -1 + ], + [ + "A1f1", + 7, + 8, + -1 + ], + [ + "A1f0", + 6, + 7, + -1 + ], + [ + "Bf0", + 0, + 8, + 1 + ], + [ + "Bf1", + 8, + 9, + 1 + ], + [ + "Bf2", + 9, + 7, + 1 + ], + [ + "Bf1", + 8, + 9, + -1 + ], + [ + "Bf2", + 9, + 7, + -1 + ], + [ + "Bf0", + 0, + 8, + -1 + ], + [ + "Bf2", + 9, + 7, + 1 + ], + [ + "Bf1", + 8, + 9, + 1 + ], + [ + "Bf2", + 9, + 7, + -1 + ], + [ + "Bf1", + 8, + 9, + -1 + ], + [ + "Bf3", + 7, + 9, + 1 + ], + [ + "Bf4", + 9, + 8, + 1 + ], + [ + "Bf3", + 7, + 9, + -1 + ], + [ + "Bf4", + 9, + 8, + -1 + ], + [ + "Bf5", + 8, + 9, + 1 + ], + [ + "Bf6", + 9, + 6, + 1 + ], + [ + "Bf5", + 8, + 9, + -1 + ], + [ + "Bf6", + 9, + 6, + -1 + ], + [ + "Bf4", + 9, + 8, + 1 + ], + [ + "Bf3", + 7, + 9, + 1 + ], + [ + "Bf4", + 9, + 8, + -1 + ], + [ + "Bf3", + 7, + 9, + -1 + ], + [ + "Bf6", + 9, + 6, + 1 + ], + [ + "Bf5", + 8, + 9, + 1 + ], + [ + "Bf6", + 9, + 6, + -1 + ], + [ + "Bf5", + 8, + 9, + -1 + ], + [ + "Bf1", + 8, + 9, + 1 + ], + [ + "Bf2", + 9, + 7, + 1 + ], + [ + "Bf1", + 8, + 9, + -1 + ], + [ + "Bf2", + 9, + 7, + -1 + ], + [ + "Bf0", + 0, + 8, + 1 + ], + [ + "Bf2", + 9, + 7, + 1 + ], + [ + "Bf1", + 8, + 9, + 1 + ], + [ + "Bf2", + 9, + 7, + -1 + ], + [ + "Bf1", + 8, + 9, + -1 + ], + [ + "Bf0", + 0, + 8, + -1 + ], + [ + "Bf5", + 8, + 9, + 1 + ], + [ + "Bf6", + 9, + 6, + 1 + ], + [ + "Bf5", + 8, + 9, + -1 + ], + [ + "Bf6", + 9, + 6, + -1 + ], + [ + "Bf3", + 7, + 9, + 1 + ], + [ + "Bf4", + 9, + 8, + 1 + ], + [ + "Bf3", + 7, + 9, + -1 + ], + [ + "Bf4", + 9, + 8, + -1 + ], + [ + "Bf6", + 9, + 6, + 1 + ], + [ + "Bf5", + 8, + 9, + 1 + ], + [ + "Bf6", + 9, + 6, + -1 + ], + [ + "Bf5", + 8, + 9, + -1 + ], + [ + "Bf4", + 9, + 8, + 1 + ], + [ + "Bf3", + 7, + 9, + 1 + ], + [ + "Bf4", + 9, + 8, + -1 + ], + [ + "Bf3", + 7, + 9, + -1 + ], + [ + "A1f0", + 6, + 7, + 1 + ], + [ + "A1f1", + 7, + 8, + 1 + ], + [ + "A1f2", + 8, + 2, + 1 + ], + [ + "A1f1", + 7, + 8, + -1 + ], + [ + "A1f2", + 8, + 2, + -1 + ], + [ + "A1f0", + 6, + 7, + -1 + ], + [ + "A1f2", + 8, + 2, + 1 + ], + [ + "A1f1", + 7, + 8, + 1 + ], + [ + "A1f2", + 8, + 2, + -1 + ], + [ + "A1f1", + 7, + 8, + -1 + ], + [ + "Bf3", + 7, + 9, + 1 + ], + [ + "Bf4", + 9, + 8, + 1 + ], + [ + "Bf3", + 7, + 9, + -1 + ], + [ + "Bf4", + 9, + 8, + -1 + ], + [ + "Bf5", + 8, + 9, + 1 + ], + [ + "Bf6", + 9, + 6, + 1 + ], + [ + "Bf5", + 8, + 9, + -1 + ], + [ + "Bf6", + 9, + 6, + -1 + ], + [ + "Bf4", + 9, + 8, + 1 + ], + [ + "Bf3", + 7, + 9, + 1 + ], + [ + "Bf4", + 9, + 8, + -1 + ], + [ + "Bf3", + 7, + 9, + -1 + ], + [ + "Bf6", + 9, + 6, + 1 + ], + [ + "Bf5", + 8, + 9, + 1 + ], + [ + "Bf6", + 9, + 6, + -1 + ], + [ + "Bf5", + 8, + 9, + -1 + ], + [ + "Bf0", + 0, + 8, + 1 + ], + [ + "Bf1", + 8, + 9, + 1 + ], + [ + "Bf2", + 9, + 7, + 1 + ], + [ + "Bf1", + 8, + 9, + -1 + ], + [ + "Bf2", + 9, + 7, + -1 + ], + [ + "Bf0", + 0, + 8, + -1 + ], + [ + "Bf2", + 9, + 7, + 1 + ], + [ + "Bf1", + 8, + 9, + 1 + ], + [ + "Bf2", + 9, + 7, + -1 + ], + [ + "Bf1", + 8, + 9, + -1 + ], + [ + "Bf5", + 8, + 9, + 1 + ], + [ + "Bf6", + 9, + 6, + 1 + ], + [ + "Bf5", + 8, + 9, + -1 + ], + [ + "Bf6", + 9, + 6, + -1 + ], + [ + "Bf3", + 7, + 9, + 1 + ], + [ + "Bf4", + 9, + 8, + 1 + ], + [ + "Bf3", + 7, + 9, + -1 + ], + [ + "Bf4", + 9, + 8, + -1 + ], + [ + "Bf6", + 9, + 6, + 1 + ], + [ + "Bf5", + 8, + 9, + 1 + ], + [ + "Bf6", + 9, + 6, + -1 + ], + [ + "Bf5", + 8, + 9, + -1 + ], + [ + "Bf4", + 9, + 8, + 1 + ], + [ + "Bf3", + 7, + 9, + 1 + ], + [ + "Bf4", + 9, + 8, + -1 + ], + [ + "Bf3", + 7, + 9, + -1 + ], + [ + "Bf1", + 8, + 9, + 1 + ], + [ + "Bf2", + 9, + 7, + 1 + ], + [ + "Bf1", + 8, + 9, + -1 + ], + [ + "Bf2", + 9, + 7, + -1 + ], + [ + "Bf0", + 0, + 8, + 1 + ], + [ + "Bf2", + 9, + 7, + 1 + ], + [ + "Bf1", + 8, + 9, + 1 + ], + [ + "Bf2", + 9, + 7, + -1 + ], + [ + "Bf1", + 8, + 9, + -1 + ], + [ + "Bf0", + 0, + 8, + -1 + ], + [ + "A2f2", + 7, + 8, + 1 + ], + [ + "A2f3", + 8, + 3, + 1 + ], + [ + "A2f2", + 7, + 8, + -1 + ], + [ + "A2f3", + 8, + 3, + -1 + ], + [ + "A2f0", + 6, + 8, + 1 + ], + [ + "A2f1", + 8, + 7, + 1 + ], + [ + "A2f0", + 6, + 8, + -1 + ], + [ + "A2f1", + 8, + 7, + -1 + ], + [ + "A2f3", + 8, + 3, + 1 + ], + [ + "A2f2", + 7, + 8, + 1 + ], + [ + "A2f3", + 8, + 3, + -1 + ], + [ + "A2f2", + 7, + 8, + -1 + ], + [ + "A2f1", + 8, + 7, + 1 + ], + [ + "A2f0", + 6, + 8, + 1 + ], + [ + "A2f1", + 8, + 7, + -1 + ], + [ + "A2f0", + 6, + 8, + -1 + ], + [ + "Bf0", + 0, + 8, + 1 + ], + [ + "Bf1", + 8, + 9, + 1 + ], + [ + "Bf2", + 9, + 7, + 1 + ], + [ + "Bf1", + 8, + 9, + -1 + ], + [ + "Bf2", + 9, + 7, + -1 + ], + [ + "Bf0", + 0, + 8, + -1 + ], + [ + "Bf2", + 9, + 7, + 1 + ], + [ + "Bf1", + 8, + 9, + 1 + ], + [ + "Bf2", + 9, + 7, + -1 + ], + [ + "Bf1", + 8, + 9, + -1 + ], + [ + "Bf3", + 7, + 9, + 1 + ], + [ + "Bf4", + 9, + 8, + 1 + ], + [ + "Bf3", + 7, + 9, + -1 + ], + [ + "Bf4", + 9, + 8, + -1 + ], + [ + "Bf5", + 8, + 9, + 1 + ], + [ + "Bf6", + 9, + 6, + 1 + ], + [ + "Bf5", + 8, + 9, + -1 + ], + [ + "Bf6", + 9, + 6, + -1 + ], + [ + "Bf4", + 9, + 8, + 1 + ], + [ + "Bf3", + 7, + 9, + 1 + ], + [ + "Bf4", + 9, + 8, + -1 + ], + [ + "Bf3", + 7, + 9, + -1 + ], + [ + "Bf6", + 9, + 6, + 1 + ], + [ + "Bf5", + 8, + 9, + 1 + ], + [ + "Bf6", + 9, + 6, + -1 + ], + [ + "Bf5", + 8, + 9, + -1 + ], + [ + "Bf1", + 8, + 9, + 1 + ], + [ + "Bf2", + 9, + 7, + 1 + ], + [ + "Bf1", + 8, + 9, + -1 + ], + [ + "Bf2", + 9, + 7, + -1 + ], + [ + "Bf0", + 0, + 8, + 1 + ], + [ + "Bf2", + 9, + 7, + 1 + ], + [ + "Bf1", + 8, + 9, + 1 + ], + [ + "Bf2", + 9, + 7, + -1 + ], + [ + "Bf1", + 8, + 9, + -1 + ], + [ + "Bf0", + 0, + 8, + -1 + ], + [ + "Bf5", + 8, + 9, + 1 + ], + [ + "Bf6", + 9, + 6, + 1 + ], + [ + "Bf5", + 8, + 9, + -1 + ], + [ + "Bf6", + 9, + 6, + -1 + ], + [ + "Bf3", + 7, + 9, + 1 + ], + [ + "Bf4", + 9, + 8, + 1 + ], + [ + "Bf3", + 7, + 9, + -1 + ], + [ + "Bf4", + 9, + 8, + -1 + ], + [ + "Bf6", + 9, + 6, + 1 + ], + [ + "Bf5", + 8, + 9, + 1 + ], + [ + "Bf6", + 9, + 6, + -1 + ], + [ + "Bf5", + 8, + 9, + -1 + ], + [ + "Bf4", + 9, + 8, + 1 + ], + [ + "Bf3", + 7, + 9, + 1 + ], + [ + "Bf4", + 9, + 8, + -1 + ], + [ + "Bf3", + 7, + 9, + -1 + ], + [ + "A2f0", + 6, + 8, + 1 + ], + [ + "A2f1", + 8, + 7, + 1 + ], + [ + "A2f0", + 6, + 8, + -1 + ], + [ + "A2f1", + 8, + 7, + -1 + ], + [ + "A2f2", + 7, + 8, + 1 + ], + [ + "A2f3", + 8, + 3, + 1 + ], + [ + "A2f2", + 7, + 8, + -1 + ], + [ + "A2f3", + 8, + 3, + -1 + ], + [ + "A2f1", + 8, + 7, + 1 + ], + [ + "A2f0", + 6, + 8, + 1 + ], + [ + "A2f1", + 8, + 7, + -1 + ], + [ + "A2f0", + 6, + 8, + -1 + ], + [ + "A2f3", + 8, + 3, + 1 + ], + [ + "A2f2", + 7, + 8, + 1 + ], + [ + "A2f3", + 8, + 3, + -1 + ], + [ + "A2f2", + 7, + 8, + -1 + ], + [ + "Bf3", + 7, + 9, + 1 + ], + [ + "Bf4", + 9, + 8, + 1 + ], + [ + "Bf3", + 7, + 9, + -1 + ], + [ + "Bf4", + 9, + 8, + -1 + ], + [ + "Bf5", + 8, + 9, + 1 + ], + [ + "Bf6", + 9, + 6, + 1 + ], + [ + "Bf5", + 8, + 9, + -1 + ], + [ + "Bf6", + 9, + 6, + -1 + ], + [ + "Bf4", + 9, + 8, + 1 + ], + [ + "Bf3", + 7, + 9, + 1 + ], + [ + "Bf4", + 9, + 8, + -1 + ], + [ + "Bf3", + 7, + 9, + -1 + ], + [ + "Bf6", + 9, + 6, + 1 + ], + [ + "Bf5", + 8, + 9, + 1 + ], + [ + "Bf6", + 9, + 6, + -1 + ], + [ + "Bf5", + 8, + 9, + -1 + ], + [ + "Bf0", + 0, + 8, + 1 + ], + [ + "Bf1", + 8, + 9, + 1 + ], + [ + "Bf2", + 9, + 7, + 1 + ], + [ + "Bf1", + 8, + 9, + -1 + ], + [ + "Bf2", + 9, + 7, + -1 + ], + [ + "Bf0", + 0, + 8, + -1 + ], + [ + "Bf2", + 9, + 7, + 1 + ], + [ + "Bf1", + 8, + 9, + 1 + ], + [ + "Bf2", + 9, + 7, + -1 + ], + [ + "Bf1", + 8, + 9, + -1 + ], + [ + "Bf5", + 8, + 9, + 1 + ], + [ + "Bf6", + 9, + 6, + 1 + ], + [ + "Bf5", + 8, + 9, + -1 + ], + [ + "Bf6", + 9, + 6, + -1 + ], + [ + "Bf3", + 7, + 9, + 1 + ], + [ + "Bf4", + 9, + 8, + 1 + ], + [ + "Bf3", + 7, + 9, + -1 + ], + [ + "Bf4", + 9, + 8, + -1 + ], + [ + "Bf6", + 9, + 6, + 1 + ], + [ + "Bf5", + 8, + 9, + 1 + ], + [ + "Bf6", + 9, + 6, + -1 + ], + [ + "Bf5", + 8, + 9, + -1 + ], + [ + "Bf4", + 9, + 8, + 1 + ], + [ + "Bf3", + 7, + 9, + 1 + ], + [ + "Bf4", + 9, + 8, + -1 + ], + [ + "Bf3", + 7, + 9, + -1 + ], + [ + "Bf1", + 8, + 9, + 1 + ], + [ + "Bf2", + 9, + 7, + 1 + ], + [ + "Bf1", + 8, + 9, + -1 + ], + [ + "Bf2", + 9, + 7, + -1 + ], + [ + "Bf0", + 0, + 8, + 1 + ], + [ + "Bf2", + 9, + 7, + 1 + ], + [ + "Bf1", + 8, + 9, + 1 + ], + [ + "Bf2", + 9, + 7, + -1 + ], + [ + "Bf1", + 8, + 9, + -1 + ], + [ + "Bf0", + 0, + 8, + -1 + ], + [ + "A3f2", + 7, + 8, + 1 + ], + [ + "A3f3", + 8, + 9, + 1 + ], + [ + "A3f4", + 9, + 4, + 1 + ], + [ + "A3f3", + 8, + 9, + -1 + ], + [ + "A3f4", + 9, + 4, + -1 + ], + [ + "A3f2", + 7, + 8, + -1 + ], + [ + "A3f4", + 9, + 4, + 1 + ], + [ + "A3f3", + 8, + 9, + 1 + ], + [ + "A3f4", + 9, + 4, + -1 + ], + [ + "A3f3", + 8, + 9, + -1 + ], + [ + "A3f0", + 6, + 8, + 1 + ], + [ + "A3f1", + 8, + 7, + 1 + ], + [ + "A3f0", + 6, + 8, + -1 + ], + [ + "A3f1", + 8, + 7, + -1 + ], + [ + "A3f3", + 8, + 9, + 1 + ], + [ + "A3f4", + 9, + 4, + 1 + ], + [ + "A3f3", + 8, + 9, + -1 + ], + [ + "A3f4", + 9, + 4, + -1 + ], + [ + "A3f2", + 7, + 8, + 1 + ], + [ + "A3f4", + 9, + 4, + 1 + ], + [ + "A3f3", + 8, + 9, + 1 + ], + [ + "A3f4", + 9, + 4, + -1 + ], + [ + "A3f3", + 8, + 9, + -1 + ], + [ + "A3f2", + 7, + 8, + -1 + ], + [ + "A3f1", + 8, + 7, + 1 + ], + [ + "A3f0", + 6, + 8, + 1 + ], + [ + "A3f1", + 8, + 7, + -1 + ], + [ + "A3f0", + 6, + 8, + -1 + ], + [ + "Bf0", + 0, + 8, + 1 + ], + [ + "Bf1", + 8, + 9, + 1 + ], + [ + "Bf2", + 9, + 7, + 1 + ], + [ + "Bf1", + 8, + 9, + -1 + ], + [ + "Bf2", + 9, + 7, + -1 + ], + [ + "Bf0", + 0, + 8, + -1 + ], + [ + "Bf2", + 9, + 7, + 1 + ], + [ + "Bf1", + 8, + 9, + 1 + ], + [ + "Bf2", + 9, + 7, + -1 + ], + [ + "Bf1", + 8, + 9, + -1 + ], + [ + "Bf3", + 7, + 9, + 1 + ], + [ + "Bf4", + 9, + 8, + 1 + ], + [ + "Bf3", + 7, + 9, + -1 + ], + [ + "Bf4", + 9, + 8, + -1 + ], + [ + "Bf5", + 8, + 9, + 1 + ], + [ + "Bf6", + 9, + 6, + 1 + ], + [ + "Bf5", + 8, + 9, + -1 + ], + [ + "Bf6", + 9, + 6, + -1 + ], + [ + "Bf4", + 9, + 8, + 1 + ], + [ + "Bf3", + 7, + 9, + 1 + ], + [ + "Bf4", + 9, + 8, + -1 + ], + [ + "Bf3", + 7, + 9, + -1 + ], + [ + "Bf6", + 9, + 6, + 1 + ], + [ + "Bf5", + 8, + 9, + 1 + ], + [ + "Bf6", + 9, + 6, + -1 + ], + [ + "Bf5", + 8, + 9, + -1 + ], + [ + "Bf1", + 8, + 9, + 1 + ], + [ + "Bf2", + 9, + 7, + 1 + ], + [ + "Bf1", + 8, + 9, + -1 + ], + [ + "Bf2", + 9, + 7, + -1 + ], + [ + "Bf0", + 0, + 8, + 1 + ], + [ + "Bf2", + 9, + 7, + 1 + ], + [ + "Bf1", + 8, + 9, + 1 + ], + [ + "Bf2", + 9, + 7, + -1 + ], + [ + "Bf1", + 8, + 9, + -1 + ], + [ + "Bf0", + 0, + 8, + -1 + ], + [ + "Bf5", + 8, + 9, + 1 + ], + [ + "Bf6", + 9, + 6, + 1 + ], + [ + "Bf5", + 8, + 9, + -1 + ], + [ + "Bf6", + 9, + 6, + -1 + ], + [ + "Bf3", + 7, + 9, + 1 + ], + [ + "Bf4", + 9, + 8, + 1 + ], + [ + "Bf3", + 7, + 9, + -1 + ], + [ + "Bf4", + 9, + 8, + -1 + ], + [ + "Bf6", + 9, + 6, + 1 + ], + [ + "Bf5", + 8, + 9, + 1 + ], + [ + "Bf6", + 9, + 6, + -1 + ], + [ + "Bf5", + 8, + 9, + -1 + ], + [ + "Bf4", + 9, + 8, + 1 + ], + [ + "Bf3", + 7, + 9, + 1 + ], + [ + "Bf4", + 9, + 8, + -1 + ], + [ + "Bf3", + 7, + 9, + -1 + ], + [ + "A3f0", + 6, + 8, + 1 + ], + [ + "A3f1", + 8, + 7, + 1 + ], + [ + "A3f0", + 6, + 8, + -1 + ], + [ + "A3f1", + 8, + 7, + -1 + ], + [ + "A3f2", + 7, + 8, + 1 + ], + [ + "A3f3", + 8, + 9, + 1 + ], + [ + "A3f4", + 9, + 4, + 1 + ], + [ + "A3f3", + 8, + 9, + -1 + ], + [ + "A3f4", + 9, + 4, + -1 + ], + [ + "A3f2", + 7, + 8, + -1 + ], + [ + "A3f4", + 9, + 4, + 1 + ], + [ + "A3f3", + 8, + 9, + 1 + ], + [ + "A3f4", + 9, + 4, + -1 + ], + [ + "A3f3", + 8, + 9, + -1 + ], + [ + "A3f1", + 8, + 7, + 1 + ], + [ + "A3f0", + 6, + 8, + 1 + ], + [ + "A3f1", + 8, + 7, + -1 + ], + [ + "A3f0", + 6, + 8, + -1 + ], + [ + "A3f3", + 8, + 9, + 1 + ], + [ + "A3f4", + 9, + 4, + 1 + ], + [ + "A3f3", + 8, + 9, + -1 + ], + [ + "A3f4", + 9, + 4, + -1 + ], + [ + "A3f2", + 7, + 8, + 1 + ], + [ + "A3f4", + 9, + 4, + 1 + ], + [ + "A3f3", + 8, + 9, + 1 + ], + [ + "A3f4", + 9, + 4, + -1 + ], + [ + "A3f3", + 8, + 9, + -1 + ], + [ + "A3f2", + 7, + 8, + -1 + ], + [ + "Bf3", + 7, + 9, + 1 + ], + [ + "Bf4", + 9, + 8, + 1 + ], + [ + "Bf3", + 7, + 9, + -1 + ], + [ + "Bf4", + 9, + 8, + -1 + ], + [ + "Bf5", + 8, + 9, + 1 + ], + [ + "Bf6", + 9, + 6, + 1 + ], + [ + "Bf5", + 8, + 9, + -1 + ], + [ + "Bf6", + 9, + 6, + -1 + ], + [ + "Bf4", + 9, + 8, + 1 + ], + [ + "Bf3", + 7, + 9, + 1 + ], + [ + "Bf4", + 9, + 8, + -1 + ], + [ + "Bf3", + 7, + 9, + -1 + ], + [ + "Bf6", + 9, + 6, + 1 + ], + [ + "Bf5", + 8, + 9, + 1 + ], + [ + "Bf6", + 9, + 6, + -1 + ], + [ + "Bf5", + 8, + 9, + -1 + ], + [ + "Bf0", + 0, + 8, + 1 + ], + [ + "Bf1", + 8, + 9, + 1 + ], + [ + "Bf2", + 9, + 7, + 1 + ], + [ + "Bf1", + 8, + 9, + -1 + ], + [ + "Bf2", + 9, + 7, + -1 + ], + [ + "Bf0", + 0, + 8, + -1 + ], + [ + "Bf2", + 9, + 7, + 1 + ], + [ + "Bf1", + 8, + 9, + 1 + ], + [ + "Bf2", + 9, + 7, + -1 + ], + [ + "Bf1", + 8, + 9, + -1 + ], + [ + "Bf5", + 8, + 9, + 1 + ], + [ + "Bf6", + 9, + 6, + 1 + ], + [ + "Bf5", + 8, + 9, + -1 + ], + [ + "Bf6", + 9, + 6, + -1 + ], + [ + "Bf3", + 7, + 9, + 1 + ], + [ + "Bf4", + 9, + 8, + 1 + ], + [ + "Bf3", + 7, + 9, + -1 + ], + [ + "Bf4", + 9, + 8, + -1 + ], + [ + "Bf6", + 9, + 6, + 1 + ], + [ + "Bf5", + 8, + 9, + 1 + ], + [ + "Bf6", + 9, + 6, + -1 + ], + [ + "Bf5", + 8, + 9, + -1 + ], + [ + "Bf4", + 9, + 8, + 1 + ], + [ + "Bf3", + 7, + 9, + 1 + ], + [ + "Bf4", + 9, + 8, + -1 + ], + [ + "Bf3", + 7, + 9, + -1 + ], + [ + "Bf1", + 8, + 9, + 1 + ], + [ + "Bf2", + 9, + 7, + 1 + ], + [ + "Bf1", + 8, + 9, + -1 + ], + [ + "Bf2", + 9, + 7, + -1 + ], + [ + "Bf0", + 0, + 8, + 1 + ], + [ + "Bf2", + 9, + 7, + 1 + ], + [ + "Bf1", + 8, + 9, + 1 + ], + [ + "Bf2", + 9, + 7, + -1 + ], + [ + "Bf1", + 8, + 9, + -1 + ], + [ + "Bf0", + 0, + 8, + -1 + ], + [ + "A4f3", + 7, + 8, + 1 + ], + [ + "A4f4", + 8, + 9, + 1 + ], + [ + "A4f5", + 9, + 5, + 1 + ], + [ + "A4f4", + 8, + 9, + -1 + ], + [ + "A4f5", + 9, + 5, + -1 + ], + [ + "A4f3", + 7, + 8, + -1 + ], + [ + "A4f5", + 9, + 5, + 1 + ], + [ + "A4f4", + 8, + 9, + 1 + ], + [ + "A4f5", + 9, + 5, + -1 + ], + [ + "A4f4", + 8, + 9, + -1 + ], + [ + "A4f0", + 6, + 8, + 1 + ], + [ + "A4f1", + 8, + 9, + 1 + ], + [ + "A4f2", + 9, + 7, + 1 + ], + [ + "A4f1", + 8, + 9, + -1 + ], + [ + "A4f2", + 9, + 7, + -1 + ], + [ + "A4f0", + 6, + 8, + -1 + ], + [ + "A4f2", + 9, + 7, + 1 + ], + [ + "A4f1", + 8, + 9, + 1 + ], + [ + "A4f2", + 9, + 7, + -1 + ], + [ + "A4f1", + 8, + 9, + -1 + ], + [ + "A4f4", + 8, + 9, + 1 + ], + [ + "A4f5", + 9, + 5, + 1 + ], + [ + "A4f4", + 8, + 9, + -1 + ], + [ + "A4f5", + 9, + 5, + -1 + ], + [ + "A4f3", + 7, + 8, + 1 + ], + [ + "A4f5", + 9, + 5, + 1 + ], + [ + "A4f4", + 8, + 9, + 1 + ], + [ + "A4f5", + 9, + 5, + -1 + ], + [ + "A4f4", + 8, + 9, + -1 + ], + [ + "A4f3", + 7, + 8, + -1 + ], + [ + "A4f1", + 8, + 9, + 1 + ], + [ + "A4f2", + 9, + 7, + 1 + ], + [ + "A4f1", + 8, + 9, + -1 + ], + [ + "A4f2", + 9, + 7, + -1 + ], + [ + "A4f0", + 6, + 8, + 1 + ], + [ + "A4f2", + 9, + 7, + 1 + ], + [ + "A4f1", + 8, + 9, + 1 + ], + [ + "A4f2", + 9, + 7, + -1 + ], + [ + "A4f1", + 8, + 9, + -1 + ], + [ + "A4f0", + 6, + 8, + -1 + ], + [ + "Bf0", + 0, + 8, + 1 + ], + [ + "Bf1", + 8, + 9, + 1 + ], + [ + "Bf2", + 9, + 7, + 1 + ], + [ + "Bf1", + 8, + 9, + -1 + ], + [ + "Bf2", + 9, + 7, + -1 + ], + [ + "Bf0", + 0, + 8, + -1 + ], + [ + "Bf2", + 9, + 7, + 1 + ], + [ + "Bf1", + 8, + 9, + 1 + ], + [ + "Bf2", + 9, + 7, + -1 + ], + [ + "Bf1", + 8, + 9, + -1 + ], + [ + "Bf3", + 7, + 9, + 1 + ], + [ + "Bf4", + 9, + 8, + 1 + ], + [ + "Bf3", + 7, + 9, + -1 + ], + [ + "Bf4", + 9, + 8, + -1 + ], + [ + "Bf5", + 8, + 9, + 1 + ], + [ + "Bf6", + 9, + 6, + 1 + ], + [ + "Bf5", + 8, + 9, + -1 + ], + [ + "Bf6", + 9, + 6, + -1 + ], + [ + "Bf4", + 9, + 8, + 1 + ], + [ + "Bf3", + 7, + 9, + 1 + ], + [ + "Bf4", + 9, + 8, + -1 + ], + [ + "Bf3", + 7, + 9, + -1 + ], + [ + "Bf6", + 9, + 6, + 1 + ], + [ + "Bf5", + 8, + 9, + 1 + ], + [ + "Bf6", + 9, + 6, + -1 + ], + [ + "Bf5", + 8, + 9, + -1 + ], + [ + "Bf1", + 8, + 9, + 1 + ], + [ + "Bf2", + 9, + 7, + 1 + ], + [ + "Bf1", + 8, + 9, + -1 + ], + [ + "Bf2", + 9, + 7, + -1 + ], + [ + "Bf0", + 0, + 8, + 1 + ], + [ + "Bf2", + 9, + 7, + 1 + ], + [ + "Bf1", + 8, + 9, + 1 + ], + [ + "Bf2", + 9, + 7, + -1 + ], + [ + "Bf1", + 8, + 9, + -1 + ], + [ + "Bf0", + 0, + 8, + -1 + ], + [ + "Bf5", + 8, + 9, + 1 + ], + [ + "Bf6", + 9, + 6, + 1 + ], + [ + "Bf5", + 8, + 9, + -1 + ], + [ + "Bf6", + 9, + 6, + -1 + ], + [ + "Bf3", + 7, + 9, + 1 + ], + [ + "Bf4", + 9, + 8, + 1 + ], + [ + "Bf3", + 7, + 9, + -1 + ], + [ + "Bf4", + 9, + 8, + -1 + ], + [ + "Bf6", + 9, + 6, + 1 + ], + [ + "Bf5", + 8, + 9, + 1 + ], + [ + "Bf6", + 9, + 6, + -1 + ], + [ + "Bf5", + 8, + 9, + -1 + ], + [ + "Bf4", + 9, + 8, + 1 + ], + [ + "Bf3", + 7, + 9, + 1 + ], + [ + "Bf4", + 9, + 8, + -1 + ], + [ + "Bf3", + 7, + 9, + -1 + ], + [ + "A4f0", + 6, + 8, + 1 + ], + [ + "A4f1", + 8, + 9, + 1 + ], + [ + "A4f2", + 9, + 7, + 1 + ], + [ + "A4f1", + 8, + 9, + -1 + ], + [ + "A4f2", + 9, + 7, + -1 + ], + [ + "A4f0", + 6, + 8, + -1 + ], + [ + "A4f2", + 9, + 7, + 1 + ], + [ + "A4f1", + 8, + 9, + 1 + ], + [ + "A4f2", + 9, + 7, + -1 + ], + [ + "A4f1", + 8, + 9, + -1 + ], + [ + "A4f3", + 7, + 8, + 1 + ], + [ + "A4f4", + 8, + 9, + 1 + ], + [ + "A4f5", + 9, + 5, + 1 + ], + [ + "A4f4", + 8, + 9, + -1 + ], + [ + "A4f5", + 9, + 5, + -1 + ], + [ + "A4f3", + 7, + 8, + -1 + ], + [ + "A4f5", + 9, + 5, + 1 + ], + [ + "A4f4", + 8, + 9, + 1 + ], + [ + "A4f5", + 9, + 5, + -1 + ], + [ + "A4f4", + 8, + 9, + -1 + ], + [ + "A4f1", + 8, + 9, + 1 + ], + [ + "A4f2", + 9, + 7, + 1 + ], + [ + "A4f1", + 8, + 9, + -1 + ], + [ + "A4f2", + 9, + 7, + -1 + ], + [ + "A4f0", + 6, + 8, + 1 + ], + [ + "A4f2", + 9, + 7, + 1 + ], + [ + "A4f1", + 8, + 9, + 1 + ], + [ + "A4f2", + 9, + 7, + -1 + ], + [ + "A4f1", + 8, + 9, + -1 + ], + [ + "A4f0", + 6, + 8, + -1 + ], + [ + "A4f4", + 8, + 9, + 1 + ], + [ + "A4f5", + 9, + 5, + 1 + ], + [ + "A4f4", + 8, + 9, + -1 + ], + [ + "A4f5", + 9, + 5, + -1 + ], + [ + "A4f3", + 7, + 8, + 1 + ], + [ + "A4f5", + 9, + 5, + 1 + ], + [ + "A4f4", + 8, + 9, + 1 + ], + [ + "A4f5", + 9, + 5, + -1 + ], + [ + "A4f4", + 8, + 9, + -1 + ], + [ + "A4f3", + 7, + 8, + -1 + ], + [ + "Bf3", + 7, + 9, + 1 + ], + [ + "Bf4", + 9, + 8, + 1 + ], + [ + "Bf3", + 7, + 9, + -1 + ], + [ + "Bf4", + 9, + 8, + -1 + ], + [ + "Bf5", + 8, + 9, + 1 + ], + [ + "Bf6", + 9, + 6, + 1 + ], + [ + "Bf5", + 8, + 9, + -1 + ], + [ + "Bf6", + 9, + 6, + -1 + ], + [ + "Bf4", + 9, + 8, + 1 + ], + [ + "Bf3", + 7, + 9, + 1 + ], + [ + "Bf4", + 9, + 8, + -1 + ], + [ + "Bf3", + 7, + 9, + -1 + ], + [ + "Bf6", + 9, + 6, + 1 + ], + [ + "Bf5", + 8, + 9, + 1 + ], + [ + "Bf6", + 9, + 6, + -1 + ], + [ + "Bf5", + 8, + 9, + -1 + ], + [ + "Bf0", + 0, + 8, + 1 + ], + [ + "Bf1", + 8, + 9, + 1 + ], + [ + "Bf2", + 9, + 7, + 1 + ], + [ + "Bf1", + 8, + 9, + -1 + ], + [ + "Bf2", + 9, + 7, + -1 + ], + [ + "Bf0", + 0, + 8, + -1 + ], + [ + "Bf2", + 9, + 7, + 1 + ], + [ + "Bf1", + 8, + 9, + 1 + ], + [ + "Bf2", + 9, + 7, + -1 + ], + [ + "Bf1", + 8, + 9, + -1 + ], + [ + "Bf5", + 8, + 9, + 1 + ], + [ + "Bf6", + 9, + 6, + 1 + ], + [ + "Bf5", + 8, + 9, + -1 + ], + [ + "Bf6", + 9, + 6, + -1 + ], + [ + "Bf3", + 7, + 9, + 1 + ], + [ + "Bf4", + 9, + 8, + 1 + ], + [ + "Bf3", + 7, + 9, + -1 + ], + [ + "Bf4", + 9, + 8, + -1 + ], + [ + "Bf6", + 9, + 6, + 1 + ], + [ + "Bf5", + 8, + 9, + 1 + ], + [ + "Bf6", + 9, + 6, + -1 + ], + [ + "Bf5", + 8, + 9, + -1 + ], + [ + "Bf4", + 9, + 8, + 1 + ], + [ + "Bf3", + 7, + 9, + 1 + ], + [ + "Bf4", + 9, + 8, + -1 + ], + [ + "Bf3", + 7, + 9, + -1 + ], + [ + "Bf1", + 8, + 9, + 1 + ], + [ + "Bf2", + 9, + 7, + 1 + ], + [ + "Bf1", + 8, + 9, + -1 + ], + [ + "Bf2", + 9, + 7, + -1 + ], + [ + "Bf0", + 0, + 8, + 1 + ], + [ + "Bf2", + 9, + 7, + 1 + ], + [ + "Bf1", + 8, + 9, + 1 + ], + [ + "Bf2", + 9, + 7, + -1 + ], + [ + "Bf1", + 8, + 9, + -1 + ], + [ + "Bf0", + 0, + 8, + -1 + ] + ], + "word": [ + [ + "A0", + -1 + ], + [ + "B", + 1 + ], + [ + "A0", + 1 + ], + [ + "B", + -1 + ], + [ + "A1", + -1 + ], + [ + "B", + 1 + ], + [ + "A1", + 1 + ], + [ + "B", + -1 + ], + [ + "A2", + -1 + ], + [ + "B", + 1 + ], + [ + "A2", + 1 + ], + [ + "B", + -1 + ], + [ + "A3", + -1 + ], + [ + "B", + 1 + ], + [ + "A3", + 1 + ], + [ + "B", + -1 + ], + [ + "A4", + -1 + ], + [ + "B", + 1 + ], + [ + "A4", + 1 + ], + [ + "B", + -1 + ] + ] + }, + "unrestricted": { + "commit_after": [ + 4, + 5, + 6, + 10, + 11 + ], + "dirty_rows": 4, + "leaf_commit_after": [ + 85, + 95, + 111, + 259, + 299 + ], + "leaves": [ + [ + "A0f1", + 7, + 1, + 1 + ], + [ + "A0f0", + 6, + 7, + 1 + ], + [ + "A0f1", + 7, + 1, + -1 + ], + [ + "A0f0", + 6, + 7, + -1 + ], + [ + "A1f1", + 7, + 8, + 1 + ], + [ + "A1f2", + 8, + 2, + 1 + ], + [ + "A1f1", + 7, + 8, + -1 + ], + [ + "A1f2", + 8, + 2, + -1 + ], + [ + "A1f0", + 6, + 7, + 1 + ], + [ + "A1f2", + 8, + 2, + 1 + ], + [ + "A1f1", + 7, + 8, + 1 + ], + [ + "A1f2", + 8, + 2, + -1 + ], + [ + "A1f1", + 7, + 8, + -1 + ], + [ + "A1f0", + 6, + 7, + -1 + ], + [ + "A2f2", + 7, + 8, + 1 + ], + [ + "A2f3", + 8, + 3, + 1 + ], + [ + "A2f2", + 7, + 8, + -1 + ], + [ + "A2f3", + 8, + 3, + -1 + ], + [ + "A2f0", + 6, + 8, + 1 + ], + [ + "A2f1", + 8, + 7, + 1 + ], + [ + "A2f0", + 6, + 8, + -1 + ], + [ + "A2f1", + 8, + 7, + -1 + ], + [ + "A2f3", + 8, + 3, + 1 + ], + [ + "A2f2", + 7, + 8, + 1 + ], + [ + "A2f3", + 8, + 3, + -1 + ], + [ + "A2f2", + 7, + 8, + -1 + ], + [ + "A2f1", + 8, + 7, + 1 + ], + [ + "A2f0", + 6, + 8, + 1 + ], + [ + "A2f1", + 8, + 7, + -1 + ], + [ + "A2f0", + 6, + 8, + -1 + ], + [ + "Bf0", + 0, + 8, + 1 + ], + [ + "Bf1", + 8, + 9, + 1 + ], + [ + "Bf2", + 9, + 7, + 1 + ], + [ + "Bf1", + 8, + 9, + -1 + ], + [ + "Bf2", + 9, + 7, + -1 + ], + [ + "Bf0", + 0, + 8, + -1 + ], + [ + "Bf2", + 9, + 7, + 1 + ], + [ + "Bf1", + 8, + 9, + 1 + ], + [ + "Bf2", + 9, + 7, + -1 + ], + [ + "Bf1", + 8, + 9, + -1 + ], + [ + "Bf3", + 7, + 9, + 1 + ], + [ + "Bf4", + 9, + 8, + 1 + ], + [ + "Bf3", + 7, + 9, + -1 + ], + [ + "Bf4", + 9, + 8, + -1 + ], + [ + "Bf5", + 8, + 9, + 1 + ], + [ + "Bf6", + 9, + 6, + 1 + ], + [ + "Bf5", + 8, + 9, + -1 + ], + [ + "Bf6", + 9, + 6, + -1 + ], + [ + "Bf4", + 9, + 8, + 1 + ], + [ + "Bf3", + 7, + 9, + 1 + ], + [ + "Bf4", + 9, + 8, + -1 + ], + [ + "Bf3", + 7, + 9, + -1 + ], + [ + "Bf6", + 9, + 6, + 1 + ], + [ + "Bf5", + 8, + 9, + 1 + ], + [ + "Bf6", + 9, + 6, + -1 + ], + [ + "Bf5", + 8, + 9, + -1 + ], + [ + "Bf1", + 8, + 9, + 1 + ], + [ + "Bf2", + 9, + 7, + 1 + ], + [ + "Bf1", + 8, + 9, + -1 + ], + [ + "Bf2", + 9, + 7, + -1 + ], + [ + "Bf0", + 0, + 8, + 1 + ], + [ + "Bf2", + 9, + 7, + 1 + ], + [ + "Bf1", + 8, + 9, + 1 + ], + [ + "Bf2", + 9, + 7, + -1 + ], + [ + "Bf1", + 8, + 9, + -1 + ], + [ + "Bf0", + 0, + 8, + -1 + ], + [ + "Bf5", + 8, + 9, + 1 + ], + [ + "Bf6", + 9, + 6, + 1 + ], + [ + "Bf5", + 8, + 9, + -1 + ], + [ + "Bf6", + 9, + 6, + -1 + ], + [ + "Bf3", + 7, + 9, + 1 + ], + [ + "Bf4", + 9, + 8, + 1 + ], + [ + "Bf3", + 7, + 9, + -1 + ], + [ + "Bf4", + 9, + 8, + -1 + ], + [ + "Bf6", + 9, + 6, + 1 + ], + [ + "Bf5", + 8, + 9, + 1 + ], + [ + "Bf6", + 9, + 6, + -1 + ], + [ + "Bf5", + 8, + 9, + -1 + ], + [ + "Bf4", + 9, + 8, + 1 + ], + [ + "Bf3", + 7, + 9, + 1 + ], + [ + "Bf4", + 9, + 8, + -1 + ], + [ + "Bf3", + 7, + 9, + -1 + ], + [ + "A0f0", + 6, + 7, + 1 + ], + [ + "A0f1", + 7, + 1, + 1 + ], + [ + "A0f0", + 6, + 7, + -1 + ], + [ + "A0f1", + 7, + 1, + -1 + ], + [ + "A1f0", + 6, + 7, + 1 + ], + [ + "A1f1", + 7, + 8, + 1 + ], + [ + "A1f2", + 8, + 2, + 1 + ], + [ + "A1f1", + 7, + 8, + -1 + ], + [ + "A1f2", + 8, + 2, + -1 + ], + [ + "A1f0", + 6, + 7, + -1 + ], + [ + "A1f2", + 8, + 2, + 1 + ], + [ + "A1f1", + 7, + 8, + 1 + ], + [ + "A1f2", + 8, + 2, + -1 + ], + [ + "A1f1", + 7, + 8, + -1 + ], + [ + "A2f0", + 6, + 8, + 1 + ], + [ + "A2f1", + 8, + 7, + 1 + ], + [ + "A2f0", + 6, + 8, + -1 + ], + [ + "A2f1", + 8, + 7, + -1 + ], + [ + "A2f2", + 7, + 8, + 1 + ], + [ + "A2f3", + 8, + 3, + 1 + ], + [ + "A2f2", + 7, + 8, + -1 + ], + [ + "A2f3", + 8, + 3, + -1 + ], + [ + "A2f1", + 8, + 7, + 1 + ], + [ + "A2f0", + 6, + 8, + 1 + ], + [ + "A2f1", + 8, + 7, + -1 + ], + [ + "A2f0", + 6, + 8, + -1 + ], + [ + "A2f3", + 8, + 3, + 1 + ], + [ + "A2f2", + 7, + 8, + 1 + ], + [ + "A2f3", + 8, + 3, + -1 + ], + [ + "A2f2", + 7, + 8, + -1 + ], + [ + "A3f0", + 6, + 8, + 1 + ], + [ + "A3f1", + 8, + 7, + 1 + ], + [ + "A3f0", + 6, + 8, + -1 + ], + [ + "A3f1", + 8, + 7, + -1 + ], + [ + "A3f2", + 7, + 8, + 1 + ], + [ + "A3f3", + 8, + 9, + 1 + ], + [ + "A3f4", + 9, + 4, + 1 + ], + [ + "A3f3", + 8, + 9, + -1 + ], + [ + "A3f4", + 9, + 4, + -1 + ], + [ + "A3f2", + 7, + 8, + -1 + ], + [ + "A3f4", + 9, + 4, + 1 + ], + [ + "A3f3", + 8, + 9, + 1 + ], + [ + "A3f4", + 9, + 4, + -1 + ], + [ + "A3f3", + 8, + 9, + -1 + ], + [ + "A3f1", + 8, + 7, + 1 + ], + [ + "A3f0", + 6, + 8, + 1 + ], + [ + "A3f1", + 8, + 7, + -1 + ], + [ + "A3f0", + 6, + 8, + -1 + ], + [ + "A3f3", + 8, + 9, + 1 + ], + [ + "A3f4", + 9, + 4, + 1 + ], + [ + "A3f3", + 8, + 9, + -1 + ], + [ + "A3f4", + 9, + 4, + -1 + ], + [ + "A3f2", + 7, + 8, + 1 + ], + [ + "A3f4", + 9, + 4, + 1 + ], + [ + "A3f3", + 8, + 9, + 1 + ], + [ + "A3f4", + 9, + 4, + -1 + ], + [ + "A3f3", + 8, + 9, + -1 + ], + [ + "A3f2", + 7, + 8, + -1 + ], + [ + "A4f0", + 6, + 8, + 1 + ], + [ + "A4f1", + 8, + 9, + 1 + ], + [ + "A4f2", + 9, + 7, + 1 + ], + [ + "A4f1", + 8, + 9, + -1 + ], + [ + "A4f2", + 9, + 7, + -1 + ], + [ + "A4f0", + 6, + 8, + -1 + ], + [ + "A4f2", + 9, + 7, + 1 + ], + [ + "A4f1", + 8, + 9, + 1 + ], + [ + "A4f2", + 9, + 7, + -1 + ], + [ + "A4f1", + 8, + 9, + -1 + ], + [ + "A4f3", + 7, + 8, + 1 + ], + [ + "A4f4", + 8, + 9, + 1 + ], + [ + "A4f5", + 9, + 5, + 1 + ], + [ + "A4f4", + 8, + 9, + -1 + ], + [ + "A4f5", + 9, + 5, + -1 + ], + [ + "A4f3", + 7, + 8, + -1 + ], + [ + "A4f5", + 9, + 5, + 1 + ], + [ + "A4f4", + 8, + 9, + 1 + ], + [ + "A4f5", + 9, + 5, + -1 + ], + [ + "A4f4", + 8, + 9, + -1 + ], + [ + "A4f1", + 8, + 9, + 1 + ], + [ + "A4f2", + 9, + 7, + 1 + ], + [ + "A4f1", + 8, + 9, + -1 + ], + [ + "A4f2", + 9, + 7, + -1 + ], + [ + "A4f0", + 6, + 8, + 1 + ], + [ + "A4f2", + 9, + 7, + 1 + ], + [ + "A4f1", + 8, + 9, + 1 + ], + [ + "A4f2", + 9, + 7, + -1 + ], + [ + "A4f1", + 8, + 9, + -1 + ], + [ + "A4f0", + 6, + 8, + -1 + ], + [ + "A4f4", + 8, + 9, + 1 + ], + [ + "A4f5", + 9, + 5, + 1 + ], + [ + "A4f4", + 8, + 9, + -1 + ], + [ + "A4f5", + 9, + 5, + -1 + ], + [ + "A4f3", + 7, + 8, + 1 + ], + [ + "A4f5", + 9, + 5, + 1 + ], + [ + "A4f4", + 8, + 9, + 1 + ], + [ + "A4f5", + 9, + 5, + -1 + ], + [ + "A4f4", + 8, + 9, + -1 + ], + [ + "A4f3", + 7, + 8, + -1 + ], + [ + "Bf3", + 7, + 9, + 1 + ], + [ + "Bf4", + 9, + 8, + 1 + ], + [ + "Bf3", + 7, + 9, + -1 + ], + [ + "Bf4", + 9, + 8, + -1 + ], + [ + "Bf5", + 8, + 9, + 1 + ], + [ + "Bf6", + 9, + 6, + 1 + ], + [ + "Bf5", + 8, + 9, + -1 + ], + [ + "Bf6", + 9, + 6, + -1 + ], + [ + "Bf4", + 9, + 8, + 1 + ], + [ + "Bf3", + 7, + 9, + 1 + ], + [ + "Bf4", + 9, + 8, + -1 + ], + [ + "Bf3", + 7, + 9, + -1 + ], + [ + "Bf6", + 9, + 6, + 1 + ], + [ + "Bf5", + 8, + 9, + 1 + ], + [ + "Bf6", + 9, + 6, + -1 + ], + [ + "Bf5", + 8, + 9, + -1 + ], + [ + "Bf0", + 0, + 8, + 1 + ], + [ + "Bf1", + 8, + 9, + 1 + ], + [ + "Bf2", + 9, + 7, + 1 + ], + [ + "Bf1", + 8, + 9, + -1 + ], + [ + "Bf2", + 9, + 7, + -1 + ], + [ + "Bf0", + 0, + 8, + -1 + ], + [ + "Bf2", + 9, + 7, + 1 + ], + [ + "Bf1", + 8, + 9, + 1 + ], + [ + "Bf2", + 9, + 7, + -1 + ], + [ + "Bf1", + 8, + 9, + -1 + ], + [ + "Bf5", + 8, + 9, + 1 + ], + [ + "Bf6", + 9, + 6, + 1 + ], + [ + "Bf5", + 8, + 9, + -1 + ], + [ + "Bf6", + 9, + 6, + -1 + ], + [ + "Bf3", + 7, + 9, + 1 + ], + [ + "Bf4", + 9, + 8, + 1 + ], + [ + "Bf3", + 7, + 9, + -1 + ], + [ + "Bf4", + 9, + 8, + -1 + ], + [ + "Bf6", + 9, + 6, + 1 + ], + [ + "Bf5", + 8, + 9, + 1 + ], + [ + "Bf6", + 9, + 6, + -1 + ], + [ + "Bf5", + 8, + 9, + -1 + ], + [ + "Bf4", + 9, + 8, + 1 + ], + [ + "Bf3", + 7, + 9, + 1 + ], + [ + "Bf4", + 9, + 8, + -1 + ], + [ + "Bf3", + 7, + 9, + -1 + ], + [ + "Bf1", + 8, + 9, + 1 + ], + [ + "Bf2", + 9, + 7, + 1 + ], + [ + "Bf1", + 8, + 9, + -1 + ], + [ + "Bf2", + 9, + 7, + -1 + ], + [ + "Bf0", + 0, + 8, + 1 + ], + [ + "Bf2", + 9, + 7, + 1 + ], + [ + "Bf1", + 8, + 9, + 1 + ], + [ + "Bf2", + 9, + 7, + -1 + ], + [ + "Bf1", + 8, + 9, + -1 + ], + [ + "Bf0", + 0, + 8, + -1 + ], + [ + "A3f2", + 7, + 8, + 1 + ], + [ + "A3f3", + 8, + 9, + 1 + ], + [ + "A3f4", + 9, + 4, + 1 + ], + [ + "A3f3", + 8, + 9, + -1 + ], + [ + "A3f4", + 9, + 4, + -1 + ], + [ + "A3f2", + 7, + 8, + -1 + ], + [ + "A3f4", + 9, + 4, + 1 + ], + [ + "A3f3", + 8, + 9, + 1 + ], + [ + "A3f4", + 9, + 4, + -1 + ], + [ + "A3f3", + 8, + 9, + -1 + ], + [ + "A3f0", + 6, + 8, + 1 + ], + [ + "A3f1", + 8, + 7, + 1 + ], + [ + "A3f0", + 6, + 8, + -1 + ], + [ + "A3f1", + 8, + 7, + -1 + ], + [ + "A3f3", + 8, + 9, + 1 + ], + [ + "A3f4", + 9, + 4, + 1 + ], + [ + "A3f3", + 8, + 9, + -1 + ], + [ + "A3f4", + 9, + 4, + -1 + ], + [ + "A3f2", + 7, + 8, + 1 + ], + [ + "A3f4", + 9, + 4, + 1 + ], + [ + "A3f3", + 8, + 9, + 1 + ], + [ + "A3f4", + 9, + 4, + -1 + ], + [ + "A3f3", + 8, + 9, + -1 + ], + [ + "A3f2", + 7, + 8, + -1 + ], + [ + "A3f1", + 8, + 7, + 1 + ], + [ + "A3f0", + 6, + 8, + 1 + ], + [ + "A3f1", + 8, + 7, + -1 + ], + [ + "A3f0", + 6, + 8, + -1 + ], + [ + "A4f3", + 7, + 8, + 1 + ], + [ + "A4f4", + 8, + 9, + 1 + ], + [ + "A4f5", + 9, + 5, + 1 + ], + [ + "A4f4", + 8, + 9, + -1 + ], + [ + "A4f5", + 9, + 5, + -1 + ], + [ + "A4f3", + 7, + 8, + -1 + ], + [ + "A4f5", + 9, + 5, + 1 + ], + [ + "A4f4", + 8, + 9, + 1 + ], + [ + "A4f5", + 9, + 5, + -1 + ], + [ + "A4f4", + 8, + 9, + -1 + ], + [ + "A4f0", + 6, + 8, + 1 + ], + [ + "A4f1", + 8, + 9, + 1 + ], + [ + "A4f2", + 9, + 7, + 1 + ], + [ + "A4f1", + 8, + 9, + -1 + ], + [ + "A4f2", + 9, + 7, + -1 + ], + [ + "A4f0", + 6, + 8, + -1 + ], + [ + "A4f2", + 9, + 7, + 1 + ], + [ + "A4f1", + 8, + 9, + 1 + ], + [ + "A4f2", + 9, + 7, + -1 + ], + [ + "A4f1", + 8, + 9, + -1 + ], + [ + "A4f4", + 8, + 9, + 1 + ], + [ + "A4f5", + 9, + 5, + 1 + ], + [ + "A4f4", + 8, + 9, + -1 + ], + [ + "A4f5", + 9, + 5, + -1 + ], + [ + "A4f3", + 7, + 8, + 1 + ], + [ + "A4f5", + 9, + 5, + 1 + ], + [ + "A4f4", + 8, + 9, + 1 + ], + [ + "A4f5", + 9, + 5, + -1 + ], + [ + "A4f4", + 8, + 9, + -1 + ], + [ + "A4f3", + 7, + 8, + -1 + ], + [ + "A4f1", + 8, + 9, + 1 + ], + [ + "A4f2", + 9, + 7, + 1 + ], + [ + "A4f1", + 8, + 9, + -1 + ], + [ + "A4f2", + 9, + 7, + -1 + ], + [ + "A4f0", + 6, + 8, + 1 + ], + [ + "A4f2", + 9, + 7, + 1 + ], + [ + "A4f1", + 8, + 9, + 1 + ], + [ + "A4f2", + 9, + 7, + -1 + ], + [ + "A4f1", + 8, + 9, + -1 + ], + [ + "A4f0", + 6, + 8, + -1 + ] + ], + "word": [ + [ + "A0", + -1 + ], + [ + "A1", + -1 + ], + [ + "A2", + -1 + ], + [ + "B", + 1 + ], + [ + "A0", + 1 + ], + [ + "A1", + 1 + ], + [ + "A2", + 1 + ], + [ + "A3", + 1 + ], + [ + "A4", + 1 + ], + [ + "B", + -1 + ], + [ + "A3", + -1 + ], + [ + "A4", + -1 + ] + ] + } + }, + "scope": "Exact characteristic-zero queries; no new kappa or physical-memory claim.", + "seed": 53 +} diff --git a/research/bounded-pending-fanout-seed53/CLAIM.md b/research/bounded-pending-fanout-seed53/CLAIM.md new file mode 100644 index 0000000000..3373ba4ba4 --- /dev/null +++ b/research/bounded-pending-fanout-seed53/CLAIM.md @@ -0,0 +1,148 @@ +# Cycle 7 local claim + +## Completed result, 2026-10-13 19:26 UTC + +Submitted [PR1168](https://github.com/CrocSwap/integer-mult-bounds/pull/1168), +attached to the originating owner chat. This is the claim's one result update. +The bounded-pending scheduler attains `2 sum c_A + 2 ceil(k/(2W)) c_B`. +The cap-two fixture uses 404 primitive calls, compared with 716 for separate +restoration and 300 with minimum pending capacity three. All four dirty rows +restore. No new kappa, supplier or physical-memory improvement is claimed. + +Verification passes on CPython 3.11.15 and 3.14.8: 529 family cases, 46 complete +child returns, 189 dense cases and inverses, five exact finite minima, 14 +negative controls, a nonlinear counterexample, five on-disk corruption controls, +standalone optimized relocation and byte-identical certificate regeneration. +Selected integrity and all 25 selected tests pass. A globally correct +cross-boundary swap is rejected by the separate child-restoration check. + +The F3 line remains stopped as covered. No second pivot, selected-frontier +edit or change to another contributor's PR was made. Full/cold supplier replay, +Linux, formalization, hosted-CI success and independent human review are not +claimed. The repository has neither codex nor codex-automation labels. + +## One evidence-driven pivot, 19:08 UTC + +The first-result overlap check found that all six PR1088 certificate words +already have adjacent equal queries. Replacing `F^s F^s` by `F^(-s)` modulo +three yields all six 13-query repairs directly. This is an existing-witness +consequence and does not merit a new PR. The characteristic-three line stops. + +Replacement scope: an exact scheduler for PR889's one-source fanout under +a cap W on unfinished outputs, with outputs committed permanently on their +last query. Expected result is a complete query bill +`2 sum_i c_Ai + 2 ceil(k/(2W)) c_B`, plus preparation, admission and dispatch. +This is a new scheduling constraint and useful emitted tool; no new commutator +identity, unconstrained optimum, physical memory saving or kappa is claimed. + +PR889 `e2021d1c9e06948528cbc0a8fd7079b671da981d` supplies the restored fanout +and unrestricted `2k+2` minimum. PR938 +`df645942469e6a739ec94010a6068c398f4a6c86` characterizes every unrestricted +minimum word. Its actual complete proof was read, including its plateau +condition: equality permits splitting outputs around two B calls. The +replacement must cover W below `ceil(k/2)`, where those equality words cannot +meet the cap. The new lower bound uses live-output incidence at *every* B call, +including longer words and arbitrary numbers of A calls. It is not another +equality-word census. At k=5,W=2 the candidate needs four B calls; the +unrestricted construction needs two but cannot meet that cap. The scheduler +must also independently detect attempted early commits and cap violations. + +PR982 `5eca5b435d2ce172edf6ffb85694c7efa31bf114` and PR1103 +`92822cb99a7e1a28cb9d03ae5adb8e7988f30d1c` borrow outputs as connectors; +the replacement keeps a dedicated connector and excludes all outputs from +child scratch. All-state body searches for serial/online/committed/pending +output scheduling found no competing scope. Recent issue comments and the +no-pinned-issue result remain unchanged. No further pivot is permitted. + +Acceptance now requires an emitted capacity-respecting word, an all-k/W +proof of the complete positive-price query optimum, exact free-map and dense +commit checks, literal child lowering, paid recurrence and mathematical/package +negative controls. The fixed seed fixture has five outputs, cap two, B length +seven and A lengths two through six. Original cycle deadlines remain in force. + +The first complete replacement result passed at 19:14 UTC. The overlap refresh +at 19:17 UTC covered 770 open PRs through #1155 and confirmed PR889/938/982/1103 +heads unchanged. New PR1155 `9821c6e9388f3fc097e94b72be9fa7b41a849527` +coalesces read-free phase/permutation restorations. It changes a restoration +operator family; it does not constrain pending fanout outputs or count query +incidence. No competing capacity result was found. Verification/handoff began +at 19:17 UTC, before the mandatory 19:27:24 UTC reserve deadline. + +The original selection record follows, preserved as a stopped investigation. + +Final pre-submission overlap check at 19:24 UTC covered 777 open PRs through +#1162. New PR1158 `6336d879c0ba168463bf2f6fae9e653c870299fc` prices +four-source Hadamard readouts with a fixed source-call class, without a +pending-output cap; PR1159 `f38bfe5da0bed21f42ce5251d23491a56519d7c4` +provides modular ancestor borrowing. Neither supplies this scheduler or its +capacity lower bound. No same-scope claim or pinned sprint issue was found. +Upstream advanced to `c0e3631dc24e3c24a861f7d3d79e0608481cccec`; its +selection remains PR1094. The research base stays `ce7ad1b6...` as recorded. + +Claimed 2026-10-13 19:04 UTC by Sagar Thakrar, with substantial OpenAI Codex +assistance. Owner chat `01a136a0-2a0e-7a71-853d-fef24da4b94d`, host `local`. +OS-random assignment seed 53, recursive interfaces. + +Base `ce7ad1b6ab09452c3478723a2e96ed5ff212dc08`. Checkout +`/Users/thakrarsagar-dev/Documents/Codex/2026-10-13/continue-the-user-s-research-loop-13/work/integer-mult-bounds`. +Fetch completed 18:57:54 UTC. At 18:58:07 UTC clean local main and fetched +origin/main both equaled that base; only then was the new branch +`research/cycle07-seed53-recursive-interfaces` created. Earlier branches remain. + +Cycle starts 18:57:24 UTC; select by 19:05:24; begin verification by 19:27:24; +finish by 19:37:24. No reset of these deadlines and at most one evidence-driven +pivot. Expected deliverable is an exact characteristic-three connector +construction, scoped optimum and complete recursive bill, with no new kappa. + +## Candidates and early overlap check + +1. Weighted repair of PR943's five-source binary obstruction. PR943 at + `cf360b4b09b7d0419decdd6ac85421fefed55bdd` already supplies the 945-path + census and both repairs; PR1083 at + `ae95248b3301e3fafe05c1c00020f69edcdceb98` formalizes its finite exclusion. + A cheap prefix-set check found singleton missing masks of weights three + and five. A weighted restatement follows from that existing census. + Rejected as insufficient new evidence; no expanded search will be claimed. +2. Unequal positive/negative prices for PR1088's signed repairs. PR1088 at + `b0396aad724fec58630fbd4d13a809c562f18d9e` already supplies every repeated + operator. Each operator's balanced signs make pair-average pricing an + immediate reduction. Rejected as covered. +3. Selected: characteristic-three restoration by three equal-signed calls, + on PR944's canonical three-by-three obstruction. PR944 at + `5dbcfbc63f646de5a1354f6b9760ec03837233f0` explicitly restricts its + 14-query minimum to characteristic zero and excludes finite characteristic. + Its actual README, certificate, notice, and accepted ledger scope were read. + PR1088's six repairs also require characteristic-zero even multiplicities. + A small F3 check produced six 13-query occurrence profiles. This changes + the restoration algebra, rather than the seed or an existing query word. + New evidence will be six literal words, the sharp positive-price formula, + exact independent arbitrary-dirt replay, characteristic controls, and a + literal balanced child expansion. No physical supplier improvement follows. + +The first overlap scan read 1,140 all-state PR records through #1142, all open +PR bodies, current review/ledger and recent issue comments. A fresh pinned-issue +GraphQL query returned no coordination issue, so this claim is local. Targeted +body searches for characteristic-three/F3/thirteen-query connector work found +no same-scope result. PR1057/1135 cover exact-additive/rounded ancestor borrowing; +PR1103 covers rectangular output borrowing. Their interfaces remain distinct. + +The selected certificate was followed to PR1094's source inventory, assembly +and batch1099 review: conditional kappa `836330098538459/500000000000000000`, +complex-binding, bit supplier PR589/555. Those files and upstream/ stay unchanged. + +## Scope and acceptance + +Only this new research directory changes. No existing callers, tests, fixtures, +configs, exports, selected certificates or upstream files need edits. Inputs +are distinct fixed ports; exact linear maps over characteristic three; signed +unit additive queries; arbitrary initial dirt; no approximate leaves. + +Success requires literal 13-query witnesses for all six extra-call choices, +a complete lower-bound reduction, independently checked recursive expansion, +paid source access/restoration/control/storage, meaningful negative controls, +source pins and an isolated reproducible command. No general circuit optimum, +new supplier, larger kappa, formal proof or runtime speedup is promised. + +Stopping rule: complete this fixed six-witness obligation and its checks. +Recheck overlap at the first concrete result and before publication. If it is +covered, keep an honest local record rather than force a PR. diff --git a/research/bounded-pending-fanout-seed53/LICENSE b/research/bounded-pending-fanout-seed53/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/bounded-pending-fanout-seed53/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/research/bounded-pending-fanout-seed53/NOTICE.md b/research/bounded-pending-fanout-seed53/NOTICE.md new file mode 100644 index 0000000000..64d83fbb3c --- /dev/null +++ b/research/bounded-pending-fanout-seed53/NOTICE.md @@ -0,0 +1,31 @@ +# Attribution and license + +Prepared for **Sagar Thakrar / @thakrarsagar**, with substantial **OpenAI Codex +assistance** in reasoning, code, experiments, verification and prose. New work +is Apache-2.0 under the repository root LICENSE. No independent human, +delegated-agent or proof-assistant review is claimed. + +**@CubeJerry, PR889**, head `e2021d1c9e06948528cbc0a8fd7079b671da981d`, +supplies the dirty fanout contract, shared restoration, unrestricted weighted +minimum, factor lowering and accounting framework. **Ross Richardson, PR938**, +head `df645942469e6a739ec94010a6068c398f4a6c86`, supplies the equality-word +classification and coefficient-state representation. Their original README, +proof and notices are retained byte for byte under sources/. No predecessor +executable is imported. Their proofs are not presented as new results here. + +Both predecessors credit **Chafik Boukhalfa / @chafreaky, PR628**, for the dirty +product commutator lineage. The all-word bound here adds an unfinished-output +constraint and charges incidence at every shared-source call. Linear algebra, +summation by parts, the commutator identity and grouping are standard methods; +no literature-priority claim is made. + +PR982 by Ross Richardson and PR1103 by @steph4n-gh use output borrowing under different +ownership contracts. They were checked for overlap and are not consumed. +PR944 by Ross Richardson and PR1088 by @martinxxx9 receive credit for the +existing signed words that made the initially selected F3 candidate a direct +consequence. That candidate was stopped, not repackaged as a contribution. + +Rohan Arun, Jeremy Kothe, Hao Yan, Chafik Boukhalfa, Jonathan Capalbo, icekylinx, +eumemic, DreamingOfClouds and the retained community keep credit for the selected +construction and its ancestry. The OpenAI #109 framework and all inherited +full-theorem obligations remain separate. diff --git a/research/bounded-pending-fanout-seed53/README.md b/research/bounded-pending-fanout-seed53/README.md new file mode 100644 index 0000000000..636098ae1b --- /dev/null +++ b/research/bounded-pending-fanout-seed53/README.md @@ -0,0 +1,259 @@ +# Fanout with a limit on unfinished outputs + +**Recursive-interface scheduling tool and scoped optimum; no new kappa.** +PR889 shares source computation across a dirty fanout. Its minimum words can +leave several outputs unfinished at once. This package emits a schedule with +at most W unfinished outputs and permanent commits, for any k >= 0 and W >= 1. +It needs exactly + +``` +N_B = 2 ceil(k / (2W)) complete shared-source calls, +N_Ai = 2 complete calls per output. +``` + +These counts simultaneously minimize every positive fixed, sign-symmetric +query bill in the stated alphabet. The five-output, cap-two fixture costs +**404 primitive child calls versus 716 for separate restored outputs**. The +unconstrained optimum costs 300, but needs at least three unfinished outputs. +All three use four borrowed dirty rows. The cap concerns output availability; +it is not a physical-memory reduction or a measured speedup. + +Reproduce with Python 3.11+ and the standard library: + +```sh +python3 -I -B research/bounded-pending-fanout-seed53/verify.py +python3 -I -O -B research/bounded-pending-fanout-seed53/test_package.py +``` + +The first prints `PASS_BOUNDED_PENDING_FANOUT`, 529 family cases, 189 dense +cases, 14 rejected controls, and leaf counts 404/300/716. The second prints +`PASS_BOUNDED_PENDING_PACKAGE`, five rejected file corruptions, identical +regeneration and an isolated optimized relocation pass. `schedule.py` prints +the exact committed certificate to stdout and never overwrites a file. + +## Contract + +Fix distinct full length-L arrays x, z and y_0,...,y_(k-1), all initially +arbitrary. Fixed exact characteristic-zero additive linear maps A_i and B +need not commute or be invertible. The requested endpoint is + +``` +x unchanged; z unchanged; y_i += A_i B x. +``` + +The only root queries are `B^s: z += s B x` and +`A_i^s: y_i += s A_i z`, with s equal to +1 or -1. Each query preserves +its source and unrelated data, restores its private work, returns its tape +heads, and has an increment independent of the old target. Negative queries +are complete inverse shear words. No combined output query, direct product +query, extra root connector, free copy, frame change or overwrite is allowed. +All source/output rows are excluded from child scratch. + +An output becomes unfinished on its first A_i query. An explicit commit is +allowed only after the output equals its requested final value for arbitrary +initial data. After commit, no later query may touch that output. At every +root or primitive boundary, at most W outputs may be unfinished. The emitted +commits occur at complete child returns, never partway through a child. +A consumer may read committed outputs; this package does not price or execute +the consumer. Unstarted outputs retain their original values. Committed rows +remain reserved here; no reuse as recursive scratch is assumed. + +The word is fixed independently of data. The lower bound requires universal +correctness for admissible maps and inputs, and characteristic zero. Special +maps, finite-characteristic torsion, approximate or nonlinear maps, callbacks +which alter x/coefficient state, and other query alphabets are outside it. + +## Why the cap forces the shared-source bill + +Use PR938's exact coefficient representation at every prefix: + +``` +z = z_initial + q B x, +y_i = y_i_initial + e_i A_i z_initial + f_i A_i B x. +``` + +A B query of sign s changes q by s. An A_i query of sign s changes +e_i by s and f_i by s*q. Final correctness requires q=0, e_i=0 and f_i=1. +These requirements already follow by specializing to integer scalars with +identity maps and varying x and z_initial independently. + +Discrete summation by parts gives + +``` +1 = f_i(final) = - sum_over_B_queries s * e_i(before that query). +``` + +Indeed, each A_i event contributes q*delta(e_i) to both delta(e_i*q) +and delta(f_i); each B event contributes e_i*delta(q) to delta(e_i*q). +The endpoint product e_i*q is zero at both ends. Thus every output must +have nonzero e_i at some B event. Such an output is necessarily unfinished: +before its first query e_i=0, and at and after a valid commit e_i=0. +At most W outputs can be charged to any one B event. Therefore k <= W*N_B. +Restoring q=0 requires equally many positive and negative B calls, so N_B +is even. Hence N_B >= 2 ceil(k/(2W)). + +Each output needs at least one A_i query for f_i=1, and a zero signed total +requires at least two. This argument allows arbitrary extra A queries, +nonzero excursions of q, idle delays and any output order. It is not restricted +to the emitted two-readout words or to PR938's minimum-word census. +For k=0 the empty word is optimal. + +## Attaining schedule and commits + +Partition the ordered outputs into consecutive groups of at most W. Start +q=0. Alternate B signs +1,-1,+1,... across the groups. For a group G and its +sign s, emit + +``` +for i in G: A_i^(-s) +B^s +for i in G: A_i^s; commit i +``` + +The two values read from z differ by s Bx. Each output increment is +`-s A_i z_before + s A_i(z_before+s Bx) = A_i Bx`. +All outputs in G commit before any output in the next group opens. The +connector alternates between z_initial and z_initial+Bx. If the number of +groups is odd, append one B^- query after their commits. The total is +`ceil(k/W) + (ceil(k/W) mod 2) = 2 ceil(k/(2W))` B queries. + +The lower bound and this construction prove the minimum query bill + +``` +Q_min = 2 sum_i c_Ai + 2 ceil(k/(2W)) c_B, +``` + +for positive complete prices equal between signs and fixed across states and +ports. This is optimal in the stated alphabet, not over arbitrary circuits. +Word selection, admission and representation conversion remain separately +charged. Their costs are not optimized by this theorem. + +## Complete recurrence and fixture + +Let c_F(L,w) include every source/coefficient access, full-row child operation, +target update, local frame adapter, private-work restoration, per-query dispatch +and head return, with a common fixed price for both signs. Let P_F pay reusable +coefficient preparation, I pay admission/layout, and D pay group/control and +stored-program construction/access not already in c_F. Then the emitted bill is + +``` +C = I + sum_F P_F + D + N_B c_B + 2 sum_i c_Ai. +``` + +No full-row volume is divided by the output count. If an external representation +needs copies or frame changes, their cost belongs in I or c_F. The abstract +schedule emits none. Output observation is optional and separately paid. +The list emitter uses O(k+N_B) root records and a commit table of k indices. +A streaming dispatcher instead maintains an output index, group endpoint and +one sign, charging O(k+N_B) index/branch events on O(log(k+W+2))-bit counters. +It still pays each referenced factor descriptor and each emitted child. + +For factors in application order, split F into right prefix R and left suffix +S. On a new dirty child connector w, emit R(x,w), S(w,y), inverse(R)(x,w), +inverse(S)(w,y). With each child already restored/head-returning: + +``` +C([f]) = complete leaf price plus leaf dispatch, +C(F) = 2 C(R) + 2 C(S) + node dispatch, +h([f]) = 0; h(F) = 1 + max(h(R), h(S)). +``` + +The literal inverse reverses all primitive instructions and negates their +signs. Balanced contiguous splits have h(n)=ceil(log2 n) and +ell(1)=1, ell(n)=2ell(floor(n/2))+2ell(ceil(n/2)). Siblings reuse only fully +restored private scratch. Peak dirty rows are `1+max_F h(F)`, where the one +is the root connector. Recursion/control metadata and private leaf work are +additional. No clean full-length row is assumed. + +Seed 53 chooses k=5, W=2, B of seven factors and A lengths 2,3,4,5,6. +Their exact balanced prices are 52 and 4,10,16,28,40. There are 27 independent +primitive operators, six external rows and four dirty rows. + +| Schedule | Peak unfinished outputs | B queries | A queries | Primitive calls | +|---|---:|---:|---:|---:| +| Cap two | 2 | 4 | 10 | 404 | +| Unconstrained optimum, arranged at its minimum peak | 3 | 2 | 10 | 300 | +| Separate fully restored outputs | 1 | 10 | 10 | 716 | + +The cap-two schedule saves six complete B calls against separate restoration. +It costs two more B calls than the unconstrained optimum. All programs and +commit positions are literal in CERTIFICATE.json. The separate comparator is +deliberately the usual per-output restored call, not the optimum at cap one; +the theorem gives six B calls and 508 primitive calls for k=5,W=1. + +For a concrete exact realization, supply the 27 dense integer L-by-L matrices +and ten mutable rows, with entries initially bounded by H and D respectively. +Compute each dot product in an admitted clean scalar accumulator, update its +target and uncompute the dot product using the unchanged source. Restore loaded +coefficient/source/product temporaries as well. This pays two dot-product passes, +including 2L^2 products, 2L^2 accumulator additions, L target additions and +at least 2L^2 coefficient and source reads per leaf. Temporary loading/clearing, +index arithmetic and instruction traffic are additional, not free erasures. + +Place the data/coefficient words on one tape of S=10L+27L^2 word cells and use +separate scalar/control work. A direct move-to-address implementation with +reloads/unloads can use at most 16L^2+4L+2 addressed data visits per leaf, +including its final head return; each move spans at most S cells. Its paid +bit-time is bounded by +`O(S*(L^2+1)*w + L^2*M(w) + L^2*w*log(S+2))` plus instruction access, +where M includes clean multiplication workspace/cleanup. A sufficient common +signed width for all three programs is +`2+ceil(log2(max(1,D,H)))+716*ceil(log2(1+L*H))`. +This follows from the per-leaf infinity-norm growth factor 1+L*H and also +bounds dot-product intermediates. Initialize and restore the O(1) scalar words +and O(w) arithmetic work in I and the leaf price. Input matrix production is P. +These are conservative implementation bounds, not a physical tape benchmark +or an improvement to the selected supplier. + +## Independent checks and limits + +The scheduler's search space is empty: it emits a proved formula and fixed +construction. The verifier does not import predecessor executables. Its free +noncommutative module keeps all ten arbitrary input rows, verifies every commit, +all 46 complete child boundaries, the full map and literal inverse. At each +child return it checks the intended ordered product and every restored private +row; other external ports are forbidden throughout the child. Its dense integer interpreter independently +checks every basis column and a mixed dirty input at L=1,2,3 for all three +expanded programs, 189 forward cases and their inverses. The family check covers +k=0..32 and every W=1..max(1,k), 529 cases, including rational query prices. + +A separately written breadth-first reachability checker covers every shorter +word and finds minima 4,6,6,10,8 for (k,W)=(1,1),(2,1),(2,2),(3,1),(3,2). +Its state is q, the number of unopened outputs, the multiset of active pairs +(e_i,f_i), and the number permanently committed. It considers both signs for +every active query and B, opening under capacity, and either committing or +keeping an active output when its pair reaches (0,1). Sorting active pairs is +a label-symmetry quotient preserving reachability; no labelled-word counts +are claimed. There is no heuristic pruning. It stops at the first complete +endpoint. This finite check supports, and does not replace, the written bound. + +Controls reject premature root/leaf commits, excess pending capacity, missing +connector restoration, sign changes, wrong factors, unpaid leaves, aliases and +invalid domains. A nonlinear scalar control returns 7 instead of 1 when +A(z)=z^2, x=1 and z_initial=3; linearity is essential. Package controls mutate +actual files and test a changed producer together with its regenerated bad +certificate, so comparison to a frozen certificate is not the only guard. +One additional control swaps zero-based primitive positions 79 and 80 across +a child return. The full dirty endpoint, literal inverse and all commits still +pass, but the per-child restoration checker rejects it. Thus those final-state +checks alone would not establish the required recursive interface. This is a +control on this package's emitted word, not a defect attributed to a predecessor. + +PR889 is credited for the interface/commutator and unrestricted weighted +minimum. PR938 is credited for the exact coefficient state and every equality +case. Its two-B equality words already imply that unrestricted optimal work +can be arranged with ceil(k/2) pending outputs. This package claims that fact +only as inherited context. The addition is an emitted scheduler, commit checker +and all-word lower bound below that capacity, including longer words. PR982 +and PR1103 change output borrowing and remain distinct. + +The selected base is `ce7ad1b6ab09452c3478723a2e96ed5ff212dc08`, with PR1094's +conditional kappa `836330098538459/500000000000000000`, bound by the complex +supplier. No occurrence of this abstract fanout has been physically admitted +inside that supplier. Compiler/common-label realization, hosting, full-row +volume, external precision/tape integration and outer analytic assembly remain +unresolved or inherited. Finite checks are not a formal multiplication theorem, +an independent human review, a new kappa, or a speed claim. + +See CLAIM.md for the rejected F3 line and single bounded pivot, SOURCES.json +for original Git/SHA256 pins, and NOTICE.md for preserved credit and license. diff --git a/research/bounded-pending-fanout-seed53/SOURCES.json b/research/bounded-pending-fanout-seed53/SOURCES.json new file mode 100644 index 0000000000..96298fa6db --- /dev/null +++ b/research/bounded-pending-fanout-seed53/SOURCES.json @@ -0,0 +1,37 @@ +{ + "base": "ce7ad1b6ab09452c3478723a2e96ed5ff212dc08", + "files": [ + { + "pr": 889, + "head": "e2021d1c9e06948528cbc0a8fd7079b671da981d", + "path": "research/dirty-fanout-batch/README.md", + "retained": "sources/PR889-README.md", + "sha256": "0ef1c0a7dd98c0270822e6f78d222a3888083794502b132543038827c783c706", + "git_blob": "400761138ddd10fb77b836be7c59590545be70e0" + }, + { + "pr": 889, + "head": "e2021d1c9e06948528cbc0a8fd7079b671da981d", + "path": "research/dirty-fanout-batch/NOTICE.md", + "retained": "sources/PR889-NOTICE.md", + "sha256": "e0ea74eed5957ed62f6c3eb5dadd6f51fd61d6c5ba546d29fb96adf4dda50e4b", + "git_blob": "7c5788e0766d4d01d2710828d6972ad53a54b513" + }, + { + "pr": 938, + "head": "df645942469e6a739ec94010a6068c398f4a6c86", + "path": "research/dirty-fanout-star-census/PROOF.md", + "retained": "sources/PR938-PROOF.md", + "sha256": "9df4f8c6c40627054f512608b3ff423b61d453209ca3741eca1caa450ccd7b2b", + "git_blob": "8cc737780cc89280cbbe7d89bf3aa10cf2309e8b" + }, + { + "pr": 938, + "head": "df645942469e6a739ec94010a6068c398f4a6c86", + "path": "research/dirty-fanout-star-census/NOTICE.md", + "retained": "sources/PR938-NOTICE.md", + "sha256": "a50dd4719c3481db0179f9983da4d7c10ef32fd1ac081e5417d86c5b0095c251", + "git_blob": "c5f338fc907b5bd20ffc61ba90cedb9db9c61242" + } + ] +} diff --git a/research/bounded-pending-fanout-seed53/VALIDATION.md b/research/bounded-pending-fanout-seed53/VALIDATION.md new file mode 100644 index 0000000000..5dcf31a4ae --- /dev/null +++ b/research/bounded-pending-fanout-seed53/VALIDATION.md @@ -0,0 +1,57 @@ +# Local validation + +Checked on macOS arm64, CPython 3.11.15 and 3.14.8, on 2026-10-13 UTC. +Exact research base: `ce7ad1b6ab09452c3478723a2e96ed5ff212dc08`. +Final verifier stdout SHA256: +`d4fc755f22aa31ac062e20be2bd5222ca6c9001b14b2db4fa956825171c0bfba`. +Certificate SHA256: +`5e3c19a0731e5bc9093db5844b36e3f83c59725fd7ac95cea3b68f23e68f04a3`. + +Commands run from the repository root with the user's RTK shell prefix: + +``` +rtk proxy python3.11 -I -B research/bounded-pending-fanout-seed53/verify.py +rtk proxy python3.11 -I -O -B research/bounded-pending-fanout-seed53/verify.py +rtk proxy python3.14 -I -O -B research/bounded-pending-fanout-seed53/verify.py +rtk proxy python3.11 -I -O -B research/bounded-pending-fanout-seed53/test_package.py +rtk proxy python3.14 -I -O -B research/bounded-pending-fanout-seed53/test_package.py +``` + +All pass. The final mathematical receipt agrees across interpreters and +optimization modes. Package checks confirm standalone relocation from an +unrelated working directory and byte-identical certificate regeneration. +Five real file mutations fail, including a changed producer paired with its +own regenerated certificate. No network is required by either public command. + +The receipt covers 529 k/capacity cases, 46 complete child boundaries, 189 +dense basis/mixed-state cases and their inverses, all free noncommutative +input columns of all three expanded programs, 14 rejected mathematical/input +controls and one explicit nonlinear counterexample. The exact finite BFS +minima are 4,6,6,10,8 on the five declared k/capacity pairs. No larger search +or exhaustive global circuit claim is made. + +Selected-record integrity and all existing selected tests pass: + +``` +rtk proxy python3.11 -B scripts/verify_selected_result.py +rtk proxy python3.11 -B tests/test_selected_inventory_links.py +rtk proxy python3.11 -B tests/test_selected_proof_binding.py +rtk proxy python3.11 -B tests/test_selected_result.py +``` + +The suites run 8,12,5 tests respectively. Selected kappa remains +`836330098538459/500000000000000000`. No source in those checks was edited. +The final diff is confined to this new research directory; upstream/ and +existing certificates remain unchanged. + +The 19:21 UTC refresh advanced origin/main to +`c0e3631dc24e3c24a861f7d3d79e0608481cccec`; it still selects PR1094 at the +same kappa and contains no conflicting package path. That is a handoff +observation, not a relabeling of the investigation base. Original PR889/938 +heads and the four copied proof/notice pins remain fixed. + +Full make verify, selected cold supplier replay, a physical tape implementation, +Linux execution, hosted CI completion, formalization and independent human +review were not performed. This package adds an abstract exact scheduling +interface and scoped query optimum; supplier integration and a kappa change +remain unestablished. diff --git a/research/bounded-pending-fanout-seed53/schedule.py b/research/bounded-pending-fanout-seed53/schedule.py new file mode 100644 index 0000000000..354271f6f7 --- /dev/null +++ b/research/bounded-pending-fanout-seed53/schedule.py @@ -0,0 +1,73 @@ +"""Exact signed fanout schedules with a limit on unfinished outputs.""" + +import json + + +def schedule(k, capacity): + if type(k) is not int or k < 0: + raise ValueError("output count must be a nonnegative integer") + if type(capacity) is not int or capacity < 1: + raise ValueError("capacity must be a positive integer") + word, commits = [], [-1] * k + sign = 1 + for start in range(0, k, capacity): + group = range(start, min(start + capacity, k)) + word.extend([[f"A{i}", -sign] for i in group]) + word.append(["B", sign]) + for i in group: + word.append([f"A{i}", sign]) + commits[i] = len(word) - 1 + sign = -sign + if sign == -1: + word.append(["B", -1]) + return {"word": word, "commit_after": commits} + + +def inverse(word): + return [item[:-1] + [-item[-1]] for item in reversed(word)] + + +def factor_word(factors, source, target, scratch): + if len(factors) == 1: + return [[factors[0], source, target, 1]] + middle = len(factors) // 2 + connector, *rest = scratch + right = factor_word(factors[:middle], source, connector, rest) + left = factor_word(factors[middle:], connector, target, rest) + return right + left + inverse(right) + inverse(left) + + +def lower(plan, factors, k): + depth = max((len(v) - 1).bit_length() for v in factors.values()) + scratch = list(range(k + 2, k + 2 + depth)) + leaves, ends = [], [] + for name, sign in plan["word"]: + source, target = (0, k + 1) if name == "B" else (k + 1, int(name[1:]) + 1) + child = factor_word(factors[name], source, target, scratch) + leaves.extend(child if sign == 1 else inverse(child)) + ends.append(len(leaves) - 1) + return {**plan, "leaves": leaves, + "leaf_commit_after": [ends[t] for t in plan["commit_after"]], + "dirty_rows": 1 + depth} + + +def fixture(): + k, capacity = 5, 2 + lengths = {"B": 7, **{f"A{i}": i + 2 for i in range(k)}} + factors = {name: [f"{name}f{j}" for j in range(n)] for name, n in lengths.items()} + separate = {"word": [], "commit_after": []} + for i in range(k): + separate["word"].extend([[f"A{i}", -1], ["B", 1], [f"A{i}", 1], ["B", -1]]) + separate["commit_after"].append(4 * i + 2) + plans = {"bounded": schedule(k, capacity), + "unrestricted": schedule(k, (k + 1) // 2), + "separate": separate} + return {"format": "bounded-pending-fanout-v1", "seed": 53, + "base": "ce7ad1b6ab09452c3478723a2e96ed5ff212dc08", + "outputs": k, "capacity": capacity, "factors": factors, + "plans": {name: lower(plan, factors, k) for name, plan in plans.items()}, + "scope": "Exact characteristic-zero queries; no new kappa or physical-memory claim."} + + +if __name__ == "__main__": + print(json.dumps(fixture(), indent=2, sort_keys=True)) diff --git a/research/bounded-pending-fanout-seed53/sources/PR889-NOTICE.md b/research/bounded-pending-fanout-seed53/sources/PR889-NOTICE.md new file mode 100644 index 0000000000..7c5788e076 --- /dev/null +++ b/research/bounded-pending-fanout-seed53/sources/PR889-NOTICE.md @@ -0,0 +1,31 @@ +# Attribution and scope + +Prepared for the requesting contributor with substantial OpenAI Codex assistance +in the mathematical argument, implementation, tests and prose. The user's human +identity is not asserted. This package uses the repository's Apache-2.0 license. + +Chafik Boukhalfa / chafreaky's PR628 supplies the dirty product commutator, +literal-inverse convention, exact restoration contract and rounded-error +analysis. Its reference source, proof and notice are retained byte for byte. +Ali Romman's PR621 and OpenAI's exact-DFT/Newton framework are inherited context; +we do not use their analytic kernel claims to certify the abstract matrices here. +The commutator and batching algebra are classical; no literature-priority claim +is made. + +Relevant concurrent work inspected: androolloyd's PR673 (multiway dirty echo), +commdata2338's PR677 (native DATA-query contract), Dillon Amburgey's PR689 +(ternary placement), FanPUYen's PR714 (clean root checkpoint), Sagar Thakrar's +PR730 (fixed scratch optimization), nightangelflowerwin-ops's PR788 (reusable +clean checkpoint), PR822 (dirty sibling connector reuse), and Wentao Li's PR840 +(dyadic ADDRESS-query pair). These concern different contracts or one-output +schedules. Their code is not consumed; no relative optimality against their +broader classes is claimed. Varun Mittal's PR793 batches scalar coefficient +preparation in historical JP8 compensation and preserves its recursive profile; +this package instead batches full product-query calls under a different abstract +multi-output contract. No PR793 code or claimed savings are consumed. PR663's nonlinear-restoration distinction is +acknowledged and explicitly respected by the rounded controls. + +The accepted frontier's authors and source lineage retain all attribution. +This local multi-output result supplies neither a new κ nor an instantiated +current supplier, physical tape compiler, full theorem formalization, human +peer review or measured performance result. diff --git a/research/bounded-pending-fanout-seed53/sources/PR889-README.md b/research/bounded-pending-fanout-seed53/sources/PR889-README.md new file mode 100644 index 0000000000..400761138d --- /dev/null +++ b/research/bounded-pending-fanout-seed53/sources/PR889-README.md @@ -0,0 +1,227 @@ +# Batch product shears with a common right factor + +**Recursive-interface construction; no new κ.** This package supplies an exact +multi-output version of the dirty product commutator from Chafik Boukhalfa's +[PR628](https://github.com/CrocSwap/integer-mult-bounds/pull/628), with a literal +instruction generator, complete local cost recurrence, a restricted-query +optimality argument, and independent exact checks. + +For the seed-58 fixture, five outputs share eight rightmost factors. Batching +uses **246 primitive factor-shear calls**, versus **680** for five separate +balanced binary products, with **four borrowed dirty arrays in either case**. +The comparison is between these explicit binary schedules. Multiway echoes and +arbitrary circuits are outside the comparison. The 434-call reduction (about +63.82%) is not a measured runtime or an integer-multiplication exponent gain. + +From the repository root, Python 3.9+ and the standard library suffice: + +```sh +python3 -I -O -B research/dirty-fanout-batch/verify.py +``` + +Expected: `PASS_DIRTY_FANOUT_BATCH`, 128 free-word cases, 795 dense cases, +`680 -> 246 leaves`, four dirty arrays. The default command checks the complete +committed [certificate](CERTIFICATE.json); `--write` regenerates it instead. +`python3 -I -O -B research/dirty-fanout-batch/test_package.py` checks relocation +and rejects deliberately broken packages. + +## Contract and exact identity + +Let x, y_1,...,y_k and every borrowed array be independent arbitrary elements +of R^L, with distinct storage and unchanged read-only coefficients. R may be a +noncommutative ring; A_i and B are additive linear operators, in the indicated +order. The goal is simultaneously + +``` +x -> x, y_i -> y_i + A_i B x, all borrowed arrays restored. +``` + +A child `target += F(source)` preserves its source and all its own scratch. +It is independent of the target's previous value. Its negative call is the +literal reverse instruction word with signs reversed. Every source/target and +coefficient array is excluded from borrowed storage. All outputs are reserved +throughout the batch. No concurrent observer may use the temporary output +values. Common B and its input x must stay identical across the two calls. + +With one arbitrary dirty connector z, execute: + +1. `z += B x`. +2. For every i, `y_i += A_i z`. +3. `z -= B x`. +4. For every i in reverse order, `y_i -= A_i z`. + +The two observed values of z are z_0+B x and z_0. Thus the increment is +A_i(z_0+B x)-A_i z_0=A_i B x. All dirt cancels, and z returns to z_0. No +commutation of A_i with B, or of individual factors, is used. Neither A_i +nor B needs to be invertible; their additive shears are invertible. Distinct output +ports make the A_i calls commute with one another after their private scratch +has been restored. The emitted negative block nevertheless uses the literal +inverse, so no extra commutation assumption is needed for its implementation. + +This is the familiar commutator identity applied to a direct-sum output map; +we make no algebraic or literature-priority claim. The contribution is the +explicit batched interface, executable factor lowering, pricing, and controls. +It changes the demanded output family; it is not a new single-output echo tree. + +### A sharp bound in the specified star-query model + +Allow only signed queries `z += ±B x` and `y_i += ±A_i z`, with one connector, +read-only x, private query scratch restored before return, and no other data +operations. Treat the maps as free formal operators. At an A_i query, write +z=z_0+t Bx. Final dirt independence forces the signed coefficient sum on A_i z_0 +to vanish, while correctness requires the signed sum of the corresponding t's +to be one. Therefore there must be at least two A_i queries for every output. +At least one B query is needed for a nonzero signal; restoration of z requires +at least one opposite B query. Hence every admissible word uses at least +`2k+2` queries. The construction attains it, including under arbitrary positive +per-operator query prices. This does not bound models admitting combined-output +queries, extra connectors, direct A_i B queries, or other linear operations. + +The finite regression exhausts all 9,331 signed star words of lengths zero +through five for k=2. Their failure supports the implementation of the universal +argument above; enumeration is not the proof of that argument. + +## Recursive lowering and exact cost + +Factor lists are in **application order**: `[B0,B1,A0]` means A0 B1 B0. +Each product is lowered with PR628's balanced binary dirty commutator, using +one distinct array per active recursion level. All child calls operate on +**full length-L rows**. Batching never divides their charged volume by k. +Let C(F;L,w) be the complete cost of an additive product child, with both signs +bounded by the same price and with its heads returned to the documented entry +positions. For a leaf j let c_j include arithmetic, source and coefficient +access, target update, phase/descriptor work, routing and head returns. Then + +``` +C([j]) = c_j + dispatch_leaf +C(F_right followed by F_left) + = 2 C(F_right) + 2 C(F_left) + dispatch_node +C_batch = 2 C(B) + 2 sum_i C(A_i) + dispatch_batch. +``` + +No child or inverse is free. The unbatched *same-root-split* comparator costs +`2k C(B) + 2 sum C(A_i) + dispatch_separate`, so the recursive saving is +`2(k-1) C(B)` before comparing dispatch and layout overhead. If source access, +layout or external frames differ, use their actual c_j; the operation count +alone does not imply a bit-cost improvement. + +For an unweighted balanced product of n factors, L(1)=1 and +L(n)=2L(floor(n/2))+2L(ceil(n/2)). Writing p=2^floor(log2 n), induction gives +L(n)=p(3n-2p). Scratch is ceil(log2 n). The batch's dirty requirement is +`1 + max(ceil(log2 |B|), max_i ceil(log2 |A_i|))`, in addition to its source +and k output arrays. Child scratch is reused only after return; all sibling +outputs remain excluded. There is no clean length-L array. + +For seed 58, k=2+(58 mod 5)=5, |B|=1+(58 mod 17)=8, and |A_i|=i: + +| Schedule | Complete leaf calls | Dirty arrays | +|---|---:|---:| +| Separate products, each split into the common B and its A_i | 758 | 4 | +| Separate balanced products of lengths 9,10,11,12,13 | 680 | 4 | +| Shared B batch | 246 | 4 | + +A separate integer DP checks the minimum over all ordered **binary** splits +for n=1,...,64 and agrees with the balanced counts. No all-arity optimum is +asserted; PR673, PR730 and PR822 investigate different tree/allocation classes. +The certificate lists exact per-factor multiplicities and three positive +nonuniform price assignments for every sampled batch, rather than crediting +only the convenient common-factor calls. + +### Fully charged dense reference realization + +There is also a simple, deliberately slow implementation of each matrix leaf. +For every target entry, form the dot product in one scalar accumulator, then +add/subtract it to the target. All matrix coefficients are read-only. The +source and target rows are distinct. The certificate records, for each schedule +on identical 3-by-3 inputs and the same role layout: + +- N L² coefficient reads and N L² source reads; +- N L target read/write updates; +- N L² multiplications, N L(L+1) additions (including zero-initialized sums), + and one sign negation per negative target update; +- literal one-tape head travel, measured in word slots, including returning + to slot zero after **every** primitive call; +- coefficient storage, data storage and every emitted instruction record; +- array-length/role-alias checks and the explicit preflight matrix-row and + coefficient-alias checks (N L and N R L respectively, for R live roles). + +The tape layout puts all mutable rows first and the coefficient matrices +second. Within a dot product it visits coefficient then source for each term, +then the destination, and returns home at leaf end. The head-travel sum is +`sum |next_position-current_position|` for that literal trace. Coefficients and +source entries must be loaded into a constant number of scalar arithmetic +ports. This reference makes no locality or free-gather assumption. + +For word size w, multiply this travel by w, add O(w) per load/store, the listed +counts times integer multiplication/addition costs M(w), A(w), and charge +O(N(log(number of roles)+log(number of factors))) instruction/control bits +and O(N) generator records. Also charge the listed descriptor/alias preflight +comparisons at the required index/pointer bit width; they are not arithmetic +leaf calls. This invoice describes the reference algorithm, not CPython +interpreter wall time. Input coefficient preparation is additional and +paid once for each distinct factor, equally available to both comparators. +The seed matrices are already supplied exact integers; a cyclic-inverse or +phase oracle would need its own preparation and validation bill. + +For integer matrices of row norm at most K=L H, input magnitude at most D, +and N leaf calls, exact states are bounded by D(1+K)^N. Thus signed word length +`2 + ceil(log2(max(1,D))) + N ceil(log2(1+K))` suffices. The same conservative +word length from the larger comparator can be used for all schedules. This +is a finite dense-matrix realization, not an efficient common-label/tape +compiler for the selected supplier. + +## Rounded leaves: restoration and accuracy are different + +A deterministic grid leaf `target += F(source)` can be inverted exactly by +subtracting the same computed increment. Literal inverse words then restore +all source/borrowed arrays even when F is nonlinear from rounding, provided +read-only data and all excluded arrays are respected. B's paired calls see +the same source and deeper dirt: intervening A_i calls restore their source +z and private scratch. The final A_i calls use the restored connector. + +The target increment need not be the exact, dirt-independent A_i Bx in this +case. For example floor((z+1)/2)-floor(z/2) depends on dirty z. We include this +negative control and make no substitution of approximate linearity for exact +linearity in the identity or query minimum above. + +For a separate accuracy bound, suppose the ideal primitive operators have +infinity norm at most K and each rounded primitive's increment error is at +most u, uniformly on the actual trajectory. A full ideal shear has norm at +most 1+K. Telescoping the N perturbed shears gives + +``` +error <= u sum_(j=0)^(N-1) (1+K)^j <= N u (1+K)^(N-1). +``` + +For u=2^-w, `w >= p + ceil(log2 N) + (N-1)ceil(log2(1+K))` suffices for error +at most 2^-p. Actual state magnitudes are bounded by (D+1)(2+K)^N for u<=1, +which must also be included in integer-word storage. Coefficient perturbation +and preparation errors must be added separately; source-dependent error +bounds require checking the resulting magnitude bound, not silently using +this uniform-u premise. Twenty-seven exact grid experiments compare a floor +rounding interpreter with independent dense ideal products and check the full +error bound and exact all-role reversal. + +## Verification scope, provenance and stopping rule + +[CLAIM.md](CLAIM.md) records the OS seed, three candidates, overlap review and +local claim. Exact base: `f567884aeb8851b6e794af1184119a3bfbe1e631`. +[Source pins](SOURCES.json) retain the original proof, implementation reference +and notice from PR628 at `0768f97d06c623b8211e651543c66135796b62bf`, with Git +blob and SHA256 hashes. Those source files are references; their cyclic-scan +implementation is not imported or asserted to have been revalidated here. + +The test domain is fixed: common lengths 1..16, fanout 1..8 with left lengths +1..k; dense domains/fixtures listed in verify.py; and the seed-selected example. +Random dense inputs use Python Random(58); the track draw used OS randomness. +This is a bounded constructive check, not a search for a new multiplication +bound or an impossibility claim outside the stated star-query model. + +The selected #799/#589 result at this base is κ=1661634653669567/10^18. Its +native calls are not assumed to have the shared source, coefficient, frame, +volume and exclusivity contract used here. No current invoice term is removed. +Existing owner obligations, ordinary child widths, read-only source access, +common-label realization, precision, layout and all-size analytic transfer +remain unresolved for any supplier application. This package changes no +selected certificate or upstream manuscript. See [NOTICE.md](NOTICE.md) for +attribution and substantial AI assistance. diff --git a/research/bounded-pending-fanout-seed53/sources/PR938-NOTICE.md b/research/bounded-pending-fanout-seed53/sources/PR938-NOTICE.md new file mode 100644 index 0000000000..c5f338fc90 --- /dev/null +++ b/research/bounded-pending-fanout-seed53/sources/PR938-NOTICE.md @@ -0,0 +1,26 @@ +# Attribution and license + +Prepared for Ross Richardson (@RossRichardson), with substantial OpenAI Codex +assistance in the mathematics, code, tests and writing. A delegated Codex agent +independently derived the equality count and reviewed the checker within this +scope. This is AI-assisted independent implementation, not independent human +review. New files use Apache-2.0; the repository license is included. + +CubeJerry's PR889, commit `e2021d1c9e06948528cbc0a8fd7079b671da981d`, supplies +the batched dirty-fanout construction, sharp restricted-query minimum and +literal emitter. Three original files are retained without edits under +`vendor/pr889/`; their original attribution and substantial-AI notice remain. +The original README's relative links describe its source package; only the +three files listed in SOURCES.json are vendored here. + +Chafik Boukhalfa (chafreaky), PR628, supplies the dirty product commutator +lineage and restoration contract. Its implementation is not imported here. +The commutator identity and the predecessor's minimum bound are not claimed +as new. This package adds a complete equality characterization/count and an +independently implemented exact census and emitter check. + +The accepted selected frontier and its authors retain all attribution. No +current invoice or exponent is changed. PR896 formalizes a different nonlinear +binary evaluator obligation; its code is not imported. PR934 studies another +multi-source query alphabet; this package counts all shortest labelled words +in the one-source signed star alphabet. diff --git a/research/bounded-pending-fanout-seed53/sources/PR938-PROOF.md b/research/bounded-pending-fanout-seed53/sources/PR938-PROOF.md new file mode 100644 index 0000000000..8cc737780c --- /dev/null +++ b/research/bounded-pending-fanout-seed53/sources/PR938-PROOF.md @@ -0,0 +1,176 @@ +# Exact signed star-query census + +This note independently checks the sharp star-query argument in +[PR889](https://github.com/CrocSwap/integer-mult-bounds/pull/889), at commit +`e2021d1c9e06948528cbc0a8fd7079b671da981d`, and characterizes every equality +case. The predecessor supplies the construction and its query lower bound; +the contribution here is the complete equality census and an independently +justified coefficient-state checker. The repository base for this contribution +is `91a2094f2e022930069e8cfdc810a3ea1b81cd09`. + +## Statement and scope + +Fix an integer `k >= 1`. The only allowed letters are + +``` +B_s: z <- z + s Bx +A_i,s: y_i <- y_i + s A_i z (1 <= i <= k; s in {-1,+1}). +``` + +Source `x`, connector `z`, and outputs `y_i` occupy distinct storage. Each +letter preserves its source and restores any private scratch before returning. +The maps are exact additive linear maps, remain unchanged, and are available +only through these letters. A valid word must implement, for every allowed +choice of maps and arbitrary initial data, + +``` +z <- z; y_i <- y_i + A_i Bx; x <- x. +``` + +There are no combined-output letters, direct product letters, extra +connectors, or other data operations. We count literal words: output labels, +signs, and ordering distinguish words even when two adjacent operations +commute. + +**Result.** No valid word has length below `2k+2`. The exact number of valid +words of length `2k+2` is + +``` +C_k = 2(k+1)(k!)^2. +``` + +This is a mathematical proof for the stated query alphabet, accompanied by +finite executable checks. It is not a machine-checked formal proof, a lower +bound for general circuits, or a proof of the full multiplication theorem. +The universal-map condition matters: a fixed zero map, torsion in a fixed +characteristic, or other special identities can change the valid-word set. +`k=0` is excluded because its shortest valid word is the empty word. + +## Exact integer state + +At every prefix there are integers `t`, `a_i`, and `b_i` such that + +``` +z = z_0 + t Bx, +y_i = y_i,0 + a_i A_i z_0 + b_i A_i Bx. +``` + +All coefficients start at zero. A letter `B_s` updates only `t <- t+s`. +A letter `A_i,s` uses the current `t` and updates only + +``` +(a_i,b_i) <- (a_i+s, b_i+s*t). +``` + +Induction proves these identities using additivity alone; no commutation or +invertibility of the maps is needed. Consequently a word is universally valid +if and only if its final state has + +``` +t = 0; a_i = 0 and b_i = 1 for every i. +``` + +Sufficiency follows directly from the displayed identities. For necessity, +one may already specialize to integer scalars with identity maps: independently +varying `z_0` and `x` separates the two output coefficients, and varying `x` +tests connector restoration. Thus these integer conditions do not merely test +a sample of free-map instances; they characterize universal validity in this +alphabet. A finite matrix replay is a separate implementation check. + +## Minimum length and equality characterization + +Each output must have at least one `A_i` letter to obtain `b_i=1`. Since its +signed count must finish at `a_i=0`, it needs at least two. At least one `B` +letter is necessary to make any observed `t` nonzero, and `t=0` at the end +requires at least two. This proves the lower bound `2k+2`. + +At equality there are exactly two `B` letters of opposite signs, and exactly +two letters of each output, also of opposite signs. Write the first `B` sign +as `s`. The value of `t` is zero before the first `B`, `s` between the two +`B` letters, and zero after the second. Call the middle interval the plateau. + +For output `i`, both letters outside the plateau give `b_i=0`; both inside +give `b_i=s(+1-1)=0`. Hence exactly one must lie inside. To produce `b_i=1`, +its sign must be `s`; the outside letter then has sign `-s`. Conversely, any +word satisfying these conditions has the required final coefficient state. +This characterizes every equality case, with no further ordering condition +among letters from different outputs. + +For a fixed number `j` of outputs whose outside letter is before the first +`B`, choose their labels in `binom(k,j)` ways. Order those `j` letters in +`j!` ways, all `k` plateau letters in `k!` ways, and the remaining `k-j` +outside letters after the second `B` in `(k-j)!` ways. Either first `B` sign +is possible. Therefore the number for this `j` is + +``` +2 binom(k,j) j! k! (k-j)! = 2(k!)^2. +``` + +The `k+1` possible values of `j` are disjoint and exhaustive. This proves +the stated formula. For `k=1,...,5` it gives `4, 24, 288, 5760, 172800`. + +## Why the symmetry quotient preserves exact word counts + +Permuting output labels permutes the pairs `(a_i,b_i)` and commutes with all +state transitions, up to the same permutation of letter labels. A canonical +state can therefore retain `t` and the sorted multiset of these pairs. + +Suppose a pair `(a,b)` has multiplicity `m`. For either sign `s`, there are +exactly `m` distinct labelled next letters whose chosen output has this pair. +Each produces the same canonical successor: replace one copy by +`(a+s,b+s*t)` and sort. Assign that transition weight `m`. Each of the two +`B` transitions has weight one. Distinct transitions reaching the same +canonical successor must have their weights added; they must not be +deduplicated as unlabelled words. + +Starting with count one at the all-zero state, propagate nonnegative integer +counts by multiplication by transition weights and addition at successors. +Induction on word length shows that each state's count equals the number of +literal labelled words whose coefficient state has that canonical form. +Every labelled state in an orbit has the same outgoing multiplicities, so +aggregating incoming counts introduces neither an orbit-size factor nor a +division by `k!`. The desired terminal orbit consists of `t=0` with `k` +copies of `(0,1)`. + +## Safe remaining-length pruning + +For any intermediate state define + +``` +h = |t| + sum_i f(a_i,b_i), +f(a,b) = |a| if a != 0, + 0 if a == 0 and b == 1, + 2 if a == 0 and b != 1. +``` + +Any successful continuation must use at least `|t|` additional `B` letters +to restore the connector, because only those letters change `t` and each +changes it by one. If `a_i != 0`, at least `|a_i|` additional `A_i` letters +are needed to cancel its signed dirt coefficient. If `a_i=0` but `b_i!=1`, +zero further `A_i` letters cannot correct `b_i`, and one cannot leave +`a_i=0`; at least two are necessary. These are disjoint letter families, +so their lower bounds add. This proves `h` is a lower bound on every +successful continuation's length. Pruning only when `h` exceeds the remaining +length cannot remove a successful word. + +The bound need not be attainable. For example, at the initial state it equals +`2k`, although two additional `B` letters are necessary to create a signal. +Such underestimation affects speed, not completeness. Also `h=0` holds exactly +at the desired terminal coefficient state, so an exhausted horizon does not +accept an unresolved output. + +## Attribution and remaining obligations + +PR889 supplies the batched interface and sharp restricted-query minimum; +its cited predecessor, Chafik Boukhalfa's +[PR628](https://github.com/CrocSwap/integer-mult-bounds/pull/628), supplies +the dirty product commutator lineage. No priority claim is made for the +commutator identity. This proof and its companion verifier were prepared for +the requesting contributor with substantial OpenAI Codex assistance and are +provided under the repository's Apache-2.0 license. + +The abstract query contract is inherited. This result does not supply native +source access, coefficient preparation, physical layout, precision guarantees +for approximate maps, supplier integration, or a new exponent `kappa`. +Finite census results should be reported with their completed `k` and length +domain; they do not independently establish obligations outside this alphabet. diff --git a/research/bounded-pending-fanout-seed53/test_package.py b/research/bounded-pending-fanout-seed53/test_package.py new file mode 100644 index 0000000000..11be8b0ca8 --- /dev/null +++ b/research/bounded-pending-fanout-seed53/test_package.py @@ -0,0 +1,70 @@ +"""Offline relocation and actual file-corruption controls for the public CLI.""" + +import json +from pathlib import Path +import shutil +import subprocess +import sys +import tempfile + +HERE = Path(__file__).resolve().parent + + +def run(folder, script="verify.py"): + return subprocess.run([sys.executable, "-I", "-O", "-B", str(folder / script)], + cwd=folder.parent, text=True, capture_output=True, timeout=30) + + +def need(ok, message): + if not ok: + raise RuntimeError(message) + + +def main(): + baseline = run(HERE) + need(baseline.returncode == 0, baseline.stderr) + with tempfile.TemporaryDirectory(prefix="bounded-pending-") as root: + destination = Path(root) / "package" + shutil.copytree(HERE, destination, ignore=shutil.ignore_patterns("__pycache__")) + clean = run(destination) + need(clean.returncode == 0 and clean.stdout == baseline.stdout, "relocation differs") + generated = run(destination, "schedule.py") + need(generated.returncode == 0 and + generated.stdout == (destination / "CERTIFICATE.json").read_text(), + "literal certificate regeneration differs") + for mutation in ("certificate", "commit", "source", "inventory", "producer"): + shutil.rmtree(destination) + shutil.copytree(HERE, destination, ignore=shutil.ignore_patterns("__pycache__")) + if mutation in ("certificate", "commit"): + path = destination / "CERTIFICATE.json" + data = json.loads(path.read_text()) + if mutation == "certificate": + data["plans"]["bounded"]["leaves"].pop() + else: + data["plans"]["bounded"]["commit_after"][0] = 0 + path.write_text(json.dumps(data)) + elif mutation == "source": + path = destination / "sources/PR938-PROOF.md" + path.write_bytes(path.read_bytes() + b"\nchanged\n") + elif mutation == "inventory": + path = destination / "SOURCES.json" + data = json.loads(path.read_text()) + data["files"].pop() + path.write_text(json.dumps(data)) + else: + path = destination / "schedule.py" + old = path.read_text() + new = old.replace('word.append(["B", -1])', 'word.append(["B", 1])') + need(new != old, "producer mutation not applied") + path.write_text(new) + changed = run(destination, "schedule.py") + need(changed.returncode == 0, "mutated producer did not run") + (destination / "CERTIFICATE.json").write_text(changed.stdout) + result = run(destination) + need(result.returncode != 0 and "ValueError" in result.stderr, + f"{mutation} corruption was not rejected") + print("PASS_BOUNDED_PENDING_PACKAGE controls=5 relocated_optimized=PASS regeneration=identical") + + +if __name__ == "__main__": + main() diff --git a/research/bounded-pending-fanout-seed53/verify.py b/research/bounded-pending-fanout-seed53/verify.py new file mode 100644 index 0000000000..66095bccb7 --- /dev/null +++ b/research/bounded-pending-fanout-seed53/verify.py @@ -0,0 +1,294 @@ +"""Independent free-module, commit-boundary and finite-state checks.""" + +from collections import Counter +from copy import deepcopy +from fractions import Fraction +import hashlib +import importlib.util +import itertools +import json +from pathlib import Path + +HERE = Path(__file__).resolve().parent +SPEC = importlib.util.spec_from_file_location("capacity_schedule", HERE / "schedule.py") +SCHED = importlib.util.module_from_spec(SPEC) +SPEC.loader.exec_module(SCHED) +PINS = { + "sources/PR889-README.md": "0ef1c0a7dd98c0270822e6f78d222a3888083794502b132543038827c783c706", + "sources/PR889-NOTICE.md": "e0ea74eed5957ed62f6c3eb5dadd6f51fd61d6c5ba546d29fb96adf4dda50e4b", + "sources/PR938-PROOF.md": "9df4f8c6c40627054f512608b3ff423b61d453209ca3741eca1caa450ccd7b2b", + "sources/PR938-NOTICE.md": "a50dd4719c3481db0179f9983da4d7c10ef32fd1ac081e5417d86c5b0095c251", +} + + +def need(ok, message): + if not ok: + raise ValueError(message) + + +def identity(rows): + return [{((), i): 1} for i in range(rows)] + + +def step(state, item, allowed): + name, source, target, sign = item + need(name in allowed and type(sign) is int and sign in (-1, 1), "invalid primitive") + need(type(source) is int and type(target) is int and + 0 <= source < len(state) and 0 <= target < len(state) and source != target, + "invalid or aliased ports") + for (chain, origin), coefficient in state[source].items(): + term = chain + (name,), origin + value = state[target].get(term, 0) + sign * coefficient + if value: + state[target][term] = value + else: + state[target].pop(term, None) + + +def target_map(k, rows, factors): + result = identity(rows) + for i in range(k): + result[i + 1][(tuple(factors["B"] + factors[f"A{i}"]), 0)] = 1 + return result + + +def root_leaves(word, k): + result = [] + names = {"B", *(f"A{i}" for i in range(k))} + for name, sign in word: + need(name in names, "unknown query") + src, dst = (0, k + 1) if name == "B" else (k + 1, int(name[1:]) + 1) + result.append([name, src, dst, sign]) + return result + + +def replay(leaves, commits, k, rows, factors, capacity): + need(type(capacity) is int and capacity > 0, "invalid capacity") + need(len(commits) == k and all(type(t) is int and 0 <= t < len(leaves) for t in commits), + "invalid commit table") + initial, expected = identity(rows), target_map(k, rows, factors) + state = deepcopy(initial) + pending, finished, peak = set(), set(), 0 + allowed = set(itertools.chain.from_iterable(factors.values())) + events = {} + for i, t in enumerate(commits): + events.setdefault(t, []).append(i) + for t, item in enumerate(leaves): + need(item[1] - 1 not in finished, "committed output read again") + dst = item[2] + need(dst != 0, "source mutated") + if 1 <= dst <= k: + i = dst - 1 + need(i not in finished, "committed output touched again") + pending.add(i) + peak = max(peak, len(pending)) + need(peak <= capacity, "unfinished-output capacity exceeded") + step(state, item, allowed) + for i in events.get(t, []): + need(i in pending and state[i + 1] == expected[i + 1], "incorrect early commit") + pending.remove(i) + finished.add(i) + need(state == expected and not pending and len(finished) == k, "wrong endpoint or restoration") + for name, src, dst, sign in reversed(leaves): + step(state, [name, src, dst, -sign], allowed) + need(state == initial, "literal inverse failed") + return peak + + +def root_check(plan, k, capacity): + factors = {name: [name] for name in ["B", *(f"A{i}" for i in range(k))]} + return replay(root_leaves(plan["word"], k), plan["commit_after"], k, k + 2, factors, capacity) + + +def child_boundary_check(plan, factors, k, rows): + state = identity(rows) + allowed = set(itertools.chain.from_iterable(factors.values())) + offset, ends = 0, [] + for name, src, dst, sign in root_leaves(plan["word"], k): + expected = deepcopy(state) + for (chain, origin), coefficient in state[src].items(): + term = chain + tuple(factors[name]), origin + value = expected[dst].get(term, 0) + sign * coefficient + if value: + expected[dst][term] = value + else: + expected[dst].pop(term, None) + n = len(factors[name]) + power = 1 << (n.bit_length() - 1) + size = power * (3 * n - 2 * power) + permitted = {src, dst, *range(k + 2, rows)} + for item in plan["leaves"][offset:offset + size]: + need(item[1] in permitted and item[2] in permitted and item[2] != src, + "child uses a reserved port") + step(state, item, allowed) + need(state == expected, "child did not restore its complete boundary") + offset += size + ends.append(offset - 1) + need(offset == len(plan["leaves"]), "unpaid child instructions") + need(plan["leaf_commit_after"] == [ends[t] for t in plan["commit_after"]], + "commit is not at a complete child return") + return len(ends) + + +def minimum_search(k, capacity, limit): + # Output-label symmetry preserves reachability, not labelled word counts. + states = {(0, k, (), 0)} + sizes = [] + for depth in range(limit + 1): + sizes.append(len(states)) + if (0, 0, (), k) in states: + return depth, sizes + following = set() + for q, unopened, active, done in states: + for sign in (-1, 1): + following.add((q + sign, unopened, active, done)) + for j, (a, b) in enumerate(active): + for sign in (-1, 1): + aa, bb = a + sign, b + sign * q + changed = list(active) + changed[j] = aa, bb + following.add((q, unopened, tuple(sorted(changed)), done)) + if (aa, bb) == (0, 1): + following.add((q, unopened, active[:j] + active[j + 1:], done + 1)) + if unopened and len(active) < capacity: + for sign in (-1, 1): + following.add((q, unopened - 1, tuple(sorted(active + ((sign, sign * q),))), done)) + states = following + return None, sizes + + +def dense_check(plan, factors, k, rows): + names = sorted(itertools.chain.from_iterable(factors.values())) + cases = 0 + for dimension in (1, 2, 3): + matrices = {name: [[((j + 2) * (r + 1) + (j + 1) * (c + 2) + r * c) % 5 - 2 + for c in range(dimension)] for r in range(dimension)] + for j, name in enumerate(names)} + def apply(matrix, vector): + return [sum(x * y for x, y in zip(row, vector)) for row in matrix] + def product(labels, vector): + for label in labels: + vector = apply(matrices[label], vector) + return vector + inputs = [] + for j in range(rows * dimension): + vector = [0] * (rows * dimension) + vector[j] = 1 + inputs.append(vector) + inputs.append([((j + 53) % 11) - 5 for j in range(rows * dimension)]) + for flat in inputs: + initial = [flat[i * dimension:(i + 1) * dimension] for i in range(rows)] + state, expected = deepcopy(initial), deepcopy(initial) + for i in range(k): + delta = product(factors["B"] + factors[f"A{i}"], initial[0]) + expected[i + 1] = [a + b for a, b in zip(initial[i + 1], delta)] + for t, (name, src, dst, sign) in enumerate(plan["leaves"]): + delta = apply(matrices[name], state[src]) + state[dst] = [a + sign * b for a, b in zip(state[dst], delta)] + for i, when in enumerate(plan["leaf_commit_after"]): + if t == when: + need(state[i + 1] == expected[i + 1], "dense commit failed") + need(state == expected, "dense endpoint failed") + for name, src, dst, sign in reversed(plan["leaves"]): + delta = apply(matrices[name], state[src]) + state[dst] = [a - sign * b for a, b in zip(state[dst], delta)] + need(state == initial, "dense inverse failed") + cases += 1 + return cases + + +def reject(call): + try: + call() + except (ValueError, KeyError, IndexError): + return 1 + raise ValueError("negative control was accepted") + + +def verify(data): + need(data == SCHED.fixture(), "certificate differs from literal regeneration") + k, cap, factors = data["outputs"], data["capacity"], data["factors"] + need((k, cap) == (5, 2), "fixture scope changed") + counts, peaks, dense, boundaries = {}, {}, 0, 0 + for name, plan in data["plans"].items(): + allowed_cap = 3 if name == "unrestricted" else 2 + rows = k + 1 + plan["dirty_rows"] + need(plan["dirty_rows"] == 4, "unpaid scratch") + root_check(plan, k, allowed_cap) + boundaries += child_boundary_check(plan, factors, k, rows) + peaks[name] = replay(plan["leaves"], plan["leaf_commit_after"], k, rows, factors, allowed_cap) + counts[name] = len(plan["leaves"]) + dense += dense_check(plan, factors, k, rows) + need(counts == {"bounded": 404, "unrestricted": 300, "separate": 716}, "wrong complete leaf prices") + need(peaks == {"bounded": 2, "unrestricted": 3, "separate": 1}, "wrong peak pending count") + family = 0 + for outputs in range(33): + for capacity in range(1, max(2, outputs + 1)): + plan = SCHED.schedule(outputs, capacity) + root_check(plan, outputs, capacity) + counts_by_name = Counter(name for name, sign in plan["word"]) + expected_b = 2 * ((outputs + 2 * capacity - 1) // (2 * capacity)) + need(counts_by_name["B"] == expected_b and + all(counts_by_name[f"A{i}"] == 2 for i in range(outputs)), "family multiplicity") + prices = {name: Fraction(1 + ((j + 53) % 17), 1 + j % 5) + for j, name in enumerate(["B", *(f"A{i}" for i in range(outputs))])} + actual = sum(prices[name] for name, sign in plan["word"]) + target = expected_b * prices["B"] + 2 * sum(v for name, v in prices.items() if name != "B") + need(actual == target, "weighted bill mismatch") + family += 1 + minima = {} + for outputs, capacity, bound in [(1, 1, 4), (2, 1, 6), (2, 2, 6), (3, 1, 10), (3, 2, 8)]: + actual, sizes = minimum_search(outputs, capacity, bound) + need(actual == bound, "independent finite minimum differs") + minima[f"{outputs},{capacity}"] = {"minimum": actual, "states_by_depth": sizes} + controls = 0 + for outputs, capacity in [(True, 1), (-1, 1), (1, 0), (1, True), (1, Fraction(1))]: + controls += reject(lambda o=outputs, c=capacity: SCHED.schedule(o, c)) + bounded = data["plans"]["bounded"] + controls += reject(lambda: root_check(data["plans"]["unrestricted"], k, cap)) + bad = deepcopy(bounded) + bad["commit_after"][0] = 0 + controls += reject(lambda: root_check(bad, k, cap)) + bad = deepcopy(bounded) + bad["word"] = bad["word"][:-1] + controls += reject(lambda: root_check(bad, k, cap)) + bad = deepcopy(bounded) + bad["word"][2][-1] *= -1 + controls += reject(lambda: root_check(bad, k, cap)) + for mode in ("omit", "factor", "alias", "commit"): + bad = deepcopy(bounded) + if mode == "omit": + del bad["leaves"][-1] + elif mode == "factor": + bad["leaves"][0][0] = factors["B"][0] + elif mode == "alias": + bad["leaves"][0][1] = bad["leaves"][0][2] + else: + bad["leaf_commit_after"][0] = 0 + controls += reject(lambda: replay(bad["leaves"], bad["leaf_commit_after"], k, 10, factors, cap)) + bad = deepcopy(bounded) + bad["leaves"][79], bad["leaves"][80] = bad["leaves"][80], bad["leaves"][79] + replay(bad["leaves"], bad["leaf_commit_after"], k, 10, factors, cap) + controls += reject(lambda: child_boundary_check(bad, factors, k, 10)) + need((3 + 1) ** 2 - 3 ** 2 == 7 and 7 != 1, "nonlinear boundary control") + return {"status": "PASS_BOUNDED_PENDING_FANOUT", "family_cases": family, + "leaf_calls": counts, "peak_pending": peaks, "dense_cases": dense, + "controls_rejected": controls, "nonlinear_counterexamples": 1, + "complete_child_boundaries": boundaries, + "finite_minima": minima, "no_new_kappa": True} + + +def main(): + manifest = json.loads((HERE / "SOURCES.json").read_text()) + need({item["retained"]: item["sha256"] for item in manifest["files"]} == PINS, "source inventory differs") + for item in manifest["files"]: + payload = (HERE / item["retained"]).read_bytes() + need(hashlib.sha256(payload).hexdigest() == item["sha256"], "source SHA256 differs") + blob = b"blob " + str(len(payload)).encode() + b"\0" + payload + need(hashlib.sha1(blob).hexdigest() == item["git_blob"], "source Git blob differs") + result = verify(json.loads((HERE / "CERTIFICATE.json").read_text())) + print(json.dumps(result, sort_keys=True)) + + +if __name__ == "__main__": + main()