diff --git a/research/universal-connector-boundary/CERTIFICATE.json b/research/universal-connector-boundary/CERTIFICATE.json new file mode 100644 index 0000000000..079e3e1441 --- /dev/null +++ b/research/universal-connector-boundary/CERTIFICATE.json @@ -0,0 +1,3564 @@ +{ + "schema": "universal-connector-boundary-v1", + "base": "91a2094f2e022930069e8cfdc810a3ea1b81cd09", + "assignment_seed": 52, + "censuses": [ + { + "sources": 4, + "pairings": 105, + "histogram": { + "11": 14, + "13": 28, + "14": 37, + "16": 26 + }, + "canonical_entries_sha256": "089186798debffadbc21f4528d70bfd3445d7a6fa2630bdfc2207dcf04f87f4e", + "max_coverage": 16 + }, + { + "sources": 5, + "pairings": 945, + "histogram": { + "16": 42, + "19": 120, + "21": 180, + "22": 56, + "23": 45, + "24": 220, + "26": 110, + "28": 150, + "31": 22 + }, + "canonical_entries_sha256": "1419cd57230138cc8a37c0411c513cf4109d0bba03c10cd1196e137a9a10ea9c", + "max_coverage": 31 + } + ], + "schedules": { + "four_all": { + "sources": 4, + "rows": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15 + ], + "source_word": [ + 0, + 1, + 0, + 1, + 2, + 3, + 2, + 3 + ], + "readout_slots": [ + [ + 0, + 1 + ], + [ + 0, + 3 + ], + [ + 0, + 2 + ], + [ + 0, + 5 + ], + [ + 1, + 5 + ], + [ + 3, + 5 + ], + [ + 2, + 5 + ], + [ + 0, + 7 + ], + [ + 1, + 7 + ], + [ + 3, + 7 + ], + [ + 2, + 7 + ], + [ + 0, + 6 + ], + [ + 1, + 6 + ], + [ + 3, + 6 + ], + [ + 2, + 6 + ] + ], + "word": [ + [ + "A", + 0 + ], + [ + "A", + 1 + ], + [ + "A", + 2 + ], + [ + "A", + 3 + ], + [ + "A", + 7 + ], + [ + "A", + 11 + ], + [ + "B", + 0 + ], + [ + "A", + 0 + ], + [ + "A", + 4 + ], + [ + "A", + 8 + ], + [ + "A", + 12 + ], + [ + "B", + 1 + ], + [ + "A", + 2 + ], + [ + "A", + 6 + ], + [ + "A", + 10 + ], + [ + "A", + 14 + ], + [ + "B", + 0 + ], + [ + "A", + 1 + ], + [ + "A", + 5 + ], + [ + "A", + 9 + ], + [ + "A", + 13 + ], + [ + "B", + 1 + ], + [ + "B", + 2 + ], + [ + "A", + 3 + ], + [ + "A", + 4 + ], + [ + "A", + 5 + ], + [ + "A", + 6 + ], + [ + "B", + 3 + ], + [ + "A", + 11 + ], + [ + "A", + 12 + ], + [ + "A", + 13 + ], + [ + "A", + 14 + ], + [ + "B", + 2 + ], + [ + "A", + 7 + ], + [ + "A", + 8 + ], + [ + "A", + 9 + ], + [ + "A", + 10 + ], + [ + "B", + 3 + ] + ], + "queries": 38 + }, + "five_extra_source": { + "sources": 5, + "rows": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31 + ], + "source_word": [ + 2, + 0, + 2, + 1, + 2, + 0, + 3, + 1, + 4, + 2, + 3, + 4 + ], + "readout_slots": [ + [ + 0, + 3 + ], + [ + 1, + 6 + ], + [ + 0, + 4 + ], + [ + 0, + 1 + ], + [ + 0, + 2 + ], + [ + 0, + 6 + ], + [ + 0, + 5 + ], + [ + 1, + 8 + ], + [ + 2, + 8 + ], + [ + 1, + 7 + ], + [ + 2, + 7 + ], + [ + 0, + 8 + ], + [ + 3, + 8 + ], + [ + 0, + 7 + ], + [ + 3, + 7 + ], + [ + 0, + 11 + ], + [ + 3, + 11 + ], + [ + 7, + 9 + ], + [ + 4, + 11 + ], + [ + 1, + 11 + ], + [ + 2, + 11 + ], + [ + 6, + 11 + ], + [ + 5, + 11 + ], + [ + 0, + 10 + ], + [ + 2, + 9 + ], + [ + 6, + 9 + ], + [ + 4, + 10 + ], + [ + 0, + 9 + ], + [ + 2, + 10 + ], + [ + 6, + 10 + ], + [ + 4, + 9 + ] + ], + "word": [ + [ + "A", + 0 + ], + [ + "A", + 2 + ], + [ + "A", + 3 + ], + [ + "A", + 4 + ], + [ + "A", + 5 + ], + [ + "A", + 6 + ], + [ + "A", + 11 + ], + [ + "A", + 13 + ], + [ + "A", + 15 + ], + [ + "A", + 23 + ], + [ + "A", + 27 + ], + [ + "B", + 2 + ], + [ + "A", + 1 + ], + [ + "A", + 3 + ], + [ + "A", + 7 + ], + [ + "A", + 9 + ], + [ + "A", + 19 + ], + [ + "B", + 0 + ], + [ + "A", + 4 + ], + [ + "A", + 8 + ], + [ + "A", + 10 + ], + [ + "A", + 20 + ], + [ + "A", + 24 + ], + [ + "A", + 28 + ], + [ + "B", + 2 + ], + [ + "A", + 0 + ], + [ + "A", + 12 + ], + [ + "A", + 14 + ], + [ + "A", + 16 + ], + [ + "B", + 1 + ], + [ + "A", + 2 + ], + [ + "A", + 18 + ], + [ + "A", + 26 + ], + [ + "A", + 30 + ], + [ + "B", + 2 + ], + [ + "A", + 6 + ], + [ + "A", + 22 + ], + [ + "B", + 0 + ], + [ + "A", + 1 + ], + [ + "A", + 5 + ], + [ + "A", + 21 + ], + [ + "A", + 25 + ], + [ + "A", + 29 + ], + [ + "B", + 3 + ], + [ + "A", + 9 + ], + [ + "A", + 10 + ], + [ + "A", + 13 + ], + [ + "A", + 14 + ], + [ + "A", + 17 + ], + [ + "B", + 1 + ], + [ + "A", + 7 + ], + [ + "A", + 8 + ], + [ + "A", + 11 + ], + [ + "A", + 12 + ], + [ + "B", + 4 + ], + [ + "A", + 17 + ], + [ + "A", + 24 + ], + [ + "A", + 25 + ], + [ + "A", + 27 + ], + [ + "A", + 30 + ], + [ + "B", + 2 + ], + [ + "A", + 23 + ], + [ + "A", + 26 + ], + [ + "A", + 28 + ], + [ + "A", + 29 + ], + [ + "B", + 3 + ], + [ + "A", + 15 + ], + [ + "A", + 16 + ], + [ + "A", + 18 + ], + [ + "A", + 19 + ], + [ + "A", + 20 + ], + [ + "A", + 21 + ], + [ + "A", + 22 + ], + [ + "B", + 4 + ] + ], + "queries": 74 + }, + "five_extra_output": { + "sources": 5, + "rows": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31 + ], + "source_word": [ + 0, + 1, + 2, + 0, + 3, + 1, + 4, + 2, + 3, + 4 + ], + "readout_slots": [ + [ + 0, + 1 + ], + [ + 1, + 2 + ], + [ + 0, + 2 + ], + [ + 2, + 3 + ], + [ + 2, + 4 + ], + [ + 0, + 4 + ], + [ + 0, + 3 + ], + [ + 4, + 5 + ], + [ + 3, + 5 + ], + [ + 4, + 6 + ], + [ + 3, + 6 + ], + [ + 0, + 6 + ], + [ + 1, + 6 + ], + [ + 0, + 5 + ], + [ + 1, + 5 + ], + [ + 0, + 9 + ], + [ + 1, + 9 + ], + [ + 5, + 7 + ], + [ + 2, + 9 + ], + [ + 6, + 8 + ], + [ + 0, + 1, + 6, + 8 + ], + [ + 4, + 9 + ], + [ + 3, + 9 + ], + [ + 0, + 8 + ], + [ + 1, + 8 + ], + [ + 4, + 7 + ], + [ + 2, + 8 + ], + [ + 0, + 7 + ], + [ + 1, + 7 + ], + [ + 4, + 8 + ], + [ + 2, + 7 + ] + ], + "word": [ + [ + "A", + 0 + ], + [ + "A", + 2 + ], + [ + "A", + 5 + ], + [ + "A", + 6 + ], + [ + "A", + 11 + ], + [ + "A", + 13 + ], + [ + "A", + 15 + ], + [ + "A", + 20 + ], + [ + "A", + 23 + ], + [ + "A", + 27 + ], + [ + "B", + 0 + ], + [ + "A", + 0 + ], + [ + "A", + 1 + ], + [ + "A", + 12 + ], + [ + "A", + 14 + ], + [ + "A", + 16 + ], + [ + "A", + 20 + ], + [ + "A", + 24 + ], + [ + "A", + 28 + ], + [ + "B", + 1 + ], + [ + "A", + 1 + ], + [ + "A", + 2 + ], + [ + "A", + 3 + ], + [ + "A", + 4 + ], + [ + "A", + 18 + ], + [ + "A", + 26 + ], + [ + "A", + 30 + ], + [ + "B", + 2 + ], + [ + "A", + 3 + ], + [ + "A", + 6 + ], + [ + "A", + 8 + ], + [ + "A", + 10 + ], + [ + "A", + 22 + ], + [ + "B", + 0 + ], + [ + "A", + 4 + ], + [ + "A", + 5 + ], + [ + "A", + 7 + ], + [ + "A", + 9 + ], + [ + "A", + 21 + ], + [ + "A", + 25 + ], + [ + "A", + 29 + ], + [ + "B", + 3 + ], + [ + "A", + 7 + ], + [ + "A", + 8 + ], + [ + "A", + 13 + ], + [ + "A", + 14 + ], + [ + "A", + 17 + ], + [ + "B", + 1 + ], + [ + "A", + 9 + ], + [ + "A", + 10 + ], + [ + "A", + 11 + ], + [ + "A", + 12 + ], + [ + "A", + 19 + ], + [ + "A", + 20 + ], + [ + "B", + 4 + ], + [ + "A", + 17 + ], + [ + "A", + 25 + ], + [ + "A", + 27 + ], + [ + "A", + 28 + ], + [ + "A", + 30 + ], + [ + "B", + 2 + ], + [ + "A", + 19 + ], + [ + "A", + 20 + ], + [ + "A", + 23 + ], + [ + "A", + 24 + ], + [ + "A", + 26 + ], + [ + "A", + 29 + ], + [ + "B", + 3 + ], + [ + "A", + 15 + ], + [ + "A", + 16 + ], + [ + "A", + 18 + ], + [ + "A", + 21 + ], + [ + "A", + 22 + ], + [ + "B", + 4 + ] + ], + "queries": 74 + } + }, + "lowered": { + "five_extra_source": { + "factor_lengths": { + "B": [ + 1, + 2, + 3, + 4, + 5 + ], + "A": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ] + }, + "factors": { + "B0": [ + "B0.0" + ], + "B1": [ + "B1.0", + "B1.1" + ], + "B2": [ + "B2.0", + "B2.1", + "B2.2" + ], + "B3": [ + "B3.0", + "B3.1", + "B3.2", + "B3.3" + ], + "B4": [ + "B4.0", + "B4.1", + "B4.2", + "B4.3", + "B4.4" + ], + "A0": [ + "A0.0" + ], + "A1": [ + "A1.0" + ], + "A2": [ + "A2.0" + ], + "A3": [ + "A3.0" + ], + "A4": [ + "A4.0" + ], + "A5": [ + "A5.0" + ], + "A6": [ + "A6.0" + ], + "A7": [ + "A7.0" + ], + "A8": [ + "A8.0" + ], + "A9": [ + "A9.0" + ], + "A10": [ + "A10.0" + ], + "A11": [ + "A11.0" + ], + "A12": [ + "A12.0" + ], + "A13": [ + "A13.0" + ], + "A14": [ + "A14.0" + ], + "A15": [ + "A15.0" + ], + "A16": [ + "A16.0" + ], + "A17": [ + "A17.0" + ], + "A18": [ + "A18.0" + ], + "A19": [ + "A19.0" + ], + "A20": [ + "A20.0" + ], + "A21": [ + "A21.0" + ], + "A22": [ + "A22.0" + ], + "A23": [ + "A23.0" + ], + "A24": [ + "A24.0" + ], + "A25": [ + "A25.0" + ], + "A26": [ + "A26.0" + ], + "A27": [ + "A27.0" + ], + "A28": [ + "A28.0" + ], + "A29": [ + "A29.0" + ], + "A30": [ + "A30.0" + ] + }, + "query_leaf_prices": { + "B0": 1, + "B1": 4, + "B2": 10, + "B3": 16, + "B4": 28, + "A0": 1, + "A1": 1, + "A2": 1, + "A3": 1, + "A4": 1, + "A5": 1, + "A6": 1, + "A7": 1, + "A8": 1, + "A9": 1, + "A10": 1, + "A11": 1, + "A12": 1, + "A13": 1, + "A14": 1, + "A15": 1, + "A16": 1, + "A17": 1, + "A18": 1, + "A19": 1, + "A20": 1, + "A21": 1, + "A22": 1, + "A23": 1, + "A24": 1, + "A25": 1, + "A26": 1, + "A27": 1, + "A28": 1, + "A29": 1, + "A30": 1 + }, + "leaf_word": [ + [ + "A0.0", + "z", + "y0" + ], + [ + "A2.0", + "z", + "y2" + ], + [ + "A3.0", + "z", + "y3" + ], + [ + "A4.0", + "z", + "y4" + ], + [ + "A5.0", + "z", + "y5" + ], + [ + "A6.0", + "z", + "y6" + ], + [ + "A11.0", + "z", + "y11" + ], + [ + "A13.0", + "z", + "y13" + ], + [ + "A15.0", + "z", + "y15" + ], + [ + "A23.0", + "z", + "y23" + ], + [ + "A27.0", + "z", + "y27" + ], + [ + "B2.0", + "x2", + "scratch0" + ], + [ + "B2.1", + "scratch0", + "scratch1" + ], + [ + "B2.2", + "scratch1", + "z" + ], + [ + "B2.1", + "scratch0", + "scratch1" + ], + [ + "B2.2", + "scratch1", + "z" + ], + [ + "B2.0", + "x2", + "scratch0" + ], + [ + "B2.2", + "scratch1", + "z" + ], + [ + "B2.1", + "scratch0", + "scratch1" + ], + [ + "B2.2", + "scratch1", + "z" + ], + [ + "B2.1", + "scratch0", + "scratch1" + ], + [ + "A1.0", + "z", + "y1" + ], + [ + "A3.0", + "z", + "y3" + ], + [ + "A7.0", + "z", + "y7" + ], + [ + "A9.0", + "z", + "y9" + ], + [ + "A19.0", + "z", + "y19" + ], + [ + "B0.0", + "x0", + "z" + ], + [ + "A4.0", + "z", + "y4" + ], + [ + "A8.0", + "z", + "y8" + ], + [ + "A10.0", + "z", + "y10" + ], + [ + "A20.0", + "z", + "y20" + ], + [ + "A24.0", + "z", + "y24" + ], + [ + "A28.0", + "z", + "y28" + ], + [ + "B2.0", + "x2", + "scratch0" + ], + [ + "B2.1", + "scratch0", + "scratch1" + ], + [ + "B2.2", + "scratch1", + "z" + ], + [ + "B2.1", + "scratch0", + "scratch1" + ], + [ + "B2.2", + "scratch1", + "z" + ], + [ + "B2.0", + "x2", + "scratch0" + ], + [ + "B2.2", + "scratch1", + "z" + ], + [ + "B2.1", + "scratch0", + "scratch1" + ], + [ + "B2.2", + "scratch1", + "z" + ], + [ + "B2.1", + "scratch0", + "scratch1" + ], + [ + "A0.0", + "z", + "y0" + ], + [ + "A12.0", + "z", + "y12" + ], + [ + "A14.0", + "z", + "y14" + ], + [ + "A16.0", + "z", + "y16" + ], + [ + "B1.0", + "x1", + "scratch0" + ], + [ + "B1.1", + "scratch0", + "z" + ], + [ + "B1.0", + "x1", + "scratch0" + ], + [ + "B1.1", + "scratch0", + "z" + ], + [ + "A2.0", + "z", + "y2" + ], + [ + "A18.0", + "z", + "y18" + ], + [ + "A26.0", + "z", + "y26" + ], + [ + "A30.0", + "z", + "y30" + ], + [ + "B2.0", + "x2", + "scratch0" + ], + [ + "B2.1", + "scratch0", + "scratch1" + ], + [ + "B2.2", + "scratch1", + "z" + ], + [ + "B2.1", + "scratch0", + "scratch1" + ], + [ + "B2.2", + "scratch1", + "z" + ], + [ + "B2.0", + "x2", + "scratch0" + ], + [ + "B2.2", + "scratch1", + "z" + ], + [ + "B2.1", + "scratch0", + "scratch1" + ], + [ + "B2.2", + "scratch1", + "z" + ], + [ + "B2.1", + "scratch0", + "scratch1" + ], + [ + "A6.0", + "z", + "y6" + ], + [ + "A22.0", + "z", + "y22" + ], + [ + "B0.0", + "x0", + "z" + ], + [ + "A1.0", + "z", + "y1" + ], + [ + "A5.0", + "z", + "y5" + ], + [ + "A21.0", + "z", + "y21" + ], + [ + "A25.0", + "z", + "y25" + ], + [ + "A29.0", + "z", + "y29" + ], + [ + "B3.0", + "x3", + "scratch1" + ], + [ + "B3.1", + "scratch1", + "scratch0" + ], + [ + "B3.0", + "x3", + "scratch1" + ], + [ + "B3.1", + "scratch1", + "scratch0" + ], + [ + "B3.2", + "scratch0", + "scratch1" + ], + [ + "B3.3", + "scratch1", + "z" + ], + [ + "B3.2", + "scratch0", + "scratch1" + ], + [ + "B3.3", + "scratch1", + "z" + ], + [ + "B3.1", + "scratch1", + "scratch0" + ], + [ + "B3.0", + "x3", + "scratch1" + ], + [ + "B3.1", + "scratch1", + "scratch0" + ], + [ + "B3.0", + "x3", + "scratch1" + ], + [ + "B3.3", + "scratch1", + "z" + ], + [ + "B3.2", + "scratch0", + "scratch1" + ], + [ + "B3.3", + "scratch1", + "z" + ], + [ + "B3.2", + "scratch0", + "scratch1" + ], + [ + "A9.0", + "z", + "y9" + ], + [ + "A10.0", + "z", + "y10" + ], + [ + "A13.0", + "z", + "y13" + ], + [ + "A14.0", + "z", + "y14" + ], + [ + "A17.0", + "z", + "y17" + ], + [ + "B1.0", + "x1", + "scratch0" + ], + [ + "B1.1", + "scratch0", + "z" + ], + [ + "B1.0", + "x1", + "scratch0" + ], + [ + "B1.1", + "scratch0", + "z" + ], + [ + "A7.0", + "z", + "y7" + ], + [ + "A8.0", + "z", + "y8" + ], + [ + "A11.0", + "z", + "y11" + ], + [ + "A12.0", + "z", + "y12" + ], + [ + "B4.0", + "x4", + "scratch1" + ], + [ + "B4.1", + "scratch1", + "scratch0" + ], + [ + "B4.0", + "x4", + "scratch1" + ], + [ + "B4.1", + "scratch1", + "scratch0" + ], + [ + "B4.2", + "scratch0", + "scratch1" + ], + [ + "B4.3", + "scratch1", + "scratch2" + ], + [ + "B4.4", + "scratch2", + "z" + ], + [ + "B4.3", + "scratch1", + "scratch2" + ], + [ + "B4.4", + "scratch2", + "z" + ], + [ + "B4.2", + "scratch0", + "scratch1" + ], + [ + "B4.4", + "scratch2", + "z" + ], + [ + "B4.3", + "scratch1", + "scratch2" + ], + [ + "B4.4", + "scratch2", + "z" + ], + [ + "B4.3", + "scratch1", + "scratch2" + ], + [ + "B4.1", + "scratch1", + "scratch0" + ], + [ + "B4.0", + "x4", + "scratch1" + ], + [ + "B4.1", + "scratch1", + "scratch0" + ], + [ + "B4.0", + "x4", + "scratch1" + ], + [ + "B4.3", + "scratch1", + "scratch2" + ], + [ + "B4.4", + "scratch2", + "z" + ], + [ + "B4.3", + "scratch1", + "scratch2" + ], + [ + "B4.4", + "scratch2", + "z" + ], + [ + "B4.2", + "scratch0", + "scratch1" + ], + [ + "B4.4", + "scratch2", + "z" + ], + [ + "B4.3", + "scratch1", + "scratch2" + ], + [ + "B4.4", + "scratch2", + "z" + ], + [ + "B4.3", + "scratch1", + "scratch2" + ], + [ + "B4.2", + "scratch0", + "scratch1" + ], + [ + "A17.0", + "z", + "y17" + ], + [ + "A24.0", + "z", + "y24" + ], + [ + "A25.0", + "z", + "y25" + ], + [ + "A27.0", + "z", + "y27" + ], + [ + "A30.0", + "z", + "y30" + ], + [ + "B2.0", + "x2", + "scratch0" + ], + [ + "B2.1", + "scratch0", + "scratch1" + ], + [ + "B2.2", + "scratch1", + "z" + ], + [ + "B2.1", + "scratch0", + "scratch1" + ], + [ + "B2.2", + "scratch1", + "z" + ], + [ + "B2.0", + "x2", + "scratch0" + ], + [ + "B2.2", + "scratch1", + "z" + ], + [ + "B2.1", + "scratch0", + "scratch1" + ], + [ + "B2.2", + "scratch1", + "z" + ], + [ + "B2.1", + "scratch0", + "scratch1" + ], + [ + "A23.0", + "z", + "y23" + ], + [ + "A26.0", + "z", + "y26" + ], + [ + "A28.0", + "z", + "y28" + ], + [ + "A29.0", + "z", + "y29" + ], + [ + "B3.0", + "x3", + "scratch1" + ], + [ + "B3.1", + "scratch1", + "scratch0" + ], + [ + "B3.0", + "x3", + "scratch1" + ], + [ + "B3.1", + "scratch1", + "scratch0" + ], + [ + "B3.2", + "scratch0", + "scratch1" + ], + [ + "B3.3", + "scratch1", + "z" + ], + [ + "B3.2", + "scratch0", + "scratch1" + ], + [ + "B3.3", + "scratch1", + "z" + ], + [ + "B3.1", + "scratch1", + "scratch0" + ], + [ + "B3.0", + "x3", + "scratch1" + ], + [ + "B3.1", + "scratch1", + "scratch0" + ], + [ + "B3.0", + "x3", + "scratch1" + ], + [ + "B3.3", + "scratch1", + "z" + ], + [ + "B3.2", + "scratch0", + "scratch1" + ], + [ + "B3.3", + "scratch1", + "z" + ], + [ + "B3.2", + "scratch0", + "scratch1" + ], + [ + "A15.0", + "z", + "y15" + ], + [ + "A16.0", + "z", + "y16" + ], + [ + "A18.0", + "z", + "y18" + ], + [ + "A19.0", + "z", + "y19" + ], + [ + "A20.0", + "z", + "y20" + ], + [ + "A21.0", + "z", + "y21" + ], + [ + "A22.0", + "z", + "y22" + ], + [ + "B4.0", + "x4", + "scratch1" + ], + [ + "B4.1", + "scratch1", + "scratch0" + ], + [ + "B4.0", + "x4", + "scratch1" + ], + [ + "B4.1", + "scratch1", + "scratch0" + ], + [ + "B4.2", + "scratch0", + "scratch1" + ], + [ + "B4.3", + "scratch1", + "scratch2" + ], + [ + "B4.4", + "scratch2", + "z" + ], + [ + "B4.3", + "scratch1", + "scratch2" + ], + [ + "B4.4", + "scratch2", + "z" + ], + [ + "B4.2", + "scratch0", + "scratch1" + ], + [ + "B4.4", + "scratch2", + "z" + ], + [ + "B4.3", + "scratch1", + "scratch2" + ], + [ + "B4.4", + "scratch2", + "z" + ], + [ + "B4.3", + "scratch1", + "scratch2" + ], + [ + "B4.1", + "scratch1", + "scratch0" + ], + [ + "B4.0", + "x4", + "scratch1" + ], + [ + "B4.1", + "scratch1", + "scratch0" + ], + [ + "B4.0", + "x4", + "scratch1" + ], + [ + "B4.3", + "scratch1", + "scratch2" + ], + [ + "B4.4", + "scratch2", + "z" + ], + [ + "B4.3", + "scratch1", + "scratch2" + ], + [ + "B4.4", + "scratch2", + "z" + ], + [ + "B4.2", + "scratch0", + "scratch1" + ], + [ + "B4.4", + "scratch2", + "z" + ], + [ + "B4.3", + "scratch1", + "scratch2" + ], + [ + "B4.4", + "scratch2", + "z" + ], + [ + "B4.3", + "scratch1", + "scratch2" + ], + [ + "B4.2", + "scratch0", + "scratch1" + ] + ], + "leaf_calls": 200, + "borrowed_dirty_arrays": 4 + }, + "five_extra_output": { + "factor_lengths": { + "B": [ + 1, + 2, + 3, + 4, + 5 + ], + "A": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ] + }, + "factors": { + "B0": [ + "B0.0" + ], + "B1": [ + "B1.0", + "B1.1" + ], + "B2": [ + "B2.0", + "B2.1", + "B2.2" + ], + "B3": [ + "B3.0", + "B3.1", + "B3.2", + "B3.3" + ], + "B4": [ + "B4.0", + "B4.1", + "B4.2", + "B4.3", + "B4.4" + ], + "A0": [ + "A0.0" + ], + "A1": [ + "A1.0" + ], + "A2": [ + "A2.0" + ], + "A3": [ + "A3.0" + ], + "A4": [ + "A4.0" + ], + "A5": [ + "A5.0" + ], + "A6": [ + "A6.0" + ], + "A7": [ + "A7.0" + ], + "A8": [ + "A8.0" + ], + "A9": [ + "A9.0" + ], + "A10": [ + "A10.0" + ], + "A11": [ + "A11.0" + ], + "A12": [ + "A12.0" + ], + "A13": [ + "A13.0" + ], + "A14": [ + "A14.0" + ], + "A15": [ + "A15.0" + ], + "A16": [ + "A16.0" + ], + "A17": [ + "A17.0" + ], + "A18": [ + "A18.0" + ], + "A19": [ + "A19.0" + ], + "A20": [ + "A20.0" + ], + "A21": [ + "A21.0" + ], + "A22": [ + "A22.0" + ], + "A23": [ + "A23.0" + ], + "A24": [ + "A24.0" + ], + "A25": [ + "A25.0" + ], + "A26": [ + "A26.0" + ], + "A27": [ + "A27.0" + ], + "A28": [ + "A28.0" + ], + "A29": [ + "A29.0" + ], + "A30": [ + "A30.0" + ] + }, + "query_leaf_prices": { + "B0": 1, + "B1": 4, + "B2": 10, + "B3": 16, + "B4": 28, + "A0": 1, + "A1": 1, + "A2": 1, + "A3": 1, + "A4": 1, + "A5": 1, + "A6": 1, + "A7": 1, + "A8": 1, + "A9": 1, + "A10": 1, + "A11": 1, + "A12": 1, + "A13": 1, + "A14": 1, + "A15": 1, + "A16": 1, + "A17": 1, + "A18": 1, + "A19": 1, + "A20": 1, + "A21": 1, + "A22": 1, + "A23": 1, + "A24": 1, + "A25": 1, + "A26": 1, + "A27": 1, + "A28": 1, + "A29": 1, + "A30": 1 + }, + "leaf_word": [ + [ + "A0.0", + "z", + "y0" + ], + [ + "A2.0", + "z", + "y2" + ], + [ + "A5.0", + "z", + "y5" + ], + [ + "A6.0", + "z", + "y6" + ], + [ + "A11.0", + "z", + "y11" + ], + [ + "A13.0", + "z", + "y13" + ], + [ + "A15.0", + "z", + "y15" + ], + [ + "A20.0", + "z", + "y20" + ], + [ + "A23.0", + "z", + "y23" + ], + [ + "A27.0", + "z", + "y27" + ], + [ + "B0.0", + "x0", + "z" + ], + [ + "A0.0", + "z", + "y0" + ], + [ + "A1.0", + "z", + "y1" + ], + [ + "A12.0", + "z", + "y12" + ], + [ + "A14.0", + "z", + "y14" + ], + [ + "A16.0", + "z", + "y16" + ], + [ + "A20.0", + "z", + "y20" + ], + [ + "A24.0", + "z", + "y24" + ], + [ + "A28.0", + "z", + "y28" + ], + [ + "B1.0", + "x1", + "scratch0" + ], + [ + "B1.1", + "scratch0", + "z" + ], + [ + "B1.0", + "x1", + "scratch0" + ], + [ + "B1.1", + "scratch0", + "z" + ], + [ + "A1.0", + "z", + "y1" + ], + [ + "A2.0", + "z", + "y2" + ], + [ + "A3.0", + "z", + "y3" + ], + [ + "A4.0", + "z", + "y4" + ], + [ + "A18.0", + "z", + "y18" + ], + [ + "A26.0", + "z", + "y26" + ], + [ + "A30.0", + "z", + "y30" + ], + [ + "B2.0", + "x2", + "scratch0" + ], + [ + "B2.1", + "scratch0", + "scratch1" + ], + [ + "B2.2", + "scratch1", + "z" + ], + [ + "B2.1", + "scratch0", + "scratch1" + ], + [ + "B2.2", + "scratch1", + "z" + ], + [ + "B2.0", + "x2", + "scratch0" + ], + [ + "B2.2", + "scratch1", + "z" + ], + [ + "B2.1", + "scratch0", + "scratch1" + ], + [ + "B2.2", + "scratch1", + "z" + ], + [ + "B2.1", + "scratch0", + "scratch1" + ], + [ + "A3.0", + "z", + "y3" + ], + [ + "A6.0", + "z", + "y6" + ], + [ + "A8.0", + "z", + "y8" + ], + [ + "A10.0", + "z", + "y10" + ], + [ + "A22.0", + "z", + "y22" + ], + [ + "B0.0", + "x0", + "z" + ], + [ + "A4.0", + "z", + "y4" + ], + [ + "A5.0", + "z", + "y5" + ], + [ + "A7.0", + "z", + "y7" + ], + [ + "A9.0", + "z", + "y9" + ], + [ + "A21.0", + "z", + "y21" + ], + [ + "A25.0", + "z", + "y25" + ], + [ + "A29.0", + "z", + "y29" + ], + [ + "B3.0", + "x3", + "scratch1" + ], + [ + "B3.1", + "scratch1", + "scratch0" + ], + [ + "B3.0", + "x3", + "scratch1" + ], + [ + "B3.1", + "scratch1", + "scratch0" + ], + [ + "B3.2", + "scratch0", + "scratch1" + ], + [ + "B3.3", + "scratch1", + "z" + ], + [ + "B3.2", + "scratch0", + "scratch1" + ], + [ + "B3.3", + "scratch1", + "z" + ], + [ + "B3.1", + "scratch1", + "scratch0" + ], + [ + "B3.0", + "x3", + "scratch1" + ], + [ + "B3.1", + "scratch1", + "scratch0" + ], + [ + "B3.0", + "x3", + "scratch1" + ], + [ + "B3.3", + "scratch1", + "z" + ], + [ + "B3.2", + "scratch0", + "scratch1" + ], + [ + "B3.3", + "scratch1", + "z" + ], + [ + "B3.2", + "scratch0", + "scratch1" + ], + [ + "A7.0", + "z", + "y7" + ], + [ + "A8.0", + "z", + "y8" + ], + [ + "A13.0", + "z", + "y13" + ], + [ + "A14.0", + "z", + "y14" + ], + [ + "A17.0", + "z", + "y17" + ], + [ + "B1.0", + "x1", + "scratch0" + ], + [ + "B1.1", + "scratch0", + "z" + ], + [ + "B1.0", + "x1", + "scratch0" + ], + [ + "B1.1", + "scratch0", + "z" + ], + [ + "A9.0", + "z", + "y9" + ], + [ + "A10.0", + "z", + "y10" + ], + [ + "A11.0", + "z", + "y11" + ], + [ + "A12.0", + "z", + "y12" + ], + [ + "A19.0", + "z", + "y19" + ], + [ + "A20.0", + "z", + "y20" + ], + [ + "B4.0", + "x4", + "scratch1" + ], + [ + "B4.1", + "scratch1", + "scratch0" + ], + [ + "B4.0", + "x4", + "scratch1" + ], + [ + "B4.1", + "scratch1", + "scratch0" + ], + [ + "B4.2", + "scratch0", + "scratch1" + ], + [ + "B4.3", + "scratch1", + "scratch2" + ], + [ + "B4.4", + "scratch2", + "z" + ], + [ + "B4.3", + "scratch1", + "scratch2" + ], + [ + "B4.4", + "scratch2", + "z" + ], + [ + "B4.2", + "scratch0", + "scratch1" + ], + [ + "B4.4", + "scratch2", + "z" + ], + [ + "B4.3", + "scratch1", + "scratch2" + ], + [ + "B4.4", + "scratch2", + "z" + ], + [ + "B4.3", + "scratch1", + "scratch2" + ], + [ + "B4.1", + "scratch1", + "scratch0" + ], + [ + "B4.0", + "x4", + "scratch1" + ], + [ + "B4.1", + "scratch1", + "scratch0" + ], + [ + "B4.0", + "x4", + "scratch1" + ], + [ + "B4.3", + "scratch1", + "scratch2" + ], + [ + "B4.4", + "scratch2", + "z" + ], + [ + "B4.3", + "scratch1", + "scratch2" + ], + [ + "B4.4", + "scratch2", + "z" + ], + [ + "B4.2", + "scratch0", + "scratch1" + ], + [ + "B4.4", + "scratch2", + "z" + ], + [ + "B4.3", + "scratch1", + "scratch2" + ], + [ + "B4.4", + "scratch2", + "z" + ], + [ + "B4.3", + "scratch1", + "scratch2" + ], + [ + "B4.2", + "scratch0", + "scratch1" + ], + [ + "A17.0", + "z", + "y17" + ], + [ + "A25.0", + "z", + "y25" + ], + [ + "A27.0", + "z", + "y27" + ], + [ + "A28.0", + "z", + "y28" + ], + [ + "A30.0", + "z", + "y30" + ], + [ + "B2.0", + "x2", + "scratch0" + ], + [ + "B2.1", + "scratch0", + "scratch1" + ], + [ + "B2.2", + "scratch1", + "z" + ], + [ + "B2.1", + "scratch0", + "scratch1" + ], + [ + "B2.2", + "scratch1", + "z" + ], + [ + "B2.0", + "x2", + "scratch0" + ], + [ + "B2.2", + "scratch1", + "z" + ], + [ + "B2.1", + "scratch0", + "scratch1" + ], + [ + "B2.2", + "scratch1", + "z" + ], + [ + "B2.1", + "scratch0", + "scratch1" + ], + [ + "A19.0", + "z", + "y19" + ], + [ + "A20.0", + "z", + "y20" + ], + [ + "A23.0", + "z", + "y23" + ], + [ + "A24.0", + "z", + "y24" + ], + [ + "A26.0", + "z", + "y26" + ], + [ + "A29.0", + "z", + "y29" + ], + [ + "B3.0", + "x3", + "scratch1" + ], + [ + "B3.1", + "scratch1", + "scratch0" + ], + [ + "B3.0", + "x3", + "scratch1" + ], + [ + "B3.1", + "scratch1", + "scratch0" + ], + [ + "B3.2", + "scratch0", + "scratch1" + ], + [ + "B3.3", + "scratch1", + "z" + ], + [ + "B3.2", + "scratch0", + "scratch1" + ], + [ + "B3.3", + "scratch1", + "z" + ], + [ + "B3.1", + "scratch1", + "scratch0" + ], + [ + "B3.0", + "x3", + "scratch1" + ], + [ + "B3.1", + "scratch1", + "scratch0" + ], + [ + "B3.0", + "x3", + "scratch1" + ], + [ + "B3.3", + "scratch1", + "z" + ], + [ + "B3.2", + "scratch0", + "scratch1" + ], + [ + "B3.3", + "scratch1", + "z" + ], + [ + "B3.2", + "scratch0", + "scratch1" + ], + [ + "A15.0", + "z", + "y15" + ], + [ + "A16.0", + "z", + "y16" + ], + [ + "A18.0", + "z", + "y18" + ], + [ + "A21.0", + "z", + "y21" + ], + [ + "A22.0", + "z", + "y22" + ], + [ + "B4.0", + "x4", + "scratch1" + ], + [ + "B4.1", + "scratch1", + "scratch0" + ], + [ + "B4.0", + "x4", + "scratch1" + ], + [ + "B4.1", + "scratch1", + "scratch0" + ], + [ + "B4.2", + "scratch0", + "scratch1" + ], + [ + "B4.3", + "scratch1", + "scratch2" + ], + [ + "B4.4", + "scratch2", + "z" + ], + [ + "B4.3", + "scratch1", + "scratch2" + ], + [ + "B4.4", + "scratch2", + "z" + ], + [ + "B4.2", + "scratch0", + "scratch1" + ], + [ + "B4.4", + "scratch2", + "z" + ], + [ + "B4.3", + "scratch1", + "scratch2" + ], + [ + "B4.4", + "scratch2", + "z" + ], + [ + "B4.3", + "scratch1", + "scratch2" + ], + [ + "B4.1", + "scratch1", + "scratch0" + ], + [ + "B4.0", + "x4", + "scratch1" + ], + [ + "B4.1", + "scratch1", + "scratch0" + ], + [ + "B4.0", + "x4", + "scratch1" + ], + [ + "B4.3", + "scratch1", + "scratch2" + ], + [ + "B4.4", + "scratch2", + "z" + ], + [ + "B4.3", + "scratch1", + "scratch2" + ], + [ + "B4.4", + "scratch2", + "z" + ], + [ + "B4.2", + "scratch0", + "scratch1" + ], + [ + "B4.4", + "scratch2", + "z" + ], + [ + "B4.3", + "scratch1", + "scratch2" + ], + [ + "B4.4", + "scratch2", + "z" + ], + [ + "B4.3", + "scratch1", + "scratch2" + ], + [ + "B4.2", + "scratch0", + "scratch1" + ] + ], + "leaf_calls": 182, + "borrowed_dirty_arrays": 4 + } + }, + "five_source_comparators": { + "column_stars": 170, + "row_stars": 222 + }, + "scope": "Exact binary query model; no new kappa or supplier integration" +} diff --git a/research/universal-connector-boundary/CLAIM.md b/research/universal-connector-boundary/CLAIM.md new file mode 100644 index 0000000000..2937c22686 --- /dev/null +++ b/research/universal-connector-boundary/CLAIM.md @@ -0,0 +1,69 @@ +# Local sprint claim + +- Track: recursive interfaces. OS-random assignment seed: **52** (`secrets.randbelow(100)`). +- Exact base: `91a2094f2e022930069e8cfdc810a3ea1b81cd09`. +- Start: 2026-10-14 00:26 AEDT; intended finish: 01:11 AEDT (45 minutes). + Final 12 minutes reserved for verification and handoff. +- Object: one arbitrary dirty binary connector, fixed linear source maps B_j + and output maps A_i, with complete additive oracle calls. Determine whether + a single source-toggle schedule with two calls per source can support every + binary row pattern, then price a complete five-source boundary witness. +- Method: subset-difference characterization of paired output readouts; + explicit universal four-source word; exhaustive canonical pairings for five + source labels, with an independently implemented census and literal algebra + replay. Seed 52 selects the four/five-source boundary via 4 + (52 mod 2). +- Deliverable: scoped construction/negative result, exact certificate, full + recursive cost/storage accounting, source pins and mutation controls. No + claim of new kappa or selected-supplier integration. + +## Selection and overlap + +Three candidates were compared: (1) weighted dirty-echo tree scheduling, +(2) native dyadic query-pair fusion, (3) universal one-connector source paths. +The first is covered by #730/#758/#822; the second by #840. The third changes +#934's finite three-by-three target search into a source-path condition valid +for arbitrarily many output rows, and tests its first failure boundary. +This is not a rerun with a different seed or a claim of priority for dirty +commutators, common-factor fanout or carried connectors. + +At assignment, all 724 open PRs were inventoried through #934. Targeted all-state +search covered connector/circle/interlacement/wheel. #889 supplies the direct +fanout predecessor; #934 supplies the exact binary query contract and support +lower bound. #929 concerns grouped rational cyclic inverses, not this binary +source-path condition. The review ledger, selected review/construction and +prior stage-count negative records were inspected; newer research PRs are +outside the ledger's frozen review inventory. + +No pinned issue exists (GitHub pinnedIssues query returned an empty list), and +the only open issues are #913 and #650. Therefore this claim is local, as +requested. All delegated work is confined to this source-path boundary. + +## Completed result (single claim update) + +The universal four-source path is proved by complementary two-bit subspaces. +The two complete five-source censuses agree on all 945 canonical pairings: +maximum 31/32 masks, with no full-coverage ten-call path. Two explicit repairs +attain the exact 74-query minimum for the all-31-nonzero-row batch. One repair +lowers to 182 complete primitive factor calls versus 278 for column stars, +with four borrowed dirty arrays in both cases. No new kappa is claimed. + +Result, exact certificate, command and validation: +[review package](https://github.com/RossRichardson/integer-mult-bounds/tree/research/universal-connector-boundary-seed52/research/universal-connector-boundary). +The focused PR is submitted from that branch to CrocSwap/main; no merge is +requested. README.md contains the mathematical statement and complete cost +recurrence; VALIDATION.md records coverage and remaining obligations. + +Final submission base is `47481c89fd30a43f8f882eb4b391e89c29273fd0`, refreshed +after main incorporated PR890. Its actual selected certificate/construction/ +review were read, and selected-record checks pass. This refresh changes no +contribution files outside this package. PR934's pinned head is unchanged. +The full final queue inventory reached #939, followed by an immediate check +through #941. Concurrent #938's one-source minimizer census is credited and +distinct; #940's Fourier-layout audit and #941's R439 matching improvement do +not overlap. A second pinned-issue query was also empty. + +The final verification/handoff phase followed the completed constructions; +normal/optimized checks, standalone relocation, exact regeneration, six +package corruptions, the selected-record gate and its five tests pass. Only +one contribution and one PR are submitted; supplier realization and all-size +analytic obligations remain open. diff --git a/research/universal-connector-boundary/EXPECTED.json b/research/universal-connector-boundary/EXPECTED.json new file mode 100644 index 0000000000..c0f2eef36c --- /dev/null +++ b/research/universal-connector-boundary/EXPECTED.json @@ -0,0 +1,88 @@ +{ + "censuses": [ + { + "max_coverage": 16, + "pairings": 105, + "sources": 4 + }, + { + "max_coverage": 31, + "pairings": 945, + "sources": 5 + } + ], + "dense": { + "dimensions": [ + 1, + 2, + 3 + ], + "negative_controls_detected": [ + "omitted_final_source", + "wrong_output_destination", + "wrong_target_row" + ], + "schedules": { + "five_extra_output": { + "basis_states": 222, + "forward_cases": 297, + "inverse_cases": 297, + "map_banks": 3, + "mixed_dirty_states": 75, + "noncommuting_banks": 2, + "nonsymmetric_banks": 2 + }, + "five_extra_source": { + "basis_states": 222, + "forward_cases": 297, + "inverse_cases": 297, + "map_banks": 3, + "mixed_dirty_states": 75, + "noncommuting_banks": 2, + "nonsymmetric_banks": 2 + }, + "four_all": { + "basis_states": 120, + "forward_cases": 195, + "inverse_cases": 195, + "map_banks": 3, + "mixed_dirty_states": 75, + "noncommuting_banks": 2, + "nonsymmetric_banks": 2 + } + }, + "seed": 52 + }, + "leaf_calls": { + "five_extra_output": 182, + "five_extra_source": 200 + }, + "pinned_reference_files": 2, + "queries": { + "five_extra_output": 74, + "five_extra_source": 74, + "four_all": 38 + }, + "root_controls": [ + "omitted_final_source", + "readout_crosses_source_toggle", + "unpaid_missing_row_readout", + "wrong_target_pattern", + "underpriced_scratch", + "unpaid_recursive_child", + "aliased_child_ports", + "wrong_factor_order" + ], + "scalar_leaf_baseline": 180, + "star_comparators": { + "column_stars": { + "leaf_calls": 278, + "queries": 170 + }, + "row_stars": { + "leaf_calls": 1950, + "queries": 222 + } + }, + "unit_lower_bound": 74 +} diff --git a/research/universal-connector-boundary/LICENSE b/research/universal-connector-boundary/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/universal-connector-boundary/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/universal-connector-boundary/NOTICE.md b/research/universal-connector-boundary/NOTICE.md new file mode 100644 index 0000000000..d9afdf81f6 --- /dev/null +++ b/research/universal-connector-boundary/NOTICE.md @@ -0,0 +1,37 @@ +# Attribution and license + +Contribution by **Ross Richardson (@RossRichardson)** with substantial +**OpenAI Codex assistance** in the mathematical argument, implementation, +independent computational checks and writing. New work is Apache-2.0, under +the repository LICENSE. No independent human peer review is asserted. + +The direct predecessor is Ross Richardson's PR934, +`f3100aec6ce6a7b061987875d5e9a8b93801ac0b`: carried binary connectors, the exact +query contract, support lower bound and balanced dirty recursive lowering. +Its README and NOTICE are retained byte-for-byte in references/ with Git blob +and SHA256 pins in SOURCES.json. No predecessor executable is imported. +This contribution adds the universal-source-path reduction, the explicit +four-source construction for arbitrary output count, and the complete first +five-source obstruction/repair. It does not claim priority for carried +connectors or dirty commutators. + +PR889 at `e2021d1c9e06948528cbc0a8fd7079b671da981d` is the common-factor fanout +predecessor, authored by @shhxera (the pinned PR934 notice uses that handle; +the live GitHub author lookup during this sprint returned @CubeJerry). +Chafik Boukhalfa (@chafreaky), PR628 at +`0768f97d06c623b8211e651543c66135796b62bf`, supplies the dirty-product commutator +lineage. The retained PR934 notice credits additional related work. +PR730/#758/#822 concern tree/connector scratch schedules and #840 native +dyadic query fusion; their mechanisms and costs are not combined here. +PR929 at `85a1d11adbbd7610d269cfeb3e477cf7d457f2eb` groups rational cyclic +inverse factors and has a distinct contract. No claim of a general reversible +circuit optimum or literature priority is made. + +Concurrent PR938 by Ross Richardson, inspected at +`df645942469e6a739ec94010a6068c398f4a6c86`, independently counts every minimum +one-source dirty-fanout word. That equality-case evidence and this multi-source +universal-path boundary are distinct; neither consumes the other's code. + +The accepted frontier retains Jeremy Kothe, Chafik Boukhalfa, Hao Yan, DreamingOfClouds, +eumemic, Douglas Colkitt and the cumulative community's attribution. Their +selected construction and inherited analytic framework remain unchanged. diff --git a/research/universal-connector-boundary/README.md b/research/universal-connector-boundary/README.md new file mode 100644 index 0000000000..d277f7c583 --- /dev/null +++ b/research/universal-connector-boundary/README.md @@ -0,0 +1,235 @@ +# Sharp four/five-source boundary for universal dirty connectors + +**Recursive-interface construction and exact finite exclusion; no new kappa.** +One fixed source-toggle path supports every binary output pattern on at most +four sources, using each active source and output operator exactly twice. +For five sources, no ten-toggle path has that property: an exhaustive, +independently implemented census of all **945** canonical pairings has maximum +coverage **31 of 32** masks. An explicit twelve-toggle path covers all 32. + +Consequently the batch with five sources and one output for each of the 31 +nonzero masks has exact optimum **74 complete queries** in the model below. +The support bound of 72 is unattainable; parity rules out 73. This adds a +universal source-path criterion and its first failure boundary to +[PR934's three-by-three result](references/PR934-README.md), rather than +repeating its target-by-target search. + +```sh +python3 -I -O -B research/universal-connector-boundary/verify.py +``` + +Expected: +`PASS_UNIVERSAL_CONNECTOR_BOUNDARY pairings=945 max_coverage=31 queries=74 leaves=182`. +Python 3.10+ and the standard library suffice. [CERTIFICATE.json](CERTIFICATE.json) +contains all three literal query words and both recursive leaf expansions. +[EXPECTED.json](EXPECTED.json) records exact verification coverage. + +## Exact interface + +Let x_j, y_i and z be distinct length-L arrays over F2, all arbitrarily dirty. +The fixed maps B_j and A_i are exact F2-linear maps of compatible dimension; +they need not commute or be invertible. Sources and coefficients are read-only. +The requested operation is + + y_i += sum_j M_ij A_i B_j x_j; x_j and z unchanged. + +Only complete calls `B_j: z += B_j x_j` and `A_i: y_i += A_i z` are allowed. +The straight-line query word may depend on M, but not on the data contents. +Each call preserves other rows, restores all private scratch and returns its +tape heads to the agreed entry positions. Its behavior is independent of the +old target contents. All data rows and z are excluded from child scratch. +Targets cannot be observed until the batch completes. There are no free +copies, combined queries, extra root connectors, changes of frame or role, +overwrites, direct A_i B_j calls, or other data operations in this alphabet. + +Bounds concern a schedule correct for arbitrary admissible operators and +inputs. Specialized zero maps, operator relations or restricted inputs may be +cheaper. The construction is characteristic-two and linear; a nonlinear +readout or ordinary addition in odd characteristic does not inherit it. + +## Paired readouts are differences of source prefixes + +Project a full query word onto its B calls. Let q_t be the subset of source +labels occurring an odd number of times in the first t calls; q_0=0. At that +boundary, + + z = z_initial + sum_j (q_t)_j B_j x_j. + +Two calls to A_i at boundaries s,t cancel A_i z_initial and contribute exactly +the row q_s XOR q_t. Thus the available row masks are + + D(w) = {q_s XOR q_t : s,t are boundaries of the source word w}. + +This condition is sufficient for any number of output rows: place each pair +at its chosen boundaries. Different A_i calls commute because their targets +are distinct and they do not change z. Repeated masks are harmless. The source +path is fixed; the positions of output readouts depend on the requested M. + +It is also necessary when each A_i occurs twice. One may specialize to L=1 +and all A_i=B_j=identity, with independent source and dirty bits. This proves +the mask condition without assumptions of operator independence. The same +specialization forces every B_j count even to restore z, and every A_i count +even to remove connector dirt. Active rows/columns therefore require at least +two calls each. All valid generic schedules have even total length. + +## Universal four-source construction + +The source word + + B0 B1 B0 B1 B2 B3 B2 B3 + +has prefixes `0,1,3,2,0,4,12,8,0`. Its prefix set contains the full two-bit +subspace on coordinates 0,1 and the full two-bit subspace on coordinates 2,3. +Every four-bit mask is the XOR of one point in each subspace. Hence D(w)=F2^4. +This is an all-size argument about the output count, not a census of four-by- +four matrices. Nonzero rows need two distinct boundary values; zero rows need +no calls. Delete inactive B labels to project the same construction onto fewer +active sources. Therefore every matrix with at most four active columns +attains the lower bound `2*(active rows + active columns)`, also for arbitrary +positive fixed complete prices on those operators. + +The certificate's simultaneous all-15-nonzero-row instance uses 38 queries. + +## Exact five-source boundary and repair + +Any ten-call restored path using all five sources contains each label twice. +Rename labels by first occurrence. The resulting words correspond bijectively +to perfect matchings of ten positions, of which there are `9*7*5*3*1 = 945`. +Renaming permutes coordinates and cannot change full-mask coverage. + +The generator recursively emits restricted-growth words. The independent +checker instead pairs the least unmatched endpoint with each possible partner +and labels a matching only after completion. This exhausts every matching once +by induction on the remaining endpoints. Both implementations compute the +complete coverage set and agree on its sorted-record SHA256 and histogram: + +| Size of D(w) | 16 | 19 | 21 | 22 | 23 | 24 | 26 | 28 | 31 | +|---|---:|---:|---:|---:|---:|---:|---:|---:|---:| +| Canonical paths | 42 | 120 | 180 | 56 | 45 | 220 | 110 | 150 | 22 | + +None covers 32 masks. This is a complete computational exclusion of this +finite class, with an explicit reduction from the query model. It is not a +proof-assistant theorem or an impossibility result for other circuit models. + +The word `B0 B1 B2 B0 B3 B1 B4 B2 B3 B4` covers every mask except 21 (10101). +There are two complete repairs in the certificate: + +1. **Repeat a source twice more.** The fixed word + `B2 B0 B2 B1 B2 B0 B3 B1 B4 B2 B3 B4` covers all 32 masks. Each output is + read twice; B2 is called four times, the other sources twice. Twelve is the + minimum source-call count for a fixed universal five-source path with paired + readouts: ten is excluded, and restoration permits only even counts. +2. **Read the missing output twice more.** Keep the ten-call path and give mask + 21 four readouts. Since only 21 is missing, choose achieved nonzero a and + b=a XOR 21; b is achieved too. Their two pairs of prefix values cannot share + a value, or 21 itself would be a two-prefix difference. The four readouts + therefore realize 21 while cancelling dirt. All other rows use two. + +For the explicit matrix with rows 1,...,31, both repairs use 74 queries. Any +72-query schedule would use every operator exactly twice, contradicting the +945-path exclusion; odd 73 is impossible. This proves the claimed unit-cost +optimum within the stated alphabet. It does not assert that every five-column +matrix needs 74 calls, or that every subset of output masks needs a surcharge. + +## Complete cost recurrence + +Let c_F(L) be the complete cost of an additive call and its inverse at fixed +ports, including coefficient/source access, arithmetic, target updates, +private scratch restoration, head returns, and required entry/exit frames. +Take the larger orientation cost if necessary. Let P_F pay reusable coefficient +preparation once, I pay input admission/initial layout, and D pay root instruction +storage, reads and dispatch. For the all-31-output matrix define + + C_base = I + sum_F P_F + D + 2 sum_j c_Bj + 2 sum_i c_Ai. + C_extra_source <= C_base + 2 c_B2. + C_extra_output <= C_base + 2 c_A20. (Output index 20 has mask 21.) + +The displayed B word can be relabeled to repeat any desired B_j. These are +priced constructions, not a general weighted optimum. D must be evaluated +for the actual word; both have 74 root calls. No frame change or copy is +required by this interface. A caller needing conversions must add their cost. +For arbitrary output count, admit the explicit M by scanning its entries and +use the fixed, at-most-32-mask boundary lookup to place each output's readouts. +Charge that scan, program construction and its O(log(output count))-bit role +indices in I and D; output-dependent scheduling is not a free oracle. + +For F composed of d factors in application order, use a balanced contiguous +split F=L R and a distinct dirty connector w. Execute R(source,w), L(w,target), +reverse(R), reverse(L), including every leaf in each inverse. Then + + C([f]) = complete leaf cost including dispatch; + C(F) <= 2 C(R) + 2 C(L) + paid node dispatch; + ell(1)=1; ell(d)=2 ell(floor(d/2))+2 ell(ceil(d/2)); + h(1)=0; h(d)=1+max(h(floor(d/2)),h(ceil(d/2)))=ceil(log2 d). + +The batch requires `1+max_F h(d_F)` full borrowed dirty rows, plus any private +leaf scratch. The initial 1 is z. Siblings reuse scratch only after restoration. +The inverse duplicates calls, not peak storage. All 36 source/output rows stay +reserved in the five-source example. No clean full-length row is assumed. + +The literal fixture sets the five B factor lengths to 1,2,3,4,5 (leaf prices +1,4,10,16,28), and all 31 A lengths to 1. It uses four borrowed dirty rows and +46 distinct primitive operators. Free noncommutative replay checks the entire +182- and 200-leaf programs, arbitrary scratch, factor order and inverse. + +| Complete schedule | Root queries | Primitive leaf calls | Borrowed dirty rows | +|---|---:|---:|---:| +| Separate column stars | 170 | 278 | 4 | +| Separate row stars | 222 | 1950 | 4 | +| Universal twelve-source-call path | 74 | 200 | 4 | +| Ten-source-call path, one four-readout output | 74 | 182 | 4 | + +Both star comparators are literally replayed and priced with the same factors. +This comparison excludes changing the product factorization, specialized maps, +and other echo architectures. Leaf counts do not include a claim of physical +runtime or a faster selected supplier. + +For a concrete, deliberately slow implementation of every primitive, supply +46 dense L-by-L bit matrices and 40 mutable L-bit rows on one data tape, with +separately charged instruction/control storage. The data +region has S=40L+46L^2 cells. To update one target entry, visit each coefficient +and source bit, accumulate its dot product in a clean scalar bit, XOR the +target, then repeat the dot-product accumulation to restore that scalar to +zero. Admit and initialize O(1) clean scalar work bits in I; no clean full row +is needed. Return to the origin after each complete leaf. Per leaf this pays +2L^2 coefficient reads, 2L^2 source reads, L target reads/writes, 2L^2 ANDs and +2L^2+L XORs; head travel is at most S*(4L^2+L+1), with an additive O(1) scalar +work area and constant-factor bit-gate bookkeeping. Pay scalar initialization, +loop/index arithmetic and an instruction tape with one operator/source/target +record per leaf and O(log L) counters. Charge initial matrix/input validation +and any external matrix preparation in I and P. Scratch rows are part of the +40 rows and remain arbitrary. This is an explicit complete implementation +bound, not a measured tape trace or a subquadratic dense-matrix claim. The +displayed counters are arithmetic/data-access macro counts; temporary-bit +loading/unloading, control and instruction work are additional. A loose complete +per-leaf bound is O((S*(4L^2+L+1)+L^2)*log(L+2)) plus instruction-record access. + +## Verification, provenance and remaining obligations + +The two enumeration methods agree on all 105 four-source and 945 five-source +canonical paths. Independent dense replay checks all basis inputs and mixed +dirty states at L=1,2,3 for nine schedule/bank combinations (six distinct banks, +with the same banks shared by the two five-source repairs), including nonsymmetric and +noncommuting maps: 789 forward and 789 inverse cases. This is finite matrix +evidence; the general linear identity is the prefix argument above. Eleven +mutation controls address restoration, readout order/destination, target masks, +scratch, unpaid children, aliased ports and factor order. Package checks add +relocation, deterministic regeneration and on-disk corruption rejection. + +Discovery base: `91a2094f2e022930069e8cfdc810a3ea1b81cd09`. The accepted conditional +frontier at that base was 1661634653669567/10^18, #799 with #589/#555. Before +submission, main advanced to `47481c89fd30a43f8f882eb4b391e89c29273fd0`, selecting +PR890 at 1661957774647029/10^18. Its selected certificate, T21 construction and +maintainer review were inspected; this branch was fast-forwarded to that +submission base before final checks. Both contexts are pinned separately. +Concurrent PR938 counts minimum one-source fanout words; it does not supply +this multi-source universal-path boundary. No selected +certificate, supplier, review ledger, shared generator or upstream file changes. + +No instance of this abstract multi-output interface is claimed inside the +selected supplier. Common-label/mutable-source realization, frames and owner +admission, full-row charging, compiler/tape integration, precision and outer +analytic assumptions remain uninstantiated. In particular, this result cannot +establish which supplier binds after integration or a new kappa. See +[SOURCES.json](SOURCES.json), [CLAIM.md](CLAIM.md), [NOTICE.md](NOTICE.md) and +[VALIDATION.md](VALIDATION.md) for exact provenance, scope and handoff. diff --git a/research/universal-connector-boundary/SOURCES.json b/research/universal-connector-boundary/SOURCES.json new file mode 100644 index 0000000000..d0a857c1d9 --- /dev/null +++ b/research/universal-connector-boundary/SOURCES.json @@ -0,0 +1,38 @@ +{ + "base": "91a2094f2e022930069e8cfdc810a3ea1b81cd09", + "references": [ + { + "pr": 934, + "head": "f3100aec6ce6a7b061987875d5e9a8b93801ac0b", + "source_path": "research/binary-connector-walk/README.md", + "local_path": "references/PR934-README.md", + "git_blob": "7158c8c1f9d64506cb2a52ca047f947e544e0ae6", + "sha256": "d187dc94bf631bd5b6da2cc1019a2d1ba687b624fdaf32aae05dffc67872509d" + }, + { + "pr": 934, + "head": "f3100aec6ce6a7b061987875d5e9a8b93801ac0b", + "source_path": "research/binary-connector-walk/NOTICE.md", + "local_path": "references/PR934-NOTICE.md", + "git_blob": "22bc8648ac14639249923aa328603877aaceaf1a", + "sha256": "2b085e535c310847dd489ca60e5d12277bdb601aa1af3c731f36eb0275184528" + } + ], + "context": { + "certificates/selected-result.json": "41fb066ff0f43ce472323195e9088d6d888715c13c54eae7b42e357ed5bfc726", + "docs/research/current-status.md": "bc18a48072b15aa66b036df5901c0c209478458a39a650f1b514762ace3088ad", + "docs/research/community-frontier799-review.md": "bd91c10c67f2a873fd456b95cbb43f715a43dac0e0a66938737d591c6b754052", + "research/gauge44-frames-x/PROOF-NOTE-FRAMES-X4.md": "39c50420ebb6e8813706a49b2cf759f277c4afac9f6780fc0a7ac6a5fb86e036", + "docs/research/pr-ledger.md": "24d1b69d88b1975e32a3aebc08bba4970ca9c2f5b3e027889aee3a30188108bc", + "docs/research/community-frontier890-review.md": "cd03b7c2c6c09db2cfa89ae40133ae44e1deb6e32ec5ddd23aacecc9c50f2fea", + "research/complex-t21-owners/PROOF.md": "78721b32fceb34b21b8e77c95381c38c60276e72e6d9c2e9c6262cb347457def" + }, + "discovery_context": { + "certificates/selected-result.json": "9873519224e2db72d6a8c926f51e3e75129671e467948c6f6b03744f8bcfc699", + "docs/research/current-status.md": "415f85180f698329bea968798f2bc2519f56374cccc3e07c8e9051bd65192730", + "docs/research/community-frontier799-review.md": "bd91c10c67f2a873fd456b95cbb43f715a43dac0e0a66938737d591c6b754052", + "research/gauge44-frames-x/PROOF-NOTE-FRAMES-X4.md": "39c50420ebb6e8813706a49b2cf759f277c4afac9f6780fc0a7ac6a5fb86e036", + "docs/research/pr-ledger.md": "d8169a360cd6e5842b47008362c7cce0ffcdd62733a8e8210ef6a8ff32bb65c9" + }, + "submission_base": "47481c89fd30a43f8f882eb4b391e89c29273fd0" +} diff --git a/research/universal-connector-boundary/VALIDATION.md b/research/universal-connector-boundary/VALIDATION.md new file mode 100644 index 0000000000..95dc97993d --- /dev/null +++ b/research/universal-connector-boundary/VALIDATION.md @@ -0,0 +1,101 @@ +# Verification and handoff + +Verified on macOS arm64, CPython 3.14.6. This is a standalone research package; +only `research/universal-connector-boundary/` is added. Discovery base was +`91a2094f2e022930069e8cfdc810a3ea1b81cd09`; final checks use refreshed main +`47481c89fd30a43f8f882eb4b391e89c29273fd0`. The certificate retains the original +discovery base, and SOURCES.json separates original and submission contexts. + +## Reproduction + +From the repository root: + +```sh +python3 -I -O -B research/universal-connector-boundary/verify.py +python3 -I -O -B research/universal-connector-boundary/test_package.py +``` + +Expected: + +```text +PASS_UNIVERSAL_CONNECTOR_BOUNDARY pairings=945 max_coverage=31 queries=74 leaves=182 +PASS_UNIVERSAL_CONNECTOR_PACKAGE relocation=1 regeneration=2 corruptions=6 +``` + +Normal and optimized verification agree. Proof-relevant conditions use explicit +exceptions, so `-O` does not erase the checks. The verifier imports no generator +code. Its free noncommutative interpreter checks literal words, every initial +data/scratch symbol, expected products and inverses. The separate endpoint- +matching census uses a different combinatorial representation from the generator. + +## Completed coverage and stopping rule + +- Generator: restricted-growth words with each source label occurring twice. + Independent checker: all perfect matchings of 2n labelled endpoints, followed + by canonical source naming. Both exhaust 105 objects at n=4 and 945 at n=5, + stop only when enumeration ends, and agree on every canonical word/coverage + pair through a SHA256 of the sorted exact records and the coverage histogram. +- Four-source universality is also proved directly using two complementary + two-dimensional subspaces. The five-source maximum of 31 is an exact finite + exclusion, not a sampled failure to find a path. No claim is made about + arbitrary reversible programs or general multiplication lower bounds. +- Literal construction: all 15 nonzero four-source rows and all 31 nonzero + five-source rows, the two 74-query repairs, and the complete 182-/200-leaf + expansions. Both ordinary star comparators pass symbolic maps/inverses and + have independently recounted bills, including 278/1950 primitive calls. +- Dense replay: all basis initial bits and 25 distinct mixed states for each + schedule at L=1,2,3. There are 564 basis cases and 225 mixed cases: 789 forward + and 789 inverse checks. Both five-source schedules deliberately share their + matrix banks; there are six distinct banks across nine schedule/bank + combinations, with noncommuting/nonsymmetric witnesses at L>=2. +- Eight symbolic/accounting controls reject omitted restoration, a readout + crossing a source toggle, an unpaid missing-mask readout, a wrong target, + underpriced scratch/child, aliased ports and swapped factor order. Three dense + controls reject restoration, destination and target faults independently. +- A relocated copy in a path containing spaces passes without the repository + or network. Regenerating both certificate and evidence preserves every byte. + Six on-disk corruptions fail with their expected diagnostics: false coverage, + omitted census, missing connector restoration, unpaid child, false evidence, + and changed retained predecessor bytes. The restored package passes again. + +Seed 52 is the OS assignment draw and selects the four/five-source boundary +and the repeated-source label `52 mod 5 = 2`. It also fixes the finite dense +fixtures. The census is exhaustive, not random; its stopping rule and coverage +do not depend on the seed. Optional exploratory checks at n=1,2,3,6 did not +produce any additional contribution or claimed exclusion here. + +## Provenance and repository gates + +Both retained PR934 files match their exact remote Git blobs and local SHA256 +pins. Original context hashes were checked against Git objects at the discovery +base; refreshed context hashes were checked against the submission base. +PR934's head was still `f3100aec6ce6a7b061987875d5e9a8b93801ac0b` at refresh. + +`make selected-record-check` and all five tests in +`python3 -B tests/test_selected_result.py` pass on both bases. Python source +syntax and staged whitespace checks pass. The refreshed selected record is +PR890's conditional 1661957774647029/10^18; its T21 construction and maintainer +review were read. The selected files and `upstream/` have no contribution diff. + +The final full open-PR inventory covered 710 PRs through #939. New #938 counts +one-source dirty-fanout equality cases and is credited; it does not duplicate +the multi-source universal source-path criterion or its five-source boundary. +The immediate prepublication refresh also inspected #940's Fourier-layout +audit and #941's R439 matching construction; neither overlaps this scope. +No pinned sprint issue existed at the initial or final query. The claim and +result link are local in CLAIM.md. + +## Limits + +Repository-wide regeneration, selected-supplier cold replay, hosted CI and +proof-assistant formalization were not run. This addition changes no existing +supplier, selected construction or shared generator; its exact standalone +replays and selected-record checks are the relevant validation performed. +Finite tests do not discharge the inherited all-size, physical hosting, tape, +precision or outer analytic obligations. The dense tape invoice is an explicit +upper bound with paid macro/control work, not a measured execution trace. + +Review can focus on the prefix-difference reduction, completeness of the +945-matching quotient, scalar specialization proving the lower bound, and +the independence of the three interpreters. Substantial AI assistance and +predecessor attribution are recorded in NOTICE.md. diff --git a/research/universal-connector-boundary/dense_checks.py b/research/universal-connector-boundary/dense_checks.py new file mode 100644 index 0000000000..62f1582197 --- /dev/null +++ b/research/universal-connector-boundary/dense_checks.py @@ -0,0 +1,202 @@ +#!/usr/bin/env python3 +"""Independent finite replay with dense F2 maps and arbitrary dirty registers. + +For each supplied schedule, the map banks at dimensions 1, 2, and 3 are fixed +by seed 52. Every initial basis bit and 25 mixed dirty states are replayed. +The expected answer is evaluated from explicit matrix products A_i B_j, +independently of the schedule's intermediate connector states. Exhaustion +of basis inputs checks each sampled linear transformation exactly; it does +not exhaust every possible matrix bank or prove the full multiplication +theorem. No construction/generator module is imported. + +SPDX-License-Identifier: Apache-2.0 +Contributor: Ross, with substantial OpenAI Codex assistance. +""" + +from copy import deepcopy +import json +from pathlib import Path +import random +import sys + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def matvec(matrix, vector): + return sum(((row & vector).bit_count() & 1) << i + for i, row in enumerate(matrix)) + + +def matmul(left, right): + """Explicit row-by-column product; deliberately separate from matvec.""" + size = len(left) + result = [] + for i in range(size): + row = 0 + for j in range(size): + value = 0 + for k in range(size): + value ^= ((left[i] >> k) & 1) & ((right[k] >> j) & 1) + row |= value << j + result.append(row) + return tuple(result) + + +def symmetric(matrix): + return all(((matrix[i] >> j) & 1) == ((matrix[j] >> i) & 1) + for i in range(len(matrix)) for j in range(len(matrix))) + + +def map_bank(source_count, output_count, size): + rng = random.Random(52 + 1000 * size + 100 * source_count + output_count) + matrices = [tuple(rng.randrange(1, 1 << size) for _ in range(size)) + for _ in range(source_count + output_count)] + sources = matrices[:source_count] + outputs = matrices[source_count:] + if size > 1: + require(any(not symmetric(matrix) for matrix in matrices), + "map bank needs a nonsymmetric matrix witness") + require(any(matmul(a, b) != matmul(b, a) + for a in outputs for b in sources), + "map bank needs a noncommuting pair witness") + return sources, outputs + + +def validate_schedule(schedule): + sources = schedule["sources"] + rows = schedule["rows"] + if not isinstance(sources, int) or sources < 1: + raise ValueError("sources must be a positive integer") + if not rows or any(not isinstance(row, int) or not 0 < row < 1 << sources + for row in rows): + raise ValueError("target rows must be nonzero source masks") + for operation in schedule["word"]: + if not isinstance(operation, (tuple, list)) or len(operation) != 2: + raise ValueError("each operation must be a [kind, index] pair") + kind, index = operation + bound = sources if kind == "B" else len(rows) if kind == "A" else 0 + if not isinstance(index, int) or not 0 <= index < bound: + raise ValueError("invalid operation kind or index") + + +def apply_word(initial, word, source_maps, output_maps): + source_count = len(source_maps) + state = list(initial) + for kind, index in word: + if kind == "B": + state[-1] ^= matvec(source_maps[index], state[index]) + else: + state[source_count + index] ^= matvec(output_maps[index], state[-1]) + return tuple(state) + + +def target_state(initial, rows, compositions): + source_count = len(compositions[0]) + state = list(initial) + for output, row in enumerate(rows): + for source in range(source_count): + if row >> source & 1: + state[source_count + output] ^= matvec( + compositions[output][source], initial[source]) + return tuple(state) + + +def input_states(register_count, size): + # These vectors form a basis of all source, output, and dirty-connector bits. + for register in range(register_count): + for bit in range(size): + state = [0] * register_count + state[register] = 1 << bit + yield tuple(state) + # One all-one and 24 distinct sampled states. Source 0, the final output, + # and the connector are nonzero; remaining registers may be zero. This + # avoids repeating the all-one state 25 times at scalar dimension 1. + all_one = ((1 << size) - 1,) * register_count + yield all_one + seen = {all_one} + rng = random.Random(52 + 1000 * size + register_count) + count = min(25, ((1 << size) - 1) ** 3 * (1 << size) ** (register_count - 3)) + while len(seen) < count: + state = [rng.randrange(1 << size) for _ in range(register_count)] + for register in (0, register_count - 2, register_count - 1): + state[register] = rng.randrange(1, 1 << size) + state = tuple(state) + if state not in seen: + seen.add(state) + yield state + + +def check_schedule(schedule): + validate_schedule(schedule) + source_count = schedule["sources"] + rows = schedule["rows"] + registers = source_count + len(rows) + 1 + counts = {"map_banks": 0, "basis_states": 0, "mixed_dirty_states": 0, + "forward_cases": 0, "inverse_cases": 0, "nonsymmetric_banks": 0, + "noncommuting_banks": 0} + for size in (1, 2, 3): + sources, outputs = map_bank(source_count, len(rows), size) + compositions = [[matmul(a, b) for b in sources] for a in outputs] + bank_cases = 0 + for initial in input_states(registers, size): + actual = apply_word(initial, schedule["word"], sources, outputs) + expected = target_state(initial, rows, compositions) + require(actual == expected, ("forward", size, initial, actual, expected)) + restored = apply_word(actual, reversed(schedule["word"]), sources, outputs) + require(restored == initial, ("inverse", size, initial, restored)) + counts["forward_cases"] += 1 + counts["inverse_cases"] += 1 + bank_cases += 1 + counts["basis_states"] += registers * size + counts["mixed_dirty_states"] += bank_cases - registers * size + counts["map_banks"] += 1 + if size > 1: + counts["nonsymmetric_banks"] += 1 + counts["noncommuting_banks"] += 1 + return counts + + +def check_dense(certificate): + results = {name: check_schedule(schedule) + for name, schedule in certificate["schedules"].items()} + if not results: + raise ValueError("certificate must contain schedules") + + # Controls start with the four-source schedule and alter distinct contracts. + original = certificate["schedules"]["four_all"] + controls = [] + missing_restoration = deepcopy(original) + final_source = max(i for i, (kind, _) in enumerate(missing_restoration["word"]) + if kind == "B") + del missing_restoration["word"][final_source] + controls.append(("omitted_final_source", missing_restoration)) + + wrong_destination = deepcopy(original) + first_output = next(i for i, (kind, _) in enumerate(wrong_destination["word"]) + if kind == "A") + kind, index = wrong_destination["word"][first_output] + wrong_destination["word"][first_output] = [kind, (index + 1) % len(original["rows"])] + controls.append(("wrong_output_destination", wrong_destination)) + + wrong_target = deepcopy(original) + wrong_target["rows"][0] ^= 1 << (original["sources"] - 1) + controls.append(("wrong_target_row", wrong_target)) + + detected = [] + for name, broken in controls: + try: + check_schedule(broken) + except ValueError: + detected.append(name) + else: + raise ValueError("negative control was accepted: " + name) + return {"schedules": results, "negative_controls_detected": detected, + "seed": 52, "dimensions": [1, 2, 3]} + + +if __name__ == "__main__": + path = Path(sys.argv[1]) if len(sys.argv) > 1 else Path(__file__).with_name("CERTIFICATE.json") + print(json.dumps(check_dense(json.loads(path.read_text())), indent=2, sort_keys=True)) diff --git a/research/universal-connector-boundary/generate.py b/research/universal-connector-boundary/generate.py new file mode 100644 index 0000000000..1e20decc23 --- /dev/null +++ b/research/universal-connector-boundary/generate.py @@ -0,0 +1,121 @@ +#!/usr/bin/env python3 +"""Emit the finite universal-connector certificate (Python standard library).""" +from collections import Counter +from hashlib import sha256 +from itertools import combinations +import json +from pathlib import Path + +BASE = "91a2094f2e022930069e8cfdc810a3ea1b81cd09" +SEED = 52 +ROOT = Path(__file__).resolve().parent + + +def double_words(n, word=(), counts=()): + """Restricted-growth words: quotient by first-occurrence source naming.""" + if len(word) == 2 * n: + yield word + return + for label, count in enumerate(counts): + if count == 1: + after = counts[:label] + (2,) + counts[label + 1:] + yield from double_words(n, word + (label,), after) + if len(counts) < n: + yield from double_words(n, word + (len(counts),), counts + (1,)) + + +def prefixes(word): + values = [0] + for label in word: + values.append(values[-1] ^ (1 << label)) + return values + + +def difference_mask(word): + values = prefixes(word) + return sum(1 << d for d in {a ^ b for a in values for b in values}) + + +def census(n): + entries = sorted((list(w), difference_mask(w)) for w in double_words(n)) + hist = Counter(mask.bit_count() for _, mask in entries) + payload = json.dumps(entries, separators=(",", ":")).encode() + return {"sources": n, "pairings": len(entries), + "histogram": dict(sorted((str(k), v) for k, v in hist.items())), + "canonical_entries_sha256": sha256(payload).hexdigest(), + "max_coverage": max(hist)} + + +def schedule(source_word, n, rows, allow_four=False): + """Place each readout at two prefix slots, or four if necessary.""" + values = prefixes(source_word) + slots = [[] for _ in values] + endpoints = [] + for i, row in enumerate(rows): + pair = next((list(c) for c in combinations(range(len(values)), 2) + if values[c[0]] ^ values[c[1]] == row), None) + if pair is None and allow_four: + pair = next((list(c) for c in combinations(range(len(values)), 4) + if values[c[0]] ^ values[c[1]] ^ values[c[2]] ^ values[c[3]] == row), None) + if pair is None: + raise ValueError(f"unrealized row {row}") + endpoints.append(pair) + for slot in pair: + slots[slot].append(["A", i]) + word = [] + for k, reads in enumerate(slots): + word.extend(reads) + if k < len(source_word): + word.append(["B", source_word[k]]) + return {"sources": n, "rows": rows, "source_word": list(source_word), + "readout_slots": endpoints, "word": word, "queries": len(word)} + + +def product_word(factors, source, target, depth=0): + """Factors are listed in application order; all leaves are XOR shears.""" + if len(factors) == 1: + return [[factors[0], source, target]] + cut = len(factors) // 2 + connector = f"scratch{depth}" + right = product_word(factors[:cut], source, connector, depth + 1) + left = product_word(factors[cut:], connector, target, depth + 1) + return right + left + right[::-1] + left[::-1] + + +def lower(item, lengths): + words, factors = {}, {} + for kind in ("B", "A"): + for i, length in enumerate(lengths[kind]): + name = f"{kind}{i}" + factors[name] = [f"{name}.{k}" for k in range(length)] + src, dst = (f"x{i}", "z") if kind == "B" else ("z", f"y{i}") + words[name] = product_word(factors[name], src, dst) + literal = [op for kind, i in item["word"] for op in words[f"{kind}{i}"]] + return {"factor_lengths": lengths, "factors": factors, + "query_leaf_prices": {k: len(v) for k, v in words.items()}, + "leaf_word": literal, "leaf_calls": len(literal), + "borrowed_dirty_arrays": 1 + (max(sum(lengths.values(), [])) - 1).bit_length()} + + +def main(): + four = (0, 1, 0, 1, 2, 3, 2, 3) + five_ten = (0, 1, 2, 0, 3, 1, 4, 2, 3, 4) + five_twelve = (2, 0, 2, 1, 2, 0, 3, 1, 4, 2, 3, 4) + schedules = { + "four_all": schedule(four, 4, list(range(1, 16))), + "five_extra_source": schedule(five_twelve, 5, list(range(1, 32))), + "five_extra_output": schedule(five_ten, 5, list(range(1, 32)), True), + } + lengths = {"B": [1, 2, 3, 4, 5], "A": [1] * 31} + lowered = {k: lower(v, lengths) for k, v in schedules.items() if k.startswith("five")} + result = {"schema": "universal-connector-boundary-v1", "base": BASE, + "assignment_seed": SEED, "censuses": [census(4), census(5)], + "schedules": schedules, "lowered": lowered, + "five_source_comparators": {"column_stars": 170, "row_stars": 222}, + "scope": "Exact binary query model; no new kappa or supplier integration"} + (ROOT / "CERTIFICATE.json").write_text(json.dumps(result, indent=2) + "\n") + print("GENERATED_UNIVERSAL_CONNECTOR_BOUNDARY") + + +if __name__ == "__main__": + main() diff --git a/research/universal-connector-boundary/independent.py b/research/universal-connector-boundary/independent.py new file mode 100644 index 0000000000..af9a81a137 --- /dev/null +++ b/research/universal-connector-boundary/independent.py @@ -0,0 +1,163 @@ +#!/usr/bin/env python3 +"""Independent exact census through matchings of endpoint positions. + +No generator or certificate code is imported. The search objects are perfect +matchings of 2*n numbered positions, not restricted-growth source words. +Each matching is labelled only after it has been completed, in order of its +left endpoints. Coverage is computed by directly XORing every pair of +prefix states. A separate scalar replay checks dirty-connector cancellation +for every input and dirty initial value on each reported witness. + +This is an exhaustive finite combinatorial verification, not a formal proof +of the conditional integer-multiplication theorem. + +SPDX-License-Identifier: Apache-2.0 +Contributor: Ross, with substantial OpenAI Codex assistance. +""" + +import argparse +from collections import Counter +import json + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def endpoint_matchings(points): + """Generate each perfect matching once, pairing the least unused point.""" + if not points: + yield () + return + first = points[0] + for partner in points[1:]: + remaining = tuple(p for p in points if p != first and p != partner) + for tail in endpoint_matchings(remaining): + yield ((first, partner),) + tail + + +def matching_word(pairs, n): + word = [None] * (2 * n) + for label, (left, right) in enumerate(sorted(pairs)): + word[left] = label + word[right] = label + return tuple(word) + + +def prefix_states(word, n): + if n < 1 or len(word) != 2 * n: + raise ValueError("a source word must contain 2*n positions for n >= 1") + if Counter(word) != Counter({j: 2 for j in range(n)}): + raise ValueError("each source label 0,...,n-1 must occur exactly twice") + states = [0] + for label in word: + states.append(states[-1] ^ (1 << label)) + require(states[-1] == 0, "source word failed connector restoration") + return states + + +def available(word, n): + """Return attainable row masks, including the zero mask.""" + states = prefix_states(word, n) + return {first ^ second for first in states for second in states} + + +def pairing_covers(n): + """Yield (canonical word, integer with bit m set for each covered mask m).""" + if n < 1: + raise ValueError("n must be positive") + for pairs in endpoint_matchings(tuple(range(2 * n))): + word = matching_word(pairs, n) + covered = available(word, n) + yield word, sum(1 << mask for mask in covered) + + +def census(n): + histogram = Counter() + total = 0 + best_word = None + best_cover = 0 + maximum = -1 + for word, covered in pairing_covers(n): + count = covered.bit_count() + histogram[count] += 1 + total += 1 + if count > maximum: + maximum, best_word, best_cover = count, word, covered + expected = 1 + for factor in range(1, 2 * n, 2): + expected *= factor + require(total == expected, ("matching count", total, expected)) + return { + "pairings": total, + "histogram": {str(k): histogram[k] for k in sorted(histogram)}, + "max_coverage": maximum, + "best_word": list(best_word), + "missing": [mask for mask in range(1 << n) if not best_cover >> mask & 1], + } + + +def replay_scalar(word, n): + """Replay actual bit operations for every input/dirty value on every row. + + For each attainable nonzero row, choose one pair of boundaries, read the + scalar connector there into a dirty output, and toggle the sources along + the word. Test both dirty connector and dirty output initial bits and + every source assignment. This intentionally does not update a symbolic + prefix mask during the replay. + """ + states = prefix_states(word, n) + read_pairs = {} + for first in range(len(states)): + for second in range(first + 1, len(states)): + mask = states[first] ^ states[second] + if mask: + read_pairs.setdefault(mask, (first, second)) + cases = 0 + for mask, (first, second) in read_pairs.items(): + for source_bits in range(1 << n): + intended = 0 + for j in range(n): + if mask >> j & 1: + intended ^= source_bits >> j & 1 + for initial_connector in (0, 1): + for initial_output in (0, 1): + connector = initial_connector + output = initial_output + for boundary in range(len(word) + 1): + if boundary == first or boundary == second: + output ^= connector + if boundary < len(word): + connector ^= source_bits >> word[boundary] & 1 + require(connector == initial_connector, "scalar connector restoration") + require(output == initial_output ^ intended, "scalar row mismatch") + cases += 1 + return cases + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--sources", type=int, default=5, choices=range(1, 7)) + args = parser.parse_args() + result = census(args.sources) + result["scalar_replay_cases"] = replay_scalar(result["best_word"], args.sources) + if args.sources == 5: + require(result["pairings"] == 945, "five-source pairing count") + require(result["max_coverage"] == 31, "five-source maximum coverage") + require(result["histogram"] == { + "16": 42, "19": 120, "21": 180, "22": 56, "23": 45, + "24": 220, "26": 110, "28": 150, "31": 22, + }, "five-source complete coverage histogram") + universal_four = (0, 1, 0, 1, 2, 3, 2, 3) + require(available(universal_four, 4) == set(range(16)), "universal four coverage") + result["universal_four_scalar_replay_cases"] = replay_scalar(universal_four, 4) + # A legal double-occurrence mutation must be detected as nonuniversal. + adjacent_pairs = (0, 0, 1, 1, 2, 2, 3, 3) + require(len(available(adjacent_pairs, 4)) == 11, "legal word mutation control") + result["legal_word_negative_control_coverage"] = 11 + print(json.dumps(result, indent=2, sort_keys=True)) + + +if __name__ == "__main__": + main() diff --git a/research/universal-connector-boundary/references/PR934-NOTICE.md b/research/universal-connector-boundary/references/PR934-NOTICE.md new file mode 100644 index 0000000000..22bc8648ac --- /dev/null +++ b/research/universal-connector-boundary/references/PR934-NOTICE.md @@ -0,0 +1,34 @@ +# Attribution and license + +New contribution by Ross Richardson (@RossRichardson), with substantial +OpenAI Codex assistance in the mathematical argument, implementation, +verification and writing. Apache-2.0, as in the repository LICENSE. + +PR889 by @shhxera (head e2021d1c9e06948528cbc0a8fd7079b671da981d) +provides the direct predecessor: the common-right-factor dirty fanout contract, +its star-query lower bound, explicit child pricing and the distinction between +restoration and exact linearity. Its README and NOTICE are retained unmodified +with source pins. No predecessor executable is imported by this package. + +Chafik Boukhalfa (@chafreaky), PR628 at +0768f97d06c623b8211e651543c66135796b62bf, supplies the dirty product commutator +and literal-inverse convention cited by PR889. PR822 by @shhxera explores dirty +sibling connector reuse in one-output trees; this contribution instead changes +the multi-input/multi-output query schedule. The comparison does not claim an +optimum among PR822's or the earlier higher-arity echo architectures. +PR896's nonlinear restoration formalization is related context, not a proof +of the linear product identity used here. PR522's coordinate-sector construction +has a distinct physical supplier contract and is not imported. +Concurrent PR929 at 85a1d11adbbd7610d269cfeb3e477cf7d457f2eb groups cyclic-inverse +factors in a single-output dirty commutator, including rounded complex costs. +Its source is not used: this package is an exact characteristic-two, multiple- +source/output scheduling result and does not combine the two savings. + +The commutator identity and finite-state scheduling methods are classical; +no literature-priority claim is made. The new evidence is the complete +three-by-three binary schedule table, its independently checked support-bound +optimality, the concrete 12-query cycle, and the paid recursive lowering. + +The accepted selected result retains Jeremy Kothe, Chafik Boukhalfa, +DreamingOfClouds, eumemic and the cumulative community's attribution. No bound +or implementation from them is relabeled as this contribution's result. diff --git a/research/universal-connector-boundary/references/PR934-README.md b/research/universal-connector-boundary/references/PR934-README.md new file mode 100644 index 0000000000..7158c8c1f9 --- /dev/null +++ b/research/universal-connector-boundary/references/PR934-README.md @@ -0,0 +1,224 @@ +# Restored binary connector walks for all 3-by-3 product patterns + +**Recursive-interface construction with a finite optimality certificate. No new +kappa.** In the six-query model below, every binary 3-by-3 coefficient matrix +can be implemented with exactly two calls to each active operator. This attains +the support lower bound, including for arbitrary positive per-operator prices. +The certificate contains all 512 explicit words; it is not an inference from +a sample or a claim about general circuits. + +For the six-edge cycle, carrying partial sums in one dirty connector reduces +18 complete queries for separate row/column stars to **12**. With the six +queries themselves lowered as binary products of lengths 1 through 6, the +same change reduces the better star comparator from **228 to 198 complete +leaf calls**, with **four borrowed dirty arrays** in either schedule. +These are operation counts, not measured speedups or a supplier exponent. + +```sh +python3 -I -O -B research/binary-connector-walk/verify.py +``` + +Expected: `PASS_BINARY_CONNECTOR_WALK targets=512 dense_cases=23040 controls=11 +cycle=18->12 lowered=228->198`. Python 3.10+ and its standard library suffice. +`search.py` regenerates only this package's `CERTIFICATE.json`; +`verify.py --write-summary` regenerates only `EXPECTED.json`. +`test_package.py` also checks exact regeneration, relocation and file corruption. + +## Contract and model + +Let x_0,x_1,x_2, y_0,y_1,y_2 and z be seven distinct, arbitrary length-L +binary arrays. The maps B_j and A_i are fixed, exact F2-linear operators. +They need not commute or be invertible. Coefficients are read-only. The desired +map for M in F2^(3 by 3) is + + x_j -> x_j; z -> z; + y_i -> y_i + sum_j M_ij A_i B_j x_j. + +Only six complete queries are permitted: + +- B_j: `z += B_j x_j`; +- A_i: `y_i += A_i z`. + +Addition is XOR. Each query preserves its source, every other data array and +its private scratch. A child returns its scratch and prescribed tape heads to +their entry state. Its action is independent of the previous target contents. +All six data arrays and the connector are excluded from child scratch. They +remain reserved throughout the batch; no external observer consumes temporary +outputs. Coefficients, source arrays, role bindings and frames cannot change. + +The alphabet excludes combined queries, direct A_i B_j calls, extra connector +arrays, free copies, overwrites, changing the physical role assignment, and +other data operations. The optimum below is relative to this alphabet. It is +not a lower bound for the actual selected supplier or general bit circuits. + +This extends the single-source fanout interface in +[PR889](https://github.com/CrocSwap/integer-mult-bounds/pull/889). Its connector +is restored between individual stars in the comparator. Here independent +sources can enter/leave the connector at different times, and output readouts +cancel its original dirt only at the end. The difference is the interface and +schedule, not a different random seed for the same echo-tree search. + +## Explicit six-edge cycle + +For M with rows `(1,1,0), (0,1,1), (1,0,1)`, execute + + A0 A1 B0 A2 B1 A0 B0 B2 A1 B1 A2 B2. + +The connector's source subsets at the paired readouts are: + +| Output | First subset | Second subset | XOR difference | +|---|---|---|---| +| y_0 | empty | {0,1} | {0,1} | +| y_1 | empty | {1,2} | {1,2} | +| y_2 | {0} | {2} | {0,2} | + +Each A_i reads the initial dirty z twice, so that term cancels. Each B_j occurs +twice, restoring z. The x_j arrays are never targets. This proves the displayed +identity for arbitrary L and exact linear maps, with no commutativity assumption. +It also explains why deleting an apparent final cleanup query is invalid. + +## General lower bound and complete three-by-three certificate + +Work with free formal operators and independent input symbols. In any valid +word, the coefficient of B_j x_j in final z is the parity of the B_j count. +Restoration forces this count to be even. A nonzero column of M requires at +least one B_j call, hence at least two. The coefficient of A_i z_initial in +final y_i is the parity of the A_i count. Independence from connector dirt +forces it to be even; a nonzero row requires at least two A_i calls. + +Thus every word that works for arbitrary maps has query count at least + + 2 (number of nonzero rows + number of nonzero columns). + +For positive, fixed complete prices c_Ai,c_Bj, the corresponding bound is +`2 sum_active c_F`. This is a generic-operator bound: specialized zero maps, +relations between maps or restricted inputs can have different optima. + +The certificate's 512 words each have exactly these multiplicities and are +checked in an independent free noncommutative algebra. Therefore the lower +bound is attained for every 3-by-3 binary M, including degenerate and empty +patterns. This finite constructive result also covers smaller matrices by +zero padding the *operator pattern*, without dividing charged payload volume. +It does not establish the same property for four or more inputs/outputs. + +The search state is `(q,e,M)` with q,e in F2^3 and M in F2^(3 by 3): +`z=z_initial+sum q_j B_j x_j`, and +`y_i=y_i_initial+e_i A_i z_initial+sum M_ij A_i B_j x_j`. +A B_j toggles q_j. An A_i toggles e_i and adds q to row i of M. This gives +32,768 states and six edges per state. The breadth-first search exhausts all +196,608 directed edges and stops when its queue is empty. Seed 51 selects +dimension `2+51%2` and rotates the generator order for deterministic witnesses. +All 512 restored target states have q=e=0. No stochastic pruning is used. + +The independent verifier does **not** trust or replay the BFS transition code +or its reported distances. It interprets each literal query on free polynomial +expressions in all seven independent inputs, checks the full target map and +inverse, and checks equality with the proved support bound. The BFS statistics +are search provenance, checked separately by deterministic regeneration. +This is an exact finite certificate with a written reduction, not a Lean proof +or formal verification of the multiplication theorem. + +For 418 of 512 patterns, the word is shorter than both the whole-row and +whole-column star schedules. These are explicit comparators, not an asserted +optimum among every possible partition into stars. The zero pattern is included. + +## Complete cost recurrence and storage + +Let c_F(L) be a **complete** additive query cost on a full length-L row at its +specified ports. Include source/coefficient access, arithmetic, target update, +private scratch restoration, head returns, and any required entry/exit frame +conversion. Let P_F be reusable coefficient preparation/admission, paid once +per active F. No such preparation is needed for the already supplied binary +matrix fixtures beyond their explicit validation scans. Then + + C_M(L) = sum_active P_F + I_M(L) + + 2 sum_active c_F(L) + D_M, + +where I_M pays role/shape/bit validation and initial layout, and D_M pays word +selection, instruction reads and dispatch. No copy or frame change is emitted +by this interface itself. If a caller's representation is incompatible, its +conversions must be added to c_F or I_M; they are not silently omitted. +Seven full data rows remain live, plus the maximum private scratch of an active +query. One of the seven rows, z, is borrowed and dirty. No clean length-L row is +required; scalar arithmetic/control registers and instruction storage are paid. +Outputs and sources cannot be reused as recursive scratch. + +For explicit recursive lowering, let F=F_left F_right, in application order +right then left. With another distinct dirty connector w, use +`R L reverse(R) reverse(L)`. Every elementary binary shear is self-inverse, so +these are literal inverse words, including all children. In the same complete +entry/exit convention, + + C([f]) = c_f + dispatch_leaf, + C(F) = 2 C(F_right) + 2 C(F_left) + dispatch_node. + +The generator uses balanced contiguous splits. Its leaf recurrence is +`ell(1)=1`, `ell(n)=2 ell(floor(n/2))+2 ell(ceil(n/2))` and its scratch depth is +`h(1)=0`, `h(n)=1+max(h(floor(n/2)),h(ceil(n/2)))=ceil(log2 n)`. +The batch needs `1+max h(n_F)` borrowed dirty arrays in addition to six data +rows. A sibling reuses private scratch only after the preceding call returns. +The inverse of a child does not duplicate its peak workspace. + +For B0,B1,B2,A0,A1,A2 with factor lengths 1,2,3,4,5,6, the leaf prices are +1,4,10,16,28,40. The literal 198-leaf program is included and independently +checked on ten arbitrary initial arrays in the free algebra. + +| Schedule for the six-edge cycle | Root calls | Lowered leaf calls | Dirty arrays | +|---|---:|---:|---:| +| Three column stars | 18 | 366 | 4 | +| Three row stars | 18 | 228 | 4 | +| Carried connector walk | 12 | 198 | 4 | + +The comparison preserves the same six factor products and their lowering. +It does not optimize alternative product splits or other echo architectures. +Preparation and admission are the same; every active oracle is called twice +in the walk, so any positive fixed complete per-oracle price attains the same +support bound. A nonuniform physical price is not replaced by unit cost. + +### Explicit dense tape invoice + +`EXPECTED.json` includes a concrete, deliberately slow dense implementation. +All mutable binary arrays precede the read-only matrices on one data tape; +for every target entry, the trace visits each matrix coefficient and matching +source bit, computes a scalar dot product, then updates the target bit. It +returns to cell zero after **each** complete leaf. The exact invoice counts +coefficient/source reads, target read/write pairs, AND/XOR operations and every +head move. It includes all live data and coefficient bits and validation reads. +Each of N leaves has L^2 coefficient reads, L^2 source reads, L target updates, +L^2 ANDs, and L(L+1) XORs (including accumulation and target update). + +Control uses an explicitly stored instruction tape: charge N instruction +records with O(log(R+K)) bits per record for R roles and K matrices, sequential +instruction reads, O(N) dispatches, and indexing/control work per data access. +The finite root lookup table has 512 entries and bounded size; alternatively +the displayed word is hard-coded for the cycle. Initial placement and coefficient +production from other input formats remain separately charged in I_M and P_F. +The matrix fixtures are supplied in the stated layout. No rounding or precision +approximation occurs over F2. The verifier's Python copies are validation code, +not a wall-time implementation claim for this tape algorithm. + +## Scope, controls and inherited obligations + +The independent replay checks all 512 witnesses and both star comparators in +free algebra, plus every input basis column for deterministic dense maps at +L=1,2,3 and combined dirty inputs: 23,040 dense cases, each with the appropriate +inverse check for the basis cases. The lowered program is checked symbolically. +Eleven controls reject missing coverage, omitted restoration, reordered queries, +a correct but nonoptimal word, the wrong target pattern, a wrong child factor, +aliased ports, an unpaid child, underpriced scratch, odd characteristic and a +nonlinear readout. Odd-characteristic/nonlinear cases are **counterexamples to +extending this binary exact contract**, not failures of the admitted construction. + +The current selected conditional exponent at the exact base is +1661634653669567/10^18 (#799 with #589/#555). This package has not located these +independent-source/product obligations inside that supplier. Common-label and +mutable-source realization, frames, ownership, full-row volume, compiler/tape +integration and the outer analytic constraints remain uninstantiated. A cheaper +abstract query word cannot establish a new kappa, nor show which supplier would +bind after an actual integration. No selected profile, certificate or upstream +manuscript is changed. The coordinate-Fourier obstruction is not bypassed by a +free address transform: every black-box child here has its full charged cost. + +See [CLAIM.md](CLAIM.md), [SOURCES.json](SOURCES.json), [VALIDATION.md](VALIDATION.md) +and [NOTICE.md](NOTICE.md) for base, search domain, evidence, predecessors, +attribution and substantial AI assistance. diff --git a/research/universal-connector-boundary/test_package.py b/research/universal-connector-boundary/test_package.py new file mode 100644 index 0000000000..aa60cd1263 --- /dev/null +++ b/research/universal-connector-boundary/test_package.py @@ -0,0 +1,78 @@ +#!/usr/bin/env python3 +"""Relocated replay, exact regeneration, and deliberate package corruptions.""" +import json +from pathlib import Path +import shutil +import subprocess +import sys +import tempfile + +ROOT = Path(__file__).resolve().parent + + +def run(root, script, *args): + return subprocess.run([sys.executable, "-I", "-O", "-B", str(root / script), *args], + cwd=root.parent, text=True, capture_output=True, timeout=60) + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def main(): + with tempfile.TemporaryDirectory(prefix="universal connector ") as temp: + copy = Path(temp) / "package with spaces" + shutil.copytree(ROOT, copy, ignore=shutil.ignore_patterns("__pycache__", "*.pyc")) + initial = run(copy, "verify.py") + require(initial.returncode == 0, initial.stderr) + certificate = copy / "CERTIFICATE.json" + before = certificate.read_bytes() + require(run(copy, "generate.py").returncode == 0, "generator failed") + require(certificate.read_bytes() == before, "certificate regeneration differs") + expected = copy / "EXPECTED.json" + expected_before = expected.read_bytes() + regenerated = run(copy, "verify.py", "--write-summary") + require(regenerated.returncode == 0, regenerated.stderr) + require(expected.read_bytes() == expected_before, "evidence regeneration differs") + failures = [] + + def corrupt_json(name, filename, edit, diagnostic): + path = copy / filename + saved = path.read_bytes() + payload = json.loads(saved) + edit(payload) + path.write_text(json.dumps(payload) + "\n") + result = run(copy, "verify.py") + path.write_bytes(saved) + require(result.returncode != 0 and diagnostic in result.stderr, + f"wrong corruption outcome for {name}: {result.stdout} {result.stderr}") + failures.append(name) + + corrupt_json("fabricated_full_coverage", "CERTIFICATE.json", + lambda d: d["censuses"][1].__setitem__("max_coverage", 32), + "independent census mismatch") + corrupt_json("omitted_census", "CERTIFICATE.json", + lambda d: d["censuses"].pop(), "missing census") + corrupt_json("unrestored_connector", "CERTIFICATE.json", + lambda d: d["schedules"]["five_extra_source"]["word"].pop(), + "root free-algebra identity") + corrupt_json("unpaid_child", "CERTIFICATE.json", + lambda d: d["lowered"]["five_extra_output"]["query_leaf_prices"].__setitem__("B4", 27), + "unpaid recursive child") + corrupt_json("fabricated_evidence", "EXPECTED.json", + lambda d: d.__setitem__("unit_lower_bound", 72), "expected evidence differs") + reference = copy / "references/PR934-README.md" + saved = reference.read_bytes() + reference.write_bytes(saved + b"\nChanged predecessor bytes.\n") + result = run(copy, "verify.py") + reference.write_bytes(saved) + require(result.returncode != 0 and "reference SHA256 mismatch" in result.stderr, + "corrupt reference accepted or wrong failure") + failures.append("changed_predecessor") + require(run(copy, "verify.py").returncode == 0, "restored package no longer passes") + print("PASS_UNIVERSAL_CONNECTOR_PACKAGE relocation=1 regeneration=2 corruptions=" + str(len(failures))) + + +if __name__ == "__main__": + main() diff --git a/research/universal-connector-boundary/verify.py b/research/universal-connector-boundary/verify.py new file mode 100644 index 0000000000..de6483bb7f --- /dev/null +++ b/research/universal-connector-boundary/verify.py @@ -0,0 +1,250 @@ +#!/usr/bin/env python3 +"""Independently check the finite certificate; no generator imports.""" +import argparse +from collections import Counter +from hashlib import sha1, sha256 +import importlib.util +import json +from pathlib import Path + +ROOT = Path(__file__).resolve().parent +BASE = "91a2094f2e022930069e8cfdc810a3ea1b81cd09" + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def module(name): + spec = importlib.util.spec_from_file_location(name, ROOT / f"{name}.py") + result = importlib.util.module_from_spec(spec) + spec.loader.exec_module(result) + return result + + +def expected_map(n, rows, operators=None, extra=()): + roles = [f"x{j}" for j in range(n)] + [f"y{i}" for i in range(len(rows))] + ["z"] + list(extra) + state = {role: {(role,)} for role in roles} + for i, mask in enumerate(rows): + for j in range(n): + if mask >> j & 1: + a, b = f"A{i}", f"B{j}" + factors = (a, b) if operators is None else tuple(operators[a][::-1] + operators[b][::-1]) + state[f"y{i}"].symmetric_difference_update({factors + (f"x{j}",)}) + return state + + +def interpret(operations, state, allowed): + state = {role: set(poly) for role, poly in state.items()} + for coefficient, source, target in operations: + need(coefficient in allowed, "unknown operator") + need(source in state and target in state and source != target, "invalid/aliased port") + state[target].symmetric_difference_update({(coefficient,) + term for term in state[source]}) + return state + + +def root_operations(item): + n, rows = item["sources"], item["rows"] + need(type(n) is int and 1 <= n <= 5, "invalid source dimension") + need(all(type(r) is int and 0 < r < (1 << n) for r in rows), "invalid row mask") + result = [] + for op in item["word"]: + need(type(op) is list and len(op) == 2, "invalid query record") + kind, index = op + need(kind in ("A", "B") and type(index) is int, "invalid query type") + need(0 <= index < (n if kind == "B" else len(rows)), "invalid query index") + source, target = (f"x{index}", "z") if kind == "B" else ("z", f"y{index}") + result.append((f"{kind}{index}", source, target)) + return result + + +def check_schedule(item): + ops = root_operations(item) + target = expected_map(item["sources"], item["rows"]) + initial = {role: {(role,)} for role in target} + allowed = {f"B{j}" for j in range(item["sources"])} | {f"A{i}" for i in range(len(item["rows"]))} + out = interpret(ops, initial, allowed) + need(out == target, "root free-algebra identity or restoration failed") + need(interpret(ops[::-1], out, allowed) == initial, "root inverse failed") + need(item["queries"] == len(ops), "unpaid root call") + actual_source = [i for kind, i in item["word"] if kind == "B"] + need(actual_source == item["source_word"], "source projection mismatch") + slots, slot = [[] for _ in item["rows"]], 0 + for kind, i in item["word"]: + if kind == "B": + slot += 1 + else: + slots[i].append(slot) + need(slots == item["readout_slots"], "readout metadata mismatch") + return Counter(op[0] for op in ops) + + +def balanced_price(n): + k = n.bit_length() - 1 + return (1 << k) * (3 * n - (1 << (k + 1))) + + +def check_lowering(lowered, item): + lengths = lowered["factor_lengths"] + need(lengths == {"B": [1, 2, 3, 4, 5], "A": [1] * 31}, "changed lowering fixture") + factors = {f"{k}{i}": [f"{k}{i}.{j}" for j in range(n)] for k in ("B", "A") for i, n in enumerate(lengths[k])} + need(lowered["factors"] == factors, "factor identity/order metadata") + prices = {f"{k}{i}": balanced_price(n) for k in ("B", "A") for i, n in enumerate(lengths[k])} + need(lowered["query_leaf_prices"] == prices, "unpaid recursive child") + counts = Counter(f"{k}{i}" for k, i in item["word"]) + paid = sum(counts[name] * price for name, price in prices.items()) + ops = lowered["leaf_word"] + need(len(ops) == paid == lowered["leaf_calls"], "leaf count mismatch") + need(lowered["borrowed_dirty_arrays"] == 4, "underpriced workspace") + scratch = [f"scratch{k}" for k in range(3)] + target = expected_map(5, item["rows"], factors, scratch) + initial = {role: {(role,)} for role in target} + allowed = {f for fs in factors.values() for f in fs} + actual = interpret(ops, initial, allowed) + need(actual == target, "lowered map, factor order or dirty restoration failed") + need(interpret(ops[::-1], actual, allowed) == initial, "lowered inverse failed") + used = {r for _, s, t in ops for r in (s, t) if r.startswith("scratch")} + need(used == set(scratch), "scratch inventory mismatch") + return paid + + +def check_sources(): + sources = json.loads((ROOT / "SOURCES.json").read_text()) + need(sources["base"] == BASE, "base pin mismatch") + for entry in sources["references"]: + content = (ROOT / entry["local_path"]).read_bytes() + need(sha256(content).hexdigest() == entry["sha256"], "reference SHA256 mismatch") + blob = sha1(b"blob " + str(len(content)).encode() + b"\0" + content).hexdigest() + need(blob == entry["git_blob"], "reference Git blob mismatch") + # Optional workspace context is checked when present; relocation is standalone. + repo = ROOT.parent.parent + count = 0 + for path, digest in sources["context"].items(): + if (repo / path).is_file(): + need(sha256((repo / path).read_bytes()).hexdigest() == digest, "base context drift: " + path) + count += 1 + return len(sources["references"]), count + + +def check_star_comparators(rows): + """Build both ordinary restored star comparators without generator code.""" + columns, rowwise = [], [] + for j in range(5): + readers = [["A", i] for i, row in enumerate(rows) if row >> j & 1] + columns += [["B", j]] + readers + [["B", j]] + readers + for i, row in enumerate(rows): + toggles = [["B", j] for j in range(5) if row >> j & 1] + rowwise += toggles + [["A", i]] + toggles[::-1] + [["A", i]] + result = {} + for name, word in (("column_stars", columns), ("row_stars", rowwise)): + ops = root_operations({"sources": 5, "rows": rows, "word": word}) + target = expected_map(5, rows) + initial = {role: {(role,)} for role in target} + allowed = {op[0] for op in ops} + need(interpret(ops, initial, allowed) == target, "invalid star comparator") + need(interpret(ops[::-1], target, allowed) == initial, "star inverse") + paid = sum(balanced_price(int(name[1:]) + 1) if name.startswith("B") else 1 for name, _, _ in ops) + result[name] = {"queries": len(ops), "leaf_calls": paid} + return result + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--write-summary", action="store_true") + args = parser.parse_args() + cert = json.loads((ROOT / "CERTIFICATE.json").read_text()) + need(cert["schema"] == "universal-connector-boundary-v1" and cert["base"] == BASE and cert["assignment_seed"] == 52, "certificate header") + independent = module("independent") + need([c["sources"] for c in cert["censuses"]] == [4, 5], "missing census") + census_summary = [] + for reported in cert["censuses"]: + n = reported["sources"] + entries = sorted((list(word), mask) for word, mask in independent.pairing_covers(n)) + need(len(entries) == len({tuple(w) for w, _ in entries}), "duplicate matching") + hist = Counter(mask.bit_count() for _, mask in entries) + digest = sha256(json.dumps(entries, separators=(",", ":")).encode()).hexdigest() + need(reported == {"sources": n, "pairings": len(entries), "histogram": dict(sorted((str(k), v) for k, v in hist.items())), "canonical_entries_sha256": digest, "max_coverage": max(hist)}, "independent census mismatch") + need(len(entries) == (105 if n == 4 else 945), "domain incomplete") + need(max(hist) == (16 if n == 4 else 31), "boundary failed") + census_summary.append({"sources": n, "pairings": len(entries), "max_coverage": max(hist)}) + schedules = cert["schedules"] + need(set(schedules) == {"four_all", "five_extra_source", "five_extra_output"}, "schedule coverage") + queries = {} + for name, item in schedules.items(): + need(item["rows"] == list(range(1, 1 << item["sources"])), "all nonzero rows missing") + counts = check_schedule(item) + need(all(c % 2 == 0 for c in counts.values()), "odd oracle multiplicity") + need(item["queries"] == (38 if name == "four_all" else 74), "unit optimality witness") + queries[name] = item["queries"] + # Check full universality directly, not only counts in a receipt. + for name in ("four_all", "five_extra_source"): + need(all(len(s) == 2 for s in schedules[name]["readout_slots"]), "not paired readouts") + needs_four = [r for r, slots in zip(schedules["five_extra_output"]["rows"], schedules["five_extra_output"]["readout_slots"]) if len(slots) == 4] + need(needs_four == [21], "wrong missing-row repair") + lowered = {name: check_lowering(data, schedules[name]) for name, data in cert["lowered"].items()} + need(lowered == {"five_extra_source": 200, "five_extra_output": 182}, "lowering coverage") + rows = schedules["five_extra_output"]["rows"] + column_stars = 2 * sum(1 + sum(bool(r >> j & 1) for r in rows) for j in range(5)) + row_stars = 2 * sum(1 + r.bit_count() for r in rows) + need(cert["five_source_comparators"] == {"column_stars": column_stars, "row_stars": row_stars}, "star pricing") + star_comparators = check_star_comparators(rows) + need(star_comparators == {"column_stars": {"queries": 170, "leaf_calls": 278}, "row_stars": {"queries": 222, "leaf_calls": 1950}}, "star leaf pricing") + controls = [] + + def reject(name, action): + try: + action() + except ValueError: + controls.append(name) + else: + raise ValueError("negative control accepted: " + name) + + def mutated(item): + return json.loads(json.dumps(item)) + + bad = mutated(schedules["five_extra_source"]) + del bad["word"][-1] + reject("omitted_final_source", lambda: check_schedule(bad)) + bad = mutated(schedules["five_extra_source"]) + index = next(k for k in range(len(bad["word"]) - 1) if bad["word"][k][0] != bad["word"][k + 1][0]) + bad["word"][index], bad["word"][index + 1] = bad["word"][index + 1], bad["word"][index] + reject("readout_crosses_source_toggle", lambda: check_schedule(bad)) + bad = mutated(schedules["five_extra_output"]) + index = next(k for k, op in enumerate(bad["word"]) if op == ["A", 20]) + del bad["word"][index:index + 1] + reject("unpaid_missing_row_readout", lambda: check_schedule(bad)) + bad = mutated(schedules["five_extra_source"]) + bad["rows"][0] ^= 2 + reject("wrong_target_pattern", lambda: check_schedule(bad)) + bad = mutated(cert["lowered"]["five_extra_output"]) + bad["borrowed_dirty_arrays"] = 3 + reject("underpriced_scratch", lambda: check_lowering(bad, schedules["five_extra_output"])) + bad = mutated(cert["lowered"]["five_extra_output"]) + bad["query_leaf_prices"]["B4"] -= 1 + reject("unpaid_recursive_child", lambda: check_lowering(bad, schedules["five_extra_output"])) + bad = mutated(cert["lowered"]["five_extra_output"]) + bad["leaf_word"][0][2] = bad["leaf_word"][0][1] + reject("aliased_child_ports", lambda: check_lowering(bad, schedules["five_extra_output"])) + bad = mutated(cert["lowered"]["five_extra_output"]) + # Reverse only one nontrivial operator's coefficient order; count unchanged. + for op in bad["leaf_word"]: + if op[0].startswith("B1."): + op[0] = "B1." + str(1 - int(op[0].split(".")[1])) + reject("wrong_factor_order", lambda: check_lowering(bad, schedules["five_extra_output"])) + dense = module("dense_checks").check_dense(cert) + refs, _ = check_sources() + summary = {"censuses": census_summary, "queries": queries, "leaf_calls": lowered, + "root_controls": controls, "dense": dense, "pinned_reference_files": refs, + "scalar_leaf_baseline": 2 * (sum(balanced_price(n) for n in range(1, 6)) + 31), + "unit_lower_bound": 74, "star_comparators": star_comparators} + target = ROOT / "EXPECTED.json" + if args.write_summary: + target.write_text(json.dumps(summary, indent=2, sort_keys=True) + "\n") + else: + need(json.loads(target.read_text()) == summary, "expected evidence differs") + print("PASS_UNIVERSAL_CONNECTOR_BOUNDARY pairings=945 max_coverage=31 queries=74 leaves=182") + + +if __name__ == "__main__": + main()