diff --git a/.gitattributes b/.gitattributes index 6825630198..9f5e15c6f3 100644 --- a/.gitattributes +++ b/.gitattributes @@ -18,3 +18,10 @@ research/coordinated-frames-and-entrance-banks/** -text -whitespace # Frozen PR210 package and round-nine evidence retain their audited bytes. research/five-stage-source527-banks/** -text -whitespace research/community-round9-audit/** -text -whitespace + +# E8 bit word package: preserve exact bytes for MANIFEST.sha256 +research/e8-bit/** -text -whitespace +# Offline Hamming replay manifest requires exact bytes of pinned inputs. +research/hamming-mutable-basis-complex/** -text -whitespace + +research/hamming-frame-retiming/** -text diff --git a/.github/workflows/hamming-frame-retiming.yml b/.github/workflows/hamming-frame-retiming.yml new file mode 100644 index 0000000000..de8b606f8e --- /dev/null +++ b/.github/workflows/hamming-frame-retiming.yml @@ -0,0 +1,25 @@ +name: Verify Hamming complex and retimed bit composition +on: [push, pull_request] +jobs: + verify: + runs-on: ubuntu-latest + strategy: + fail-fast: false + matrix: + python: ['3.11', '3.14'] + env: + PYTHONDONTWRITEBYTECODE: '1' + PYTHONINTMAXSTRDIGITS: '0' + steps: + - uses: actions/checkout@v4 + - uses: actions/setup-python@v5 + with: + python-version: ${{ matrix.python }} + - run: sudo apt-get update && sudo apt-get install -y libboost-dev + - run: python -m pip install sympy + - run: python -B research/hamming-bit-composition/verify.py "$RUNNER_TEMP/hamming-retiming" + - uses: actions/upload-artifact@v4 + if: always() + with: + name: hamming-retiming-${{ matrix.python }} + path: ${{ runner.temp }}/hamming-retiming diff --git a/Makefile b/Makefile index 61fc5ef410..90998ae735 100644 --- a/Makefile +++ b/Makefile @@ -547,3 +547,18 @@ recycled-bit-full-verify: verify-recycled-bit: recycled-bit-full-verify python3 -m unittest discover -s tests -p 'test_recycled_bit_integration.py' -v + +.PHONY: complex-nine-verify +complex-nine-verify: + @work=$$(mktemp -d "$${TMPDIR:-/tmp}/integer-mult-complex-nine.XXXXXX"); \ + python3 -B research/nine-stage-complex-e8/verify.py --work "$$work/replay" + +.PHONY: e8-bit-complex-nine-verify +e8-bit-complex-nine-verify: + @work=$$(mktemp -d "$${TMPDIR:-/tmp}/integer-mult-e8-nine.XXXXXX"); \ + python3 -B research/e8-bit-complex-nine/verify.py --work "$$work/replay" + +.PHONY: hamming-complex-verify +hamming-complex-verify: + @work=$$(mktemp -d "$${TMPDIR:-/tmp}/integer-mult-hamming.XXXXXX"); \ + python3 -B research/hamming-mutable-basis-complex/verify.py --work "$$work/replay" diff --git a/research/e8-bit-complex-nine-validation/AUDIT.json b/research/e8-bit-complex-nine-validation/AUDIT.json new file mode 100644 index 0000000000..698e827ae8 --- /dev/null +++ b/research/e8-bit-complex-nine-validation/AUDIT.json @@ -0,0 +1,34 @@ +{ + "status": "PASS_INDEPENDENT_COMPRESSED_BIT_TEMPLATE_AUDIT", + "template_sha256": "dfc59b42be1ed281eada6cbd7fb63de773ef4f65563dfdd9691cc5bfd24fb2a7", + "source_frames": 944, + "exact_nested_frame_pairs": 3289, + "exact_reflected_pairs": 3289, + "orthogonal_lift_argument": "Adding the same orthogonal E_s leaves P_V-P_U unchanged; each audited projector is therefore the literal child projector in every one of the nine windows.", + "exact_bank_families": 7785, + "slots_per_bank": 8, + "mutations_rejected": [ + "omit an idle child", + "omit a bridge", + "omit terminal exchange", + "remove a local invocation", + "re-use a helper bank slot", + "understate live stock", + "omit a local paid move", + "wrong reflected copy charge" + ], + "profile": { + "1": 149472, + "2": 67824, + "3": 32256, + "4": 30096, + "5": 22176, + "6": 144, + "7": 5760, + "8": 1296, + "14": 3840, + "28": 3840, + "42": 3840 + }, + "seconds": 3.2433449580566958 +} diff --git a/research/e8-bit-complex-nine-validation/COMBINED.json b/research/e8-bit-complex-nine-validation/COMBINED.json new file mode 100644 index 0000000000..8d6e3f2266 --- /dev/null +++ b/research/e8-bit-complex-nine-validation/COMBINED.json @@ -0,0 +1,115 @@ +{ + "status": "PASS_CONDITIONAL_COMBINED_KAPPA_ABOVE_2_POW_MINUS_10", + "bit_coarse": "1057833103534317/1000000000000000000", + "complex_coarse": "999240641319551/1000000000000000000", + "selected_bit_coarse": "999240640320309/1000000000000000000", + "kappa": "998243154231047/1000000000000000000", + "kappa_decimal": "0.000998243154231047", + "log2_kappa": -9.968321106395894, + "threshold": "1/1024", + "strict_excess": "21680654231047/1000000000000000000", + "gain_over_frozen_361_percent": 24.028587048896043, + "binding": "complex", + "bit_moment_interval": [ + "3369993333393829966960646404286064940326722463344870401020098630731/3369993333393829974333376885877453834204643052817571560137951281152", + "13479973333575319867842585617144259761306889853379481604080394522925/13479973333575319897333507543509815336818572211270286240551805124608" + ], + "next_bit_grid_rejected": true, + "two_rational_engines": true, + "composed_moment_upper": "181709681073901721842257269672082348572976688319042820226994317933927373706449816274478711933304618280330346061081250822716338350555625/181709681073901722637330951972001133588410340171829515070372549795159822028349480831547762678440891390190630401566544483383650407153664", + "halving_depth": 2, + "bootstrap_chain": [ + "384599/10000000000", + "998280589158143913911690982144519/1000000000000000000000000000000000000", + "999239680998170977902563761063920457564851888736371/1000000000000000000000000000000000000000000000000000000", + "999240639361715332529351508962526311254668818740648280292946698258639/1000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "strict_constraints": { + "bit_positive": "999240639361715332529351508962526311254668818740648280292946698258639/1000000000000000000000000000000000000000000000000000000000000000000000000", + "complex_above_bit": "1957835667470648491037473688745331181259351719707053301741361/1000000000000000000000000000000000000000000000000000000000000000000000000", + "complex_below_one_over32": "30250759358680449/1000000000000000000", + "beta_positive": "1/1000000000", + "beta_below_one": "999999999/1000000000", + "leaf_saving_above_bit": "958595026151097491037473688745331181259351719707053301741361/1000000000000000000000000000000000000000000000000000000000000000000000000", + "q_positive": "499620319679858425625314039148733804118371883059069471327732700849026553301741361/500000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "q_below_internal": "999240639361715332529351508962526311254668818740648280292946698258639/500000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "q_below_leaf": "480296753714910460851266195881628116940930528672267299150973446698258639/500000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "c_positive": "499620319804858425625314039148733804118371883059069471327732700849026553301741361/500000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "c_below_one": "499500379680195141574374685960851266195881628116940930528672267299150973446698258639/500000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "q_below_reservations": "1/4000000000000", + "lambda_above_tau": "999240639361715332529351508962526311254668818740648280292946698258639/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "lambda_above_sigma": "1958834908110010206370003040254293707570606388525793950021653946698258639/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "lambda_above_internal": "999240639361715332529351508962526311254668818740648280292946698258639/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "lambda_prime_above_lambda": "999240639361715332529351508962526311254668818740648280292946698258639/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "compact_leaf": "480296753714910460851266195881628116940930528672267299150973446698258639/500000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "compact_reservations": "1/4000000000000", + "lambda_prime_below_one": "499620319679858425625314039148733804118371883059069471327732700849026553301741361/500000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "epsilon_positive": "45454545454500000000000000000000000000000000000000000000000000000000000000000000000/45499965483607259856875028549013521254919851989369006315575248427349911504845612851", + "epsilon_below_one": "45420029107259856875028549013521254919851989369006315575248427349911504845612851/45499965483607259856875028549013521254919851989369006315575248427349911504845612851", + "guard_width": "45420029107259856875028549013521254919851989369006315575248427349911504845612851/45499965483607259856875028549013521254919851989369006315575248427349911504845612851", + "K_geometry": "34136329119982259856875028549013521254919851989369006315575248427349911504845612851/45499965483607259856875028549013521254919851989369006315575248427349911504845612851000000000000", + "K_dominates_log": "45420029073123527755046289156646226370838468114086463585879421034336256418262939495154387149/45499965483607259856875028549013521254919851989369006315575248427349911504845612851000000000000", + "record_suffix": "45420029107259856875028549013521254919851989369006315575248427349911504845612851/45499965483607259856875028549013521254919851989369006315575248427349911504845612851", + "phase_local": "363360232812578889516621132251295010809802393697130672612618412483716790337552896495154387149/363999723868858078855000228392108170039358815914952050524601987418799292038764902808000000000000", + "phase_boundary": "72672046526115805516438418564758979322749661735490252931028477444283159325630650095154387149/72799944773771615771000045678421634007871763182990410104920397483759858407752980561600000000000", + "gamma_sublinear": "1/2000000000000", + "cell_above_band": "90909090908954500034516392740143124971450986478745080148010630993684424751572650088495154387149/181999861934429039427500114196054085019679407957476025262300993709399646019382451404000000000000", + "prime_interval_packing": "45420029107259856875028549013521254919851989369006315575248427349911504845612851/45499965483607259856875028549013521254919851989369006315575248427349911504845612851", + "alpha_positive": "90840058169019748266449838170167481290690457483092779161127848384247761263875790495154387149/90999930967214519713750057098027042509839703978738012631150496854699823009691225702000000000000", + "alpha_below_one": "90909090909045499965483607259856875028549013521254919851989369006315575248427349911504845612851/90999930967214519713750057098027042509839703978738012631150496854699823009691225702000000000000", + "alpha_below_one_fourth": "22659142683634610180171064436336593146169235537201410378626496365290707991158930635004845612851/90999930967214519713750057098027042509839703978738012631150496854699823009691225702000000000000", + "delta_positive": "1/8000000000000", + "delta_below_one_eighth": "999999999999/8000000000000", + "short_record_fallback": "45409080039899224302490600131986310296543341991295874902987929176584489502327418358689836721903542120832428361433992401505758188914422866673811419539830211/45499965483607259856875028549013521254919851989369006315575248427349911504845612851000000000000000000000000000000000000000000000000000000000000000000000000", + "small_field_exposure": "1/1000000000000", + "artificial_boundary": "2548361427315001130736452648916435985400517567883381163752784006369341062055401272198514536838553/363999723868858078855000228392108170039358815914952050524601987418799292038764902808000000000000", + "literal_scalar_guard": "1", + "row_product_gap": "23971789/25", + "balanced_prefix_above_kappa": "45499979973113025362762549152530831256539957198354931233265474900000965141094763633615003/45499965483607259856875028549013521254919851989369006315575248427349911504845612851000000000000000000", + "coordinate_movement_above_kappa": "997485130668332529351508962526311254668818740648280292946698258639/1000000000000000000000000000000000000000000000000000000000000000000000000", + "compact_phase_layer_above_kappa": "14489505765505887520603517310001620105208985924917690226472651053636249150782615003/45499965483607259856875028549013521254919851989369006315575248427349911504845612851000000000000000000", + "bulk_exposure_above_kappa": "997485130668332529351508962526311254668818740648280292946698258639/1000000000000000000000000000000000000000000000000000000000000000000000000", + "Gaussian_arithmetic_above_kappa": "17062501545858487952215656309397380472215049704999302286030944632907270450566255601740003/45499965483607259856875028549013521254919851989369006315575248427349911504845612851000000000000000000", + "scalar_work_above_kappa": "39812484287662117880653170583904141099674975699683805443818568846582226202989062027240003/45499965483607259856875028549013521254919851989369006315575248427349911504845612851000000000000000000", + "dimension_above_kappa": "45409125425438240123098084476349241294232678841887533641623106503883353970054388114141094763633615003/45499965483607259856875028549013521254919851989369006315575248427349911504845612851000000000000000000" + }, + "next_kappa_grid_rejected": true, + "local_and_global_bit_sha256": "55af2a11552c04f5a87268bc2d1798246297874e9e87b50e49773e91cc495c2d", + "independent_bit_audit_sha256": "59625785de14c3df03abe009cdc67c7918b8fcfa8dc5f468c3d363af0494cbb7", + "complex_verification_sha256": "30c99200583f43a83d51f6bbf1a2c45b58b77da4cb8e76c51662ae49698e4e45", + "complex_global_sha256": "68da510fd0144bf5cd8a3b1b638dd527f98899372050867645bbc8eb20bef758", + "finite": { + "unit_additions": 1068696, + "route_items": 823776, + "selector_calls": 1628482176, + "coefficient": "93352550306090768011231627739574369", + "coefficient_bits": 117, + "two_level_coefficient": "895427416993899309353243466281177952042082345387596559413394047269841104121722500", + "two_level_coefficient_bits": 269, + "charged_bound_bits": 512, + "payload_prefix_bits": 117, + "charged_payload_prefix_bits": 192, + "row_coefficient": 18355, + "retained_row_coefficient": 20161, + "cutoff": [ + { + "gap": "960051162165086088309017855481/1000000000000000000000000000000000000", + "cutoff_log2": "39058336745164" + }, + { + "gap": "959322138022097436238936079542435148111263629/1000000000000000000000000000000000000000000000000000000", + "cutoff_log2": "39117723032087411874" + }, + { + "gap": "958593667470648491037473688745331181259351719707053301741361/1000000000000000000000000000000000000000000000000000000000000000000000000", + "cutoff_log2": "39177199612950066624005104" + } + ] + }, + "retained_obligations": [ + "PR370 E8 local bit and nine copied-total admission", + "All-size weighted bit compiler, prime/tape/precision and analytic transfer interfaces", + "PR377 local E8 complex theorem, exact Clifford compiler and common fine-grid/row/analytic interfaces" + ], + "scope": "Conditional finite construction and exact arithmetic assembly. No Lean proof or priority claim; no enumeration of the entire orthogonal cover." +} diff --git a/research/e8-bit-complex-nine-validation/COMPLEX-VERIFICATION.json b/research/e8-bit-complex-nine-validation/COMPLEX-VERIFICATION.json new file mode 100644 index 0000000000..fbb20f1115 --- /dev/null +++ b/research/e8-bit-complex-nine-validation/COMPLEX-VERIFICATION.json @@ -0,0 +1,73 @@ +{ + "status": "PASS_PORTABLE_NINE_STAGE_COMPLEX_FINITE_COMPONENT", + "source_manifest_sha256": "3743f954b5a652e51fa9ae5101318345d79f4c897ff9a29d5c54387b92118458", + "fresh_stages": [ + { + "stage": "frozen-source-integrity", + "returncode": 0, + "seconds": 0.06369700003415346, + "log_sha256": "8275b348307e4aa5a846ed5c81c863c09091acebfbb5bc035f1174bd2d0f2d8f" + }, + { + "stage": "fresh-local-admission", + "returncode": 0, + "seconds": 2.528666125028394, + "log_sha256": "ea59968fc1becce7944aa07c4bf857098ad890905a318fc48ffc8413570c7735" + }, + { + "stage": "finite-data-banks-profile", + "returncode": 0, + "seconds": 2.214772915933281, + "log_sha256": "5710852ec4a262070040312fddad15dda0eedc4b1e32fe1edfaf5639ac6a2110" + }, + { + "stage": "exact-clifford-recipes", + "returncode": 0, + "seconds": 132.9049302500207, + "log_sha256": "839b232b60cfd63fa1fe80146b196d5866d2a6b5631386785fa9e2001a4e972d" + }, + { + "stage": "exact-data-and-cover-phases", + "returncode": 0, + "seconds": 11.187845165957697, + "log_sha256": "0abaa1d2933b0aff9fc78f5ab6f28217d5e8fa4068c37805f42b3af8464f4b31" + }, + { + "stage": "global-template-and-invoice", + "returncode": 0, + "seconds": 22.796479791984893, + "log_sha256": "650765b064e043b0cb6a4ef16e9aade344d9af09f1b9e10a22aec60e16b41313" + }, + { + "stage": "independent-template-two-moments", + "returncode": 0, + "seconds": 2.162089499994181, + "log_sha256": "c7008e701d628c9385265feb811f57f76c06ffc75d70ce35080080b296737491" + }, + { + "stage": "fixed-bit-outer-check", + "returncode": 0, + "seconds": 0.030897459015250206, + "log_sha256": "72b2e4e23347fd983b3eaf8185ce0e17b756bfb2afafbf22ab26411848011cba" + } + ], + "complex_coarse": "999240641319551/1000000000000000000", + "fixed_bit_kappa": "804849251275843/1000000000000000000", + "new_final_kappa_claim": false, + "final_kappa_one_percent_milestone_reached": false, + "proof": "work/complex-nine-native/PROOF.txt", + "receipt_sha256": { + "INDEPENDENT-TEMPLATE-AUDIT.json": "34b80dc65161caaf5bcf348eb7307e92df6265dcb4a5f61993ac07410d06978c", + "CLIFFORD-REVIEW.json": "aae02ae2ddeb36a52b82f694f29268e15bc4a003eedadec3d95d4e10b9002fcc", + "DATA-PHASES.json": "f621f6d4296cb215f334830356c5f79fe10d6d04d15b3ccda76ba0885ab67d0a", + "CLIFFORD-RECIPES.json": "5bfabfdf50aff6d3387d7eb702dbba740b4ca64e7a449ec4924cc9d9f34b6d09", + "GLOBAL-TEMPLATE.json.gz": "1b84904a31a733aab9bfdda3f528c06719f590d2133a43687a8bded955dc991e", + "OUTER-FIXED-BIT.json": "c157055c115b9c0706e672bc73873db93580d2abf46043e6511399e79bd6502d", + "GLOBAL-REVIEW.json": "68da510fd0144bf5cd8a3b1b638dd527f98899372050867645bbc8eb20bef758", + "PROOF.txt": "ea0edb8cfb6b2f2c1adb2de12cc0aa5fb7c57e649033528565af3e52087beda7", + "local-admission/UPSTREAM-GUARD.json": "ca86f125cffd33633bf0204f1c12930a07d5fb760a341269311bce377a2ed687", + "local-admission/INDEPENDENT-AUDIT.json": "9b6eaca84d3bb0450bbbc6bca3fbc3931f0654a2c52c283b1fb666557adadaee" + }, + "seconds": 173.895036916947, + "scope": "The explicit proof retains local E8, Clifford/compiler, common-grid and row/analytic interfaces. No Lean kernel build, astronomical cover enumeration, certificate-producer regeneration or improved bit-side theorem is claimed." +} \ No newline at end of file diff --git a/research/e8-bit-complex-nine-validation/GEOMETRY.json.gz b/research/e8-bit-complex-nine-validation/GEOMETRY.json.gz new file mode 100644 index 0000000000..19725bec46 Binary files /dev/null and b/research/e8-bit-complex-nine-validation/GEOMETRY.json.gz differ diff --git a/research/e8-bit-complex-nine-validation/GLOBAL.json b/research/e8-bit-complex-nine-validation/GLOBAL.json new file mode 100644 index 0000000000..21bc6dcc7b --- /dev/null +++ b/research/e8-bit-complex-nine-validation/GLOBAL.json @@ -0,0 +1,165 @@ +{ + "status": "PASS_SOURCE_BOUND_NINE_STAGE_BIT_TEMPLATE", + "h": 8, + "m": 64, + "v": 120, + "R": 865, + "replicas": 8, + "live": 15465, + "physical": 15474, + "word_sha256": "1fb726ea3818fe0837cceb0dd22a71a0814f064e5e781628104610d6468e0e55", + "source_records_sha256": "58683148e56b76e33705e418df35613ce99934f5e55056dea7abd8474151b3c5", + "local_checks": { + "forward": { + "copies": 9, + "adds": 14603, + "records": 18824, + "all_columns": 1105, + "cancellation_free_row_l1": 742, + "profile": { + "1": 2076, + "2": 942, + "3": 448, + "4": 418, + "5": 308, + "6": 2, + "8": 18 + }, + "sha256": "2b3bc12c3789ed22785189e793b293628e7c71b95411208119455a7b828a7f6b" + }, + "reverse": { + "copies": 9, + "adds": 14603, + "records": 18824, + "all_columns": 1105, + "cancellation_free_row_l1": 6308, + "profile": { + "1": 2076, + "2": 942, + "3": 448, + "4": 418, + "5": 308, + "6": 2, + "8": 18 + }, + "sha256": "f7ef54ad05f52c37b01f4d1ba3ca9b2b9a9ffc10e54099e2d3634cdfd0e8614a" + } + }, + "scalar_stages": [ + { + "stage": 0, + "all_columns": 8745, + "helper_columns": 7785, + "reverse": false + }, + { + "stage": 1, + "all_columns": 8745, + "helper_columns": 7785, + "reverse": true + }, + { + "stage": 2, + "all_columns": 8745, + "helper_columns": 7785, + "reverse": false + }, + { + "stage": 3, + "all_columns": 8745, + "helper_columns": 7785, + "reverse": true + }, + { + "stage": 4, + "all_columns": 8745, + "helper_columns": 7785, + "reverse": false + }, + { + "stage": 5, + "all_columns": 8745, + "helper_columns": 7785, + "reverse": true + }, + { + "stage": 6, + "all_columns": 8745, + "helper_columns": 7785, + "reverse": false + }, + { + "stage": 7, + "all_columns": 8745, + "helper_columns": 7785, + "reverse": true + }, + { + "stage": 8, + "all_columns": 8745, + "helper_columns": 7785, + "reverse": false + } + ], + "independent_unbanked_scalar_columns": 8745, + "all_scalar_columns_restored": true, + "geometry_sha256": "0bcff6cf3e243ad9192a08d0ff4bc14ed28f10d0b7a1ed6fbe378bdcc8da7048", + "template_sha256": "dfc59b42be1ed281eada6cbd7fb63de773ef4f65563dfdd9691cc5bfd24fb2a7", + "emitted_program_sha256": "65671c2b8addb093c74a89d418d10983016a9c5430d6c8de81844e63396bb285", + "emitted_events": 1355328, + "local_invocations": 72, + "bank_assignments": 62280, + "banks_per_stage": 865, + "whole_rank8_slots_per_bank": 8, + "padding_calls": 0, + "profile": { + "1": 149472, + "2": 67824, + "3": 32256, + "4": 30096, + "5": 22176, + "6": 144, + "7": 5760, + "8": 1296, + "14": 3840, + "28": 3840, + "42": 3840 + }, + "paid_calls": 320544, + "rank_mass": 987264, + "deficit": 2496, + "maxchild": 42, + "halving_depth": 2, + "halving_integer_inequality": [ + 4096, + 3528 + ], + "local_additions": 14603, + "bridge_additions": 17280, + "copy_erase_episodes": 648, + "global_prefix_bound": "93352550306090768010924318804410368", + "global_prefix_bits": 117, + "charged_prefix_bits": 192, + "omitted_bridge_shears_rejected": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17 + ], + "scope": "Complete source-bound finite cover template. Local and unbanked global F2 columns are replayed; arbitrary physical bank dirt follows by injective owner routes and the all-column local theorem. Astronomical cover enumeration and all-size compiler interfaces remain explicit inherited assumptions.", + "seconds": 3.393421999993734 +} diff --git a/research/e8-bit-complex-nine-validation/HISTORICAL-CHECKS.json b/research/e8-bit-complex-nine-validation/HISTORICAL-CHECKS.json new file mode 100644 index 0000000000..42fc012b64 --- /dev/null +++ b/research/e8-bit-complex-nine-validation/HISTORICAL-CHECKS.json @@ -0,0 +1,9 @@ +{ + "fresh_eight_stage_component": "PASS", + "make_complex_nine_verify": "PASS", + "make_gen4_bank_verify": "PASS", + "fixed_baseline_make_verify": "FAIL", + "local_remote_commit_match": "PASS", + "fixed_baseline_make_verify_exit_code": 2, + "baseline_failure_note": "The full historical make verify stopped on the unchanged pinned base at verify-strips/skip-suffix: Apple clang++ rejects -fopenmp. This is a platform/toolchain failure. A full-suite pass is not claimed; the new complex component and selected gen4 regression checks passed separately." +} diff --git a/research/e8-bit-complex-nine-validation/README.md b/research/e8-bit-complex-nine-validation/README.md new file mode 100644 index 0000000000..ada4d6fa18 --- /dev/null +++ b/research/e8-bit-complex-nine-validation/README.md @@ -0,0 +1,3 @@ +These are fresh contributor validation receipts for the source manifest named in VERIFICATION.json. Reproduce them with `make e8-bit-complex-nine-verify`. The full pinned #370 and #377 packages and all four new component checks were rebuilt in a fresh directory without network access. The large emitted template is regenerated, not taken as a trusted input. These receipts record conditional finite verification, not an independent human review or a formal proof of the entire multiplication theorem. HISTORICAL-CHECKS.json separately records earlier checks and the unchanged historical suite's Apple Clang/OpenMP limitation. + +GEOMETRY.json.gz decompresses byte-for-byte to the original generated GEOMETRY.json. Its uncompressed SHA256 is 0bcff6cf3e243ad9192a08d0ff4bc14ed28f10d0b7a1ed6fbe378bdcc8da7048. diff --git a/research/e8-bit-complex-nine-validation/RECEIPTS-MANIFEST.json b/research/e8-bit-complex-nine-validation/RECEIPTS-MANIFEST.json new file mode 100644 index 0000000000..e47fe0e899 --- /dev/null +++ b/research/e8-bit-complex-nine-validation/RECEIPTS-MANIFEST.json @@ -0,0 +1,17 @@ +{ + "GEOMETRY.json.gz": "5c980202227859e8bb9b863f94503930c2a59d460c0421356688e2b0d828b4a1", + "UPSTREAM-BIT-KAPPA.json": "e51153a62f1172823238c2a5f0efbfb4d51ea601c06cd679e0ff2528d6b6e5f1", + "COMBINED.json": "6043a7486790ac8ca04dc67ddf5b57076e7c880b66eb456127c6cd933c77764a", + "COMPLEX-VERIFICATION.json": "30c99200583f43a83d51f6bbf1a2c45b58b77da4cb8e76c51662ae49698e4e45", + "AUDIT.json": "59625785de14c3df03abe009cdc67c7918b8fcfa8dc5f468c3d363af0494cbb7", + "HISTORICAL-CHECKS.json": "e92ba8da09947bc9c19901898674ab3778711f49bc82a277bf3caee8e4122253", + "README.md": "e1cf9756b263540de3d41d83292b09b626d99f72ce6e64b17f715183730766d8", + "GLOBAL.json": "55af2a11552c04f5a87268bc2d1798246297874e9e87b50e49773e91cc495c2d", + "VERIFICATION.json": "dc12c0aba2e83e769484171ecf6e619d5ad35c894e9b05e112b90fb7bd009f22", + "logs/compressed-bit-geometry.log": "587b16783cca4fd0557ff53c2b6ff419ff6292792a275e98d65dd7dd65ec4734", + "logs/source-bound-bit-word.log": "f7b68d4546df23e6258e4317c0545c52d13c5db13cf983d2ccedd28b0f989acf", + "logs/two-moments-finite-bill-combined-assembly.log": "374c6f6db0db562b206c7da8178b79af6c4c13063dc2bb20b84b2b48ac6e5bdb", + "logs/pinned-pr370-full-rebuild.log": "224602d4d0c5843738b0ab68377ee7962f1c509c2e87da03b7fdbbd9ce2471ed", + "logs/independent-bit-template-audit.log": "75434cdb736df4a12bd0f9213b2c139460c26430254859e954eeb5f27b65f378", + "logs/pinned-pr377-full-rebuild.log": "644c10c0dbadc55371d236218ac7ab33ad11893489e41e49ba60d8949ee3a7b8" +} diff --git a/research/e8-bit-complex-nine-validation/UPSTREAM-BIT-KAPPA.json b/research/e8-bit-complex-nine-validation/UPSTREAM-BIT-KAPPA.json new file mode 100644 index 0000000000..8d2a99a2b4 --- /dev/null +++ b/research/e8-bit-complex-nine-validation/UPSTREAM-BIT-KAPPA.json @@ -0,0 +1,29 @@ +{ + "word": "/Users/chenzhihao/Documents/Codex/2026-10-11/integer-mult-joint-breakthrough/work/e8-bit-complex-nine-final-check/bit-local/records", + "h": 8, + "T": 1, + "maxchild": 18, + "bit_moment_interval": [ + "1684996666696914984034836168451063206534075386629062984350406822089/1684996666696914987166688442938726917102321526408785780068975640576", + "13479973333575319872278689347608505652272603093032503874803254576713/13479973333575319897333507543509815336818572211270286240551805124608" + ], + "normalized_histogram": { + "1": 10380, + "2": 4710, + "3": 2240, + "4": 2330, + "5": 1540, + "6": 10, + "8": 90, + "14": 240, + "7": 240, + "18": 240 + }, + "W": 1345, + "m": 40, + "bit_coarse": "452036410121261/500000000000000000", + "complex_coarse": "876248285600677/1000000000000000000", + "binding": "complex", + "kappa": "875481145306751/1000000000000000000", + "kappa_float": 0.000875481145306751 +} \ No newline at end of file diff --git a/research/e8-bit-complex-nine-validation/VERIFICATION.json b/research/e8-bit-complex-nine-validation/VERIFICATION.json new file mode 100644 index 0000000000..17ca551786 --- /dev/null +++ b/research/e8-bit-complex-nine-validation/VERIFICATION.json @@ -0,0 +1,161 @@ +{ + "status": "PASS_FRESH_CONDITIONAL_E8_BIT_COMPLEX_NINE", + "source_manifest_sha256": "93aadcc9a94e6a8e84ec4b8379c6c021115aa6621d462d5982b1795e42b1e637", + "pins_sha256": "d4f577d767428a26231375a0207ae1a2d3ee4c7394e8b6e23e1c782b2195a8ce", + "stages": [ + { + "stage": "pinned-pr370-full-rebuild", + "returncode": 0, + "seconds": 79.9720267499797, + "log_sha256": "224602d4d0c5843738b0ab68377ee7962f1c509c2e87da03b7fdbbd9ce2471ed" + }, + { + "stage": "pinned-pr377-full-rebuild", + "returncode": 0, + "seconds": 174.03994100005366, + "log_sha256": "644c10c0dbadc55371d236218ac7ab33ad11893489e41e49ba60d8949ee3a7b8" + }, + { + "stage": "compressed-bit-geometry", + "returncode": 0, + "seconds": 3.0779689999762923, + "log_sha256": "587b16783cca4fd0557ff53c2b6ff419ff6292792a275e98d65dd7dd65ec4734" + }, + { + "stage": "source-bound-bit-word", + "returncode": 0, + "seconds": 3.444278209004551, + "log_sha256": "f7b68d4546df23e6258e4317c0545c52d13c5db13cf983d2ccedd28b0f989acf" + }, + { + "stage": "independent-bit-template-audit", + "returncode": 0, + "seconds": 3.5283079580403864, + "log_sha256": "75434cdb736df4a12bd0f9213b2c139460c26430254859e954eeb5f27b65f378" + }, + { + "stage": "two-moments-finite-bill-combined-assembly", + "returncode": 0, + "seconds": 0.30876962502952665, + "log_sha256": "374c6f6db0db562b206c7da8178b79af6c4c13063dc2bb20b84b2b48ac6e5bdb" + } + ], + "combined": { + "status": "PASS_CONDITIONAL_COMBINED_KAPPA_ABOVE_2_POW_MINUS_10", + "bit_coarse": "1057833103534317/1000000000000000000", + "complex_coarse": "999240641319551/1000000000000000000", + "selected_bit_coarse": "999240640320309/1000000000000000000", + "kappa": "998243154231047/1000000000000000000", + "kappa_decimal": "0.000998243154231047", + "log2_kappa": -9.968321106395894, + "threshold": "1/1024", + "strict_excess": "21680654231047/1000000000000000000", + "gain_over_frozen_361_percent": 24.028587048896043, + "binding": "complex", + "bit_moment_interval": [ + "3369993333393829966960646404286064940326722463344870401020098630731/3369993333393829974333376885877453834204643052817571560137951281152", + "13479973333575319867842585617144259761306889853379481604080394522925/13479973333575319897333507543509815336818572211270286240551805124608" + ], + "next_bit_grid_rejected": true, + "two_rational_engines": true, + "composed_moment_upper": "181709681073901721842257269672082348572976688319042820226994317933927373706449816274478711933304618280330346061081250822716338350555625/181709681073901722637330951972001133588410340171829515070372549795159822028349480831547762678440891390190630401566544483383650407153664", + "halving_depth": 2, + "bootstrap_chain": [ + "384599/10000000000", + "998280589158143913911690982144519/1000000000000000000000000000000000000", + "999239680998170977902563761063920457564851888736371/1000000000000000000000000000000000000000000000000000000", + "999240639361715332529351508962526311254668818740648280292946698258639/1000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "strict_constraints": { + "bit_positive": "999240639361715332529351508962526311254668818740648280292946698258639/1000000000000000000000000000000000000000000000000000000000000000000000000", + "complex_above_bit": "1957835667470648491037473688745331181259351719707053301741361/1000000000000000000000000000000000000000000000000000000000000000000000000", + "complex_below_one_over32": "30250759358680449/1000000000000000000", + "beta_positive": "1/1000000000", + "beta_below_one": "999999999/1000000000", + "leaf_saving_above_bit": "958595026151097491037473688745331181259351719707053301741361/1000000000000000000000000000000000000000000000000000000000000000000000000", + "q_positive": "499620319679858425625314039148733804118371883059069471327732700849026553301741361/500000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "q_below_internal": "999240639361715332529351508962526311254668818740648280292946698258639/500000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "q_below_leaf": "480296753714910460851266195881628116940930528672267299150973446698258639/500000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "c_positive": "499620319804858425625314039148733804118371883059069471327732700849026553301741361/500000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "c_below_one": "499500379680195141574374685960851266195881628116940930528672267299150973446698258639/500000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "q_below_reservations": "1/4000000000000", + "lambda_above_tau": "999240639361715332529351508962526311254668818740648280292946698258639/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "lambda_above_sigma": "1958834908110010206370003040254293707570606388525793950021653946698258639/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "lambda_above_internal": "999240639361715332529351508962526311254668818740648280292946698258639/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "lambda_prime_above_lambda": "999240639361715332529351508962526311254668818740648280292946698258639/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "compact_leaf": "480296753714910460851266195881628116940930528672267299150973446698258639/500000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "compact_reservations": "1/4000000000000", + "lambda_prime_below_one": "499620319679858425625314039148733804118371883059069471327732700849026553301741361/500000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "epsilon_positive": "45454545454500000000000000000000000000000000000000000000000000000000000000000000000/45499965483607259856875028549013521254919851989369006315575248427349911504845612851", + "epsilon_below_one": "45420029107259856875028549013521254919851989369006315575248427349911504845612851/45499965483607259856875028549013521254919851989369006315575248427349911504845612851", + "guard_width": "45420029107259856875028549013521254919851989369006315575248427349911504845612851/45499965483607259856875028549013521254919851989369006315575248427349911504845612851", + "K_geometry": "34136329119982259856875028549013521254919851989369006315575248427349911504845612851/45499965483607259856875028549013521254919851989369006315575248427349911504845612851000000000000", + "K_dominates_log": "45420029073123527755046289156646226370838468114086463585879421034336256418262939495154387149/45499965483607259856875028549013521254919851989369006315575248427349911504845612851000000000000", + "record_suffix": "45420029107259856875028549013521254919851989369006315575248427349911504845612851/45499965483607259856875028549013521254919851989369006315575248427349911504845612851", + "phase_local": "363360232812578889516621132251295010809802393697130672612618412483716790337552896495154387149/363999723868858078855000228392108170039358815914952050524601987418799292038764902808000000000000", + "phase_boundary": "72672046526115805516438418564758979322749661735490252931028477444283159325630650095154387149/72799944773771615771000045678421634007871763182990410104920397483759858407752980561600000000000", + "gamma_sublinear": "1/2000000000000", + "cell_above_band": "90909090908954500034516392740143124971450986478745080148010630993684424751572650088495154387149/181999861934429039427500114196054085019679407957476025262300993709399646019382451404000000000000", + "prime_interval_packing": "45420029107259856875028549013521254919851989369006315575248427349911504845612851/45499965483607259856875028549013521254919851989369006315575248427349911504845612851", + "alpha_positive": "90840058169019748266449838170167481290690457483092779161127848384247761263875790495154387149/90999930967214519713750057098027042509839703978738012631150496854699823009691225702000000000000", + "alpha_below_one": "90909090909045499965483607259856875028549013521254919851989369006315575248427349911504845612851/90999930967214519713750057098027042509839703978738012631150496854699823009691225702000000000000", + "alpha_below_one_fourth": "22659142683634610180171064436336593146169235537201410378626496365290707991158930635004845612851/90999930967214519713750057098027042509839703978738012631150496854699823009691225702000000000000", + "delta_positive": "1/8000000000000", + "delta_below_one_eighth": "999999999999/8000000000000", + "short_record_fallback": "45409080039899224302490600131986310296543341991295874902987929176584489502327418358689836721903542120832428361433992401505758188914422866673811419539830211/45499965483607259856875028549013521254919851989369006315575248427349911504845612851000000000000000000000000000000000000000000000000000000000000000000000000", + "small_field_exposure": "1/1000000000000", + "artificial_boundary": "2548361427315001130736452648916435985400517567883381163752784006369341062055401272198514536838553/363999723868858078855000228392108170039358815914952050524601987418799292038764902808000000000000", + "literal_scalar_guard": "1", + "row_product_gap": "23971789/25", + "balanced_prefix_above_kappa": "45499979973113025362762549152530831256539957198354931233265474900000965141094763633615003/45499965483607259856875028549013521254919851989369006315575248427349911504845612851000000000000000000", + "coordinate_movement_above_kappa": "997485130668332529351508962526311254668818740648280292946698258639/1000000000000000000000000000000000000000000000000000000000000000000000000", + "compact_phase_layer_above_kappa": "14489505765505887520603517310001620105208985924917690226472651053636249150782615003/45499965483607259856875028549013521254919851989369006315575248427349911504845612851000000000000000000", + "bulk_exposure_above_kappa": "997485130668332529351508962526311254668818740648280292946698258639/1000000000000000000000000000000000000000000000000000000000000000000000000", + "Gaussian_arithmetic_above_kappa": "17062501545858487952215656309397380472215049704999302286030944632907270450566255601740003/45499965483607259856875028549013521254919851989369006315575248427349911504845612851000000000000000000", + "scalar_work_above_kappa": "39812484287662117880653170583904141099674975699683805443818568846582226202989062027240003/45499965483607259856875028549013521254919851989369006315575248427349911504845612851000000000000000000", + "dimension_above_kappa": "45409125425438240123098084476349241294232678841887533641623106503883353970054388114141094763633615003/45499965483607259856875028549013521254919851989369006315575248427349911504845612851000000000000000000" + }, + "next_kappa_grid_rejected": true, + "local_and_global_bit_sha256": "55af2a11552c04f5a87268bc2d1798246297874e9e87b50e49773e91cc495c2d", + "independent_bit_audit_sha256": "59625785de14c3df03abe009cdc67c7918b8fcfa8dc5f468c3d363af0494cbb7", + "complex_verification_sha256": "30c99200583f43a83d51f6bbf1a2c45b58b77da4cb8e76c51662ae49698e4e45", + "complex_global_sha256": "68da510fd0144bf5cd8a3b1b638dd527f98899372050867645bbc8eb20bef758", + "finite": { + "unit_additions": 1068696, + "route_items": 823776, + "selector_calls": 1628482176, + "coefficient": "93352550306090768011231627739574369", + "coefficient_bits": 117, + "two_level_coefficient": "895427416993899309353243466281177952042082345387596559413394047269841104121722500", + "two_level_coefficient_bits": 269, + "charged_bound_bits": 512, + "payload_prefix_bits": 117, + "charged_payload_prefix_bits": 192, + "row_coefficient": 18355, + "retained_row_coefficient": 20161, + "cutoff": [ + { + "gap": "960051162165086088309017855481/1000000000000000000000000000000000000", + "cutoff_log2": "39058336745164" + }, + { + "gap": "959322138022097436238936079542435148111263629/1000000000000000000000000000000000000000000000000000000", + "cutoff_log2": "39117723032087411874" + }, + { + "gap": "958593667470648491037473688745331181259351719707053301741361/1000000000000000000000000000000000000000000000000000000000000000000000000", + "cutoff_log2": "39177199612950066624005104" + } + ] + }, + "retained_obligations": [ + "PR370 E8 local bit and nine copied-total admission", + "All-size weighted bit compiler, prime/tape/precision and analytic transfer interfaces", + "PR377 local E8 complex theorem, exact Clifford compiler and common fine-grid/row/analytic interfaces" + ], + "scope": "Conditional finite construction and exact arithmetic assembly. No Lean proof or priority claim; no enumeration of the entire orthogonal cover." + }, + "final_receipt_sha256": "6043a7486790ac8ca04dc67ddf5b57076e7c880b66eb456127c6cd933c77764a", + "seconds": 264.3735716670053, + "scope": "Offline fresh reconstruction. All inherited supplier/compiler/precision/analytic obligations remain explicit in PROOF.txt. No Lean or priority claim." +} diff --git a/research/e8-bit-complex-nine-validation/logs/compressed-bit-geometry.log b/research/e8-bit-complex-nine-validation/logs/compressed-bit-geometry.log new file mode 100644 index 0000000000..91cdd1622f --- /dev/null +++ b/research/e8-bit-complex-nine-validation/logs/compressed-bit-geometry.log @@ -0,0 +1,5 @@ +compressed geometry 1 +compressed geometry 31 +compressed geometry 61 +compressed geometry 91 +{"status": "PASS_COMPRESSED_NINE_BIT_GEOMETRY_AND_BANK_BLOCKS", "h": 8, "m": 64, "stages": 9, "word_sha256": "1fb726ea3818fe0837cceb0dd22a71a0814f064e5e781628104610d6468e0e55", "local_window": "U direct_sum E_s, with E_s the first s exterior coordinate 7-blocks", "ambient_form": "I_64/2", "bank_slots": [[0, 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], [32, 33, 34, 35, 36, 37, 38, 39], [40, 41, 42, 43, 44, 45, 46, 47], [48, 49, 50, 51, 52, 53, 54, 55], [56, 57, 58, 59, 60, 61, 62, 63]], "route_checks": 1080, "exact_bit_endpoint_operator_checks": 240, "max_route_factors": 77, "route_denominators": [1, 2, 4], "bad_prime_factors": [2], "missing_route_factor_controls": 120, "duplicate_bank_slot_rejected": true, "scope": "All port isometries, stage boundary identities, nested idle ranks, exact bit endpoint operators and bank coordinate slots. Full local-word scalar and chronological lowering are checked separately.", "seconds": 2.6663252499420196} diff --git a/research/e8-bit-complex-nine-validation/logs/independent-bit-template-audit.log b/research/e8-bit-complex-nine-validation/logs/independent-bit-template-audit.log new file mode 100644 index 0000000000..33aea76073 --- /dev/null +++ b/research/e8-bit-complex-nine-validation/logs/independent-bit-template-audit.log @@ -0,0 +1,2 @@ +exact frame projectors 944 nested pairs 3289 +{"status": "PASS_INDEPENDENT_COMPRESSED_BIT_TEMPLATE_AUDIT", "template_sha256": "dfc59b42be1ed281eada6cbd7fb63de773ef4f65563dfdd9691cc5bfd24fb2a7", "source_frames": 944, "exact_nested_frame_pairs": 3289, "exact_reflected_pairs": 3289, "orthogonal_lift_argument": "Adding the same orthogonal E_s leaves P_V-P_U unchanged; each audited projector is therefore the literal child projector in every one of the nine windows.", "exact_bank_families": 7785, "slots_per_bank": 8, "mutations_rejected": ["omit an idle child", "omit a bridge", "omit terminal exchange", "remove a local invocation", "re-use a helper bank slot", "understate live stock", "omit a local paid move", "wrong reflected copy charge"], "profile": {"1": 149472, "2": 67824, "3": 32256, "4": 30096, "5": 22176, "6": 144, "7": 5760, "8": 1296, "14": 3840, "28": 3840, "42": 3840}, "seconds": 3.2433449580566958} diff --git a/research/e8-bit-complex-nine-validation/logs/pinned-pr370-full-rebuild.log b/research/e8-bit-complex-nine-validation/logs/pinned-pr370-full-rebuild.log new file mode 100644 index 0000000000..40f555b183 --- /dev/null +++ b/research/e8-bit-complex-nine-validation/logs/pinned-pr370-full-rebuild.log @@ -0,0 +1,85 @@ +== 0. package manifest + all files match MANIFEST.sha256 +== 1. the word: regenerate from the producer parameters; export the PR249 records +R 865 gates D/A/B/C 120 1756 472 1756 frames 944 + regenerated word equals the shipped word +exported 18824 records, 944 frames, n 1105 ZERO 0 + exported records/states/frames match RECORD-SHA256SUMS +== 2. independent all-column checker (no shared code with the producer) and its negative controls +labels: 120 distinct lines of norm 2 (pairwise |ip| <= 1), spanning rank 8 +legality + exact F2 on all 1105 columns: PASS (gates D/A/B/C = 120/1756/472/1756) +nondegeneracy: 943 used frames, all Gram dets > 0 (positive-definite form); primes in dets: [2] +histogram {1: 10380, 2: 4710, 3: 2240, 4: 2330, 5: 1540, 6: 10, 7: 240, 8: 90, 14: 240, 18: 240} m 40 W 1345 mass 53680 deficit 120 (4v-5L = 120 ) maxchild 18 +no envelope saving in [0.00090407282109368831, 0.00090407282109368831] +bad envelope saving in [0.00090407282024252275, 0.00090407282024252275] +REJECTED drop a phase-B gate :: AssertionError: ('target', 65) +REJECTED phase-B gate at the full frame (y beyond its cap) :: AssertionError: ('frame not nested', 239, 1, 943) +REJECTED drop a dirt compensation read :: AssertionError: ('target', 0) +REJECTED drop a cleanup gate :: AssertionError: ('helper not restored', 936) +REJECTED wrong scatter row :: AssertionError: ('target', 5) +REJECTED phase-A gate frame not nested :: AssertionError: ('frame not nested', 512, 122, 2) +PASS all 6 word-level negative controls rejected +== 3. official PR #266 cohort checkers, generalized: h = 8 frames, NCOPY = 9 copied centres +PASS pairs 0 ADD 14603 mass 8672 COPY24 + five-stage formal columns PASS (PASS_NEW_COHORT249_ALL_FIVE_STAGE_FORMAL_COLUMNS_AND_PREFIX_BILL 1345 columns) + REJECTED drop a phase-B delivery ADD (columns: defining decoder) [local defining-decoder full formal column] + REJECTED ADD at a frame its registers do not stand at [libc++abi: terminating due to uncaught exception of type std::runtime_] + REJECTED MOVE with a wrong rank [libc++abi: terminating due to uncaught exception of type std::runtime_] + REJECTED COPY with a cheaper rank [libc++abi: terminating due to uncaught exception of type std::runtime_] + REJECTED drop a dirt-compensation ADD (columns) [local defining-decoder full formal column] + REJECTED unchanged word with the copy count pinned to h = 8 (NCOPY unset) [libc++abi: terminating due to uncaught exception of type std::runtime_] +PASS all 6 record-level negative controls rejected + regression: unmodified PR #346/#352 sources vs generalized sources (no -DNCOPY), h = 20, on the PR #325 p10b word + legality receipts byte-identical + five-stage columns receipts identical (except wall-clock seconds) +== 4. exact nondegeneracy (E8 Gram) and prime witnesses on every frame +PASS e8ham Gram: 944 frames checked, all nondegenerate and positive definite; prime witnesses valid; max determinant bits 17; primes [2]; by dim {0: 1, 1: 120, 2: 168, 3: 168, 4: 14, 5: 168, 6: 184, 7: 120, 8: 1} + regression (G = I - J/9, h = 20, PR #325 p10b word): the original prime_new.py and the generalized check +PASS prime witnesses for 12885 new frames; max determinant bits 97 ; primes [2, 3, 11] +PASS triple9 Gram: 12885 frames checked, all nondegenerate; prime witnesses valid; max determinant bits 97; primes [2, 3, 11]; by dim {0: 1, 1: 960, 2: 1440, 3: 1440, 5: 940, 6: 180, 7: 520, 8: 279, 10: 359, 12: 275, 13: 500, 14: 352, 15: 698, 16: 120, 17: 1440, 18: 1460, 19: 1920, 20: 1} + same frame count, determinant bits and primes: ('12885', '97', '[2, 3, 11]') +== 5. PR234 five-stage geometry for the E8 labels (W(E8) reflection words as port isometries) + port 1/120 checked (0 reflections) 0s + port 21/120 checked (1 reflections) 0s + port 41/120 checked (1 reflections) 1s + port 61/120 checked (2 reflections) 2s + port 81/120 checked (2 reflections) 2s + port 101/120 checked (2 reflections) 3s +PASS E8 five-stage geometry: all 120 ports (W(E8) reflection words as port isometries), routes involutive, stage boundaries chained, idle gap ranks [14, 14, 7, 7, 18, 18, 4, 4], D_I D_P identity; entrance census {0: 865 helpers}: five-window completion exact, duplicate window rejected +PASS regression: on paired-cube labels (h = 20, G = I - J/9) the generalized routes equal the original literal rho for 3 ports and every stage, and give idle ranks (38, 38, 19, 19, 42, 42, 4, 4) +== 6. banks: exact width-40 tiling of the helper residuals +residual census {8: 865} | freed roles (r = 0) are deleted, not banked +PASS exact width-40 tiling with 1 replicas: (((8, 8, 8, 8, 8), 173),) + regression: generalized tiling output byte-identical to PR #346's tile_check on the p10b word +== 7. copied centres: 9 retained totals at h = 8 (admitted; charged as NCOPY = 9 everywhere) + retained totals 9 > h = 8 ; COPY ranks [8] (full frame); copy loss L = 72, deficit 4v - 5L = 120 + 7b. skipped (ortools not installed) +== 8. complex supplier: Jacob Sussman's E8 unit, PR #352's checks unchanged + Checking the complex program: gx.check1 with the exact scalar identity, and the gxcore mirror. + Checking every complex source label and paid child. + Deriving both complex scalar words and temporary lifetimes. + Merging scalar events, exact frames and all final climbs. + Recomputing complex cover, router, precision and row inequalities. +guard: PASS_FRESH_COMPLEX_LABEL_SCALAR_SPLICE_PRECISION | gx.check1: ACCEPTED (labels, bl | rows 11119 < 20161 +Lean binding: RESULT: REPRODUCED (25 repository files reproduced byte for byte, 0 different, 3 generated files not in the repository) (wht_main_block_B2Ge8x modules regenerated from this certificate) +stand-alone replay: REPLAY ACCEPTED: R=783 W=1263 D=120 cst=72 N=9039 figure=8762479 E8 family: True (0.4 s) +PASS complex coarse saving b = 876248285600677/1000000000000000000 0.000876248285600677 (two engines, 10^-16 fallback, adjacent grid point excluded) +== 9. bit coarse saving and outer assembly (47 constraints), PR #315 engines, h = 8, T = 1 +normalized W 1345 calls 22020 mass 53680 deficit 120 maxchild 18 +bit coarse c = 452036410121261/500000000000000000 0.000904072820242522 (two engines + 1e-16 fallback, adjacent grid excluded) +complex leaf cap itself rejected (leaf_saving_above_bit), as in PR #315 math_check +complex b = 876248285600677/1000000000000000000 0.000876248285600677 | binding: complex +KAPPA = 875481145306751/1000000000000000000 = 8.754811453068e-04 | 47 strict constraints positive, adjacent grid point rejected + regression: generalized vs original certify_bit on the PR #325 p10b word (h = 20, T = 12) + identical kappa receipt fields; p10b kappa 384842019691667/500000000000000000 +== 10. finite bill at m = 40 +finite-bill input: m 40, v 120, R 865, T 1, stock 1345, NCOPY 9, unit additions 14603, rows 742/6308, K 27347440 +PASS finite bill (E8, m = 40): coefficient 1916288151501 (41 bits) < 2^80, q-power bound q^1601, payload prefix 60 bits < 104, delta_tau 25054818195901, reference route {'swap': 7}; all 120 port routes exact elementary programs, at most 77 factors, denominators [1, 2, 4] (powers of two: units modulo every odd q) +PASS regression: on the p = 10 receipts in /Users/chenzhihao/Documents/Codex/2026-10-11/integer-mult-joint-breakthrough/work/e8-bit-complex-nine-final-check/bit-local/regression/loans the generalized bill reproduces the coefficient 24463942022302301 , the moment gaps, the bootstrap chain and the 40-dimensional route program (sha cf655bf5356b...) +== 11. SECONDARY (conditional on PR #363): kappa under the seven-stage complex value; the bit word in B_3 +bit word in B_2 (5 stages, m 40, W 1345, idle [18, 14, 7, 4]): bit coarse c = 452036410121261/500000000000000000 = 9.040728202425e-04 +bit word in B_3 (7 stages, m 56, W 1585, idle [27, 7, 14, 7, 20, 27, 1, 7, 6]): bit coarse c = 968197503705007/1000000000000000000 = 9.681975037050e-04 +kappa [five-stage bit + #352 five-stage complex (PRIMARY)]: 875481145306751/1000000000000000000 = 8.754811453068e-04 (complex-bound) +kappa [five-stage bit + #363 seven-stage complex]: 112907026276423/125000000000000000 = 9.032562102114e-04 (bit-bound) +kappa [seven-stage bit (no construction yet) + #363 seven-stage complex]: 93191395651209/100000000000000000 = 9.319139565121e-04 (complex-bound) +PASS conditional kappa = 875481145306751/1000000000000000000 = 0.000875481145306751 (complex-bound; bit coarse 452036410121261/500000000000000000 = 0.000904072820242522 ) diff --git a/research/e8-bit-complex-nine-validation/logs/pinned-pr377-full-rebuild.log b/research/e8-bit-complex-nine-validation/logs/pinned-pr377-full-rebuild.log new file mode 100644 index 0000000000..3c7837e71d --- /dev/null +++ b/research/e8-bit-complex-nine-validation/logs/pinned-pr377-full-rebuild.log @@ -0,0 +1,9 @@ +frozen-source-integrity +fresh-local-admission +finite-data-banks-profile +exact-clifford-recipes +exact-data-and-cover-phases +global-template-and-invoice +independent-template-two-moments +fixed-bit-outer-check +PASS_PORTABLE_NINE_STAGE_COMPLEX_FINITE_COMPONENT diff --git a/research/e8-bit-complex-nine-validation/logs/source-bound-bit-word.log b/research/e8-bit-complex-nine-validation/logs/source-bound-bit-word.log new file mode 100644 index 0000000000..0f93e07102 --- /dev/null +++ b/research/e8-bit-complex-nine-validation/logs/source-bound-bit-word.log @@ -0,0 +1 @@ +{"status": "PASS_SOURCE_BOUND_NINE_STAGE_BIT_TEMPLATE", "h": 8, "m": 64, "v": 120, "R": 865, "replicas": 8, "live": 15465, "physical": 15474, "word_sha256": "1fb726ea3818fe0837cceb0dd22a71a0814f064e5e781628104610d6468e0e55", "source_records_sha256": "58683148e56b76e33705e418df35613ce99934f5e55056dea7abd8474151b3c5", "independent_unbanked_scalar_columns": 8745, "all_scalar_columns_restored": true, "geometry_sha256": "0bcff6cf3e243ad9192a08d0ff4bc14ed28f10d0b7a1ed6fbe378bdcc8da7048", "template_sha256": "dfc59b42be1ed281eada6cbd7fb63de773ef4f65563dfdd9691cc5bfd24fb2a7", "emitted_program_sha256": "65671c2b8addb093c74a89d418d10983016a9c5430d6c8de81844e63396bb285", "emitted_events": 1355328, "local_invocations": 72, "bank_assignments": 62280, "banks_per_stage": 865, "whole_rank8_slots_per_bank": 8, "padding_calls": 0, "profile": {"1": 149472, "2": 67824, "3": 32256, "4": 30096, "5": 22176, "6": 144, "7": 5760, "8": 1296, "14": 3840, "28": 3840, "42": 3840}, "paid_calls": 320544, "rank_mass": 987264, "deficit": 2496, "maxchild": 42, "halving_depth": 2, "halving_integer_inequality": [4096, 3528], "local_additions": 14603, "bridge_additions": 17280, "copy_erase_episodes": 648, "global_prefix_bits": 117, "charged_prefix_bits": 192, "omitted_bridge_shears_rejected": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17], "scope": "Complete source-bound finite cover template. Local and unbanked global F2 columns are replayed; arbitrary physical bank dirt follows by injective owner routes and the all-column local theorem. Astronomical cover enumeration and all-size compiler interfaces remain explicit inherited assumptions.", "seconds": 3.393421999993734} diff --git a/research/e8-bit-complex-nine-validation/logs/two-moments-finite-bill-combined-assembly.log b/research/e8-bit-complex-nine-validation/logs/two-moments-finite-bill-combined-assembly.log new file mode 100644 index 0000000000..b290c53856 --- /dev/null +++ b/research/e8-bit-complex-nine-validation/logs/two-moments-finite-bill-combined-assembly.log @@ -0,0 +1 @@ +{"status": "PASS_CONDITIONAL_COMBINED_KAPPA_ABOVE_2_POW_MINUS_10", "bit_coarse": "1057833103534317/1000000000000000000", "complex_coarse": "999240641319551/1000000000000000000", "selected_bit_coarse": "999240640320309/1000000000000000000", "kappa": "998243154231047/1000000000000000000", "kappa_decimal": "0.000998243154231047", "log2_kappa": -9.968321106395894, "threshold": "1/1024", "strict_excess": "21680654231047/1000000000000000000", "gain_over_frozen_361_percent": 24.028587048896043, "binding": "complex", "next_bit_grid_rejected": true, "two_rational_engines": true, "halving_depth": 2, "next_kappa_grid_rejected": true, "local_and_global_bit_sha256": "55af2a11552c04f5a87268bc2d1798246297874e9e87b50e49773e91cc495c2d", "independent_bit_audit_sha256": "59625785de14c3df03abe009cdc67c7918b8fcfa8dc5f468c3d363af0494cbb7", "complex_verification_sha256": "30c99200583f43a83d51f6bbf1a2c45b58b77da4cb8e76c51662ae49698e4e45", "complex_global_sha256": "68da510fd0144bf5cd8a3b1b638dd527f98899372050867645bbc8eb20bef758", "retained_obligations": ["PR370 E8 local bit and nine copied-total admission", "All-size weighted bit compiler, prime/tape/precision and analytic transfer interfaces", "PR377 local E8 complex theorem, exact Clifford compiler and common fine-grid/row/analytic interfaces"], "scope": "Conditional finite construction and exact arithmetic assembly. No Lean proof or priority claim; no enumeration of the entire orthogonal cover."} diff --git a/research/e8-bit-complex-nine/MANIFEST.json b/research/e8-bit-complex-nine/MANIFEST.json new file mode 100644 index 0000000000..4bbf2c9746 --- /dev/null +++ b/research/e8-bit-complex-nine/MANIFEST.json @@ -0,0 +1,14 @@ +{ + "files": { + "global_word.py": "2c438be46213e014170e607a745185e45e33c7b7240b833efc86a2330de0d1f6", + "audit.py": "75811327b0d6cbd56aae8e28d72abd42d57c7f3f3630781d045efee2d36446e9", + "README.md": "8d1638afd7526169073a18ac5af495eb0dbbf3348052d45a00e209c1901ee3c6", + "NOTICE.txt": "ae2241615a23063b18a04f1b7a88a52e62b3d7d42e333fbd21e3668567ab83d1", + "geometry.py": "36eeda3184bd009e89462b65c8725d10860c444f8da8f1f87e5f6e50120011ca", + "verify.py": "ac444fff7c10a3a0d82037638029afaf68720654244d6467093a00b8c3e06941", + "certify.py": "550b1408fb3a581dd6b82c90e3f84ad7a9f78746d2be11ffa1cf543d719ae2d4", + "PROOF.txt": "c5f077b849e9add9957ab4ee36095dd47bc678dee7e09baa146dac4c0a0d66b2", + "PINS.json": "d4f577d767428a26231375a0207ae1a2d3ee4c7394e8b6e23e1c782b2195a8ce", + "portable-include/bits/stdc++.h": "420094be2af295eed03a983dd66debbbe9cfb78d8252859f4498a615a0074b99" + } +} diff --git a/research/e8-bit-complex-nine/NOTICE.txt b/research/e8-bit-complex-nine/NOTICE.txt new file mode 100644 index 0000000000..28cfebeb08 --- /dev/null +++ b/research/e8-bit-complex-nine/NOTICE.txt @@ -0,0 +1,25 @@ +Prepared by Zhihao Chen with substantial OpenAI Codex assistance. +New compressed nine-stage bit geometry, source-bound global template, +independent audit, finite bill, combined certificate and documentation: +Apache License 2.0, the repository LICENSE. + +Pinned dependency research/e8-bit is reproduced without modification from +Dylan Crow (utcorvusvolat-dotcom), with Anthropic Claude assistance, PR #370: +https://github.com/CrocSwap/integer-mult-bounds/pull/370 +commit b7fe9cdf2da009c947ff6b334c562bc190b30373. +All LICENSE, NOTICE.md, NOTICE-PR352.md and NOTICE-PR363.md files are retained. +The local E8 bit word and its producer are their contribution, not ours. + +Pinned dependency research/nine-stage-complex-e8 is the independently +developed complex component from PR #377, commit +d0a620fcc99ba012468d61d01f5bb14007076d50: +https://github.com/CrocSwap/integer-mult-bounds/pull/377 +Its inherited sources, source notices and licenses remain unchanged. + +Jacob Sussman introduced the E8 family and complex unit. The preserved +upstream notices credit source527/eumemic, PR234/hcg890, PR266, PR315, +PR346/LJH-217, PR352/DaysSky, PR363/DaysSky, Chafik Boukhalfa, +DreamingOfClouds, Evan McKinney and other original contributors. + +The portable bits/stdc++.h shim contains standard-library includes only; +it changes neither inherited algorithms nor their verification checks. diff --git a/research/e8-bit-complex-nine/PINS.json b/research/e8-bit-complex-nine/PINS.json new file mode 100644 index 0000000000..ea52422bfe --- /dev/null +++ b/research/e8-bit-complex-nine/PINS.json @@ -0,0 +1,167 @@ +{ + "bit_pr": "https://github.com/CrocSwap/integer-mult-bounds/pull/370", + "bit_commit": "b7fe9cdf2da009c947ff6b334c562bc190b30373", + "bit_files": { + "HANDOFF.md": "ce8d68b25c3a36864d80c8fc43c9f84b2fe652a9e7a2a65aa41187ba3cf8e44e", + "LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "MANIFEST.sha256": "d849c69f0d5f4ff64a34dc6ca8a18d1373d16adb643f3a3956cc655796249a16", + "NOTICE-PR352.md": "967e6d7e76e216e4898cf543c75b527e8d397ec1ddba3800cb20701f24c89524", + "NOTICE-PR363.md": "c788ace1c9a99e3292fed6b62b8c942b8ff80e47c4abe4ead344f869afc07d9b", + "NOTICE.md": "025773f32fb43667395e64c627a1752877bdc93afbfe01b106703eee438d21d3", + "PR-STATEMENT.md": "8b24ac1c09b64ca1c545e04c439d9773396e4e92e6b8fe39a2c2a1488163d560", + "README.md": "c1ff70a03a49e362ae3d2f0e349f4d3fa0386c46dd2dc5fd3153c5940e730770", + "VERIFY-LOG.txt": "56914892fbd7d306bf1180d9ed7b502a0526ce0ce3bce774ff1a5dca6d27aced", + "code/bit/checkers/certify_bit_g.py": "c9a31508126f34e7ac95d802c39e8919a872cd705314de5bf3538de1636ce8ce", + "code/bit/checkers/columns_h.cpp": "d1297f9052be4f2496e1ff2a77e4db2c0cdbd7d460d489b4c03e50bf317238ce", + "code/bit/checkers/cost.py": "d55d2b865d1c3d35e343e1a38c592b9172ed8e2596d1107e34d92e2a80c7d03f", + "code/bit/checkers/exactnd_h.py": "28a0d8ee29ac75b8a789705454987f07d618f135ed1f1bd45b97f18bcc4163e3", + "code/bit/checkers/finite_g.py": "a591d8caa9ab50a4c7ec6934c71c93fc18fd14680180b43071e8d9d704f7ac9a", + "code/bit/checkers/geometry_g.py": "b9fa3cd05f36f5fcebfdebfb4a86fb90e92ed3c1d9157c52918ee8c5b563b54f", + "code/bit/checkers/gram_frames.py": "223a5a07731fc315a90a3e48177796babc155c1d9985c7ae5017eff6af2a0608", + "code/bit/checkers/json.hpp": "aaf127c04cb31c406e5b04a63f1ae89369fccde6d8fa7cdda1ed4f32dfc5de63", + "code/bit/checkers/legality_h.cpp": "6c1ef2b24e57781d6951c172a1024fc4300e6fd392c9d6672079a7806ab663b3", + "code/bit/checkers/tile_g.py": "8140eec180e42202f2c6a9f11f5c92885e60861c38a7611dd805c524e3438138", + "code/bit/export_records.py": "8a5999601f917dbb492bb9ae9a344611f18cc7cedc53dc3c76496a369e530eb3", + "code/bit/independent/centres_sat.py": "f69379968367544807db2f0cf14359977e56299383b3edcc4469ddea7c7ecb40", + "code/bit/independent/checkword.py": "11bf9620ca9db16d52d9fe806b814fc9ec9a89c4d7645354d1861d96f6e805ad", + "code/bit/independent/mutate.py": "0ff65aace5da4b57d96235bf830f8f11969322e75134d498aeb70e9753ec6b0d", + "code/bit/mutate_records.py": "b0e75d6550412a7be4017695e6b237392b611bb852ad8ff309d6682c9f166a4e", + "code/bit/producer/compile.py": "60fea6a9d6617a3f87376d3fda040642e9cb70e7c179015e03ede8d289f30357", + "code/bit/producer/compile2.py": "0e23d4282ceb75768e82631da016aaff9818aec53c7d75a6b2a28ee1b1160dc3", + "code/bit/producer/e8lib.py": "4f8a6843e83bc4f7055d7337f33dbe12ce499051f46bee1b81bbf6b34c652574", + "code/bit/producer/frames.py": "ba71f77dd3e3c1c54f361c066cebe9faadbc78db46376046e7af625bf1de8c24", + "code/bit/producer/fullword.py": "0daf87599e9e48646b985ad87351c56c1b73cfc99cdf9eca081483846ddbfa90", + "code/bit/producer/ham1.py": "359040fb432fd392472af6b8f5dca0234dd6c2be744a791df27ba62bc5da5175", + "code/bit/producer/ham2.py": "fdf0af785ce697bd7f80b4e75f7163735f3b599d9dc42f652f0ffdbdf18ea8bf", + "code/bit/producer/params-r865.json": "1256c54debe0a551da8e24896ab73ef0bd4a5233ff8e6fedf21a9e6301d6e6f3", + "code/bit/producer/price.py": "46c858e60ba0a117bf8227b864abf55e85ebee2d56a0dce64472b706499ac405", + "code/bit/producer/search2.py": "4999c5d6bac9757e4236c45435201631eae21f644dc9543d8c0b6e3cc8360daf", + "code/bit/receipts_e8.py": "935ea65d9c6739e868ccf1aa439bd3c246657dfc887e4a0222a8f0901a5b41a5", + "code/bit/regression/certify_bit.py": "fc03e8f7bf73d7d70346b87c835d44508b0581c9ff9aec708fbbd4f0121e0394", + "code/bit/regression/columns_h_pr346.cpp": "26f5c9be3a7f545d50be458e3d17403921b5542a7dcd2986c848664a774977a8", + "code/bit/regression/cost.py": "d55d2b865d1c3d35e343e1a38c592b9172ed8e2596d1107e34d92e2a80c7d03f", + "code/bit/regression/json.hpp": "aaf127c04cb31c406e5b04a63f1ae89369fccde6d8fa7cdda1ed4f32dfc5de63", + "code/bit/regression/legality_h_pr346.cpp": "5661d0b91e07d95736bde4c1824f27bebaecce0a84e38403f5391ebc51a52056", + "code/bit/regression/prime_new.py": "7bd5cb48537621f1217d174274d42483da4e2d02feec238643c798c36b30366a", + "code/bit/regression/prime_witnesses.py": "98cd03bc9582e7bd0ab194c191ea8eea940539e510051443ab9fd3e572a364ab", + "code/bit/regression/stage_cohort.py": "6c288f6f234b528c1a7c0a4adfb724e91e0fe6b18c8dffad96af3f973de1829a", + "code/bit/regression/tile_check.py": "38c3f78daac118395565a65fa3543b1c349638ff2519ce7fda0dad2d788e90ae", + "code/complex/certify_complex.py": "7e480b7761fa700944a7dca41ccbefd530203b5e9168b6b37fe879b7e6da57fa", + "code/complex/code/complex_basis.py": "52d68781eaf6d9decf02446a532a7336fcf15924a9f6781ba0833d038decb9f8", + "code/complex/code/complex_gx.py": "ccc924537db0c0d55f0c1934e79b8cf4d85b4fb336473d7b42d69e12557aa9f2", + "code/complex/code/complex_labels.py": "e000ee131389fec427388b85f632879cbaaf10e5e5d979a47d6307d64ce58982", + "code/complex/code/complex_scalars.py": "38e985ebe8c8e7f8c83c03828abde0c80be418caf95e97afdf2d0c357c0ed919", + "code/complex/code/complex_splice.py": "aaf46c8e5c68875b8315892e924e082b2f219f8d042dd14937e7cd2f72456dce", + "code/complex/code/p10pins.py": "93b78a2e038b23264d04836928c78b6ebf33b87ff3dcc0e43ba0f1748fadd143", + "code/complex/code/scatter.py": "dfd1afbbb3ff86f54db6a0313916403ec8ee6f939caa62f3edcc9d7a151bff95", + "code/complex/inputs/complex/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "code/complex/inputs/complex/NOTICE": "9419dd03a2f52cf8bdfc4d18216ce29f263ab583b27f01ced8e420985bcb7c81", + "code/complex/inputs/complex/retained/FINITE_BRIDGE.txt": "66d8f4ea8752abd89952d6674a636575a0db16e18b1c16e293f48f64242f0c46", + "code/complex/inputs/complex/retained/compact-control-layout.tex": "2bc28e50f3eb092195294cafa81213e520f6d42e7935e9905ad8a6199e2a7c87", + "code/complex/inputs/complex/retained/compact-control-movement.tex": "b963c3d2f4e1b7059aa289bb4b4ac89b688920bcf42f5b20d7698cdef0132cc6", + "code/complex/inputs/complex/retained/copied-centers-assembly.tex": "00117892971ae766188ace0af03030c44164fda105e42b70d84f52c3339a7dcb", + "code/complex/inputs/complex/retained/copied-centers-lemma.tex": "d0ce6d3d504996aadb098227885224e48df46101daec8893523a0a8b7364d8fe", + "code/complex/inputs/complex/retained/endpoint-gauge-complex.tex": "dfee33b0281e5551bb6927f757ff0240abade60ae1800f715afd88853ae0191e", + "code/complex/inputs/complex/retained/general-clifford-frames.tex": "c9bb9655b594583c6b4bab8cb485233f1d1e588f83858cf1e4c3530cee8fed54", + "code/complex/inputs/complex/retained/stopped-product-complex.tex": "4738089103a4b263b3b0ef458f5ef35519c696f1ea871ae79e508d3720f5870a", + "code/complex/inputs/complex/source-pins.json": "0d76527bf9c259b9532466a7b056ad6ff118867a96e044ff8e1a24aca12e1dbb", + "code/complex/inputs/complex/sources/Work__Bridge__Cert.lean": "5c24746a6330907b9b37d6064095035a58575d64ce793d6d7c9881121fdc3980", + "code/complex/inputs/complex/sources/Work__Bridge__Net.lean": "cf7d7d330b1bffe2e66712c873e647b13dc32db1ccfc0e0f4cd62ee6caf584f0", + "code/complex/inputs/complex/sources/Work__Carrier__Live.lean": "6d0649eb62589e66057f044e1e2103fc42f3f57a1498f82a26565bd8eb4026d0", + "code/complex/inputs/complex/sources/Work__Carrier__Phases.lean": "71dc3dda23dfe510d5d53cbada3a6c540cd1dc2825503fda618a5bd6cfc3e812", + "code/complex/inputs/complex/sources/Work__Fourier__Main.lean": "2e8e88efd4dcbdf0b1a6e39ce7eea8c5fd5ffee2faf360a8c0c9cba84c0e4ef3", + "code/complex/inputs/complex/sources/Work__GCert__Chain__Geom.lean": "c302f5834287421f11f3b0da7112fcde876cbc702896f2af4145b2d72ee393a2", + "code/complex/inputs/complex/sources/Work__GCert__Chain__InvThm.lean": "ade7e7873da75ca63a4b5ce2f562dde9c12bfbb69d87d7ae831039ff790e5adb", + "code/complex/inputs/complex/sources/Work__GCert__Chain__NetCert.lean": "22ae34809466b4ac2a2c5cdde526f51ff246f5189f7c142b38aa4c0dcffb04a4", + "code/complex/inputs/complex/sources/Work__GCert__Chain__NetDef.lean": "6e17a68b1e988969f6eb77000028f7ed877e687b8ad3976ec1707fcfe1d2f520", + "code/complex/inputs/complex/sources/Work__GCert__Chain__NetStage.lean": "c122bc01392a6fdcc0bee918fed81804d3c9b1d3e071016dab65a4ed804ef0b6", + "code/complex/inputs/complex/sources/Work__GCert__Chain__Phased.lean": "0de429c80231334f1ce92575c1e8ac382ca2d5e7d956767b547639a8941d9a8c", + "code/complex/inputs/complex/sources/Work__GCert__Chain__WinB.lean": "c33ec3fce09c0971c32ddcbb86d9383ffbe4c6d05cf36f20460005e6547bb845", + "code/complex/inputs/complex/sources/Work__GCert__Data__B2Gp193Main.lean": "cb61f304da51f1dd0a2ec25bca4b63eb095eeb2863289e1e2bdee7c82beff48b", + "code/complex/inputs/complex/sources/Work__GCert__Data__Glue.lean": "d5314f2b93a7f0e1c949fb502331825bfc6d9d8762d35f865443e7c95b6c7ef7", + "code/complex/inputs/complex/sources/Work__GCert__Data__InstB2Gp193.lean": "9587ddb9961f44938032b609307ab91c0b0e757e3991f1ad95480dd50fd4f72b", + "code/complex/inputs/complex/sources/Work__GCert__Data__P193Cert.lean": "d92ee6889be4753fc99f467bd84039743325123a1165128378b9c906a04f2703", + "code/complex/inputs/complex/sources/Work__GCert__Data__P193Price.lean": "0299bcd0fe255960eec682eef0f045f7e5cb1e4711af2aab4393526eae2caea3", + "code/complex/inputs/complex/sources/Work__GCert__Data__P193ScalOK.lean": "479434815822e98f015e335361089c3788d00dc3dd39c2944f75410aa0c158fe", + "code/complex/inputs/complex/sources/Work__GCert__Data__RateB2Gp193x.lean": "6b40cac1481c931d47b1a092e382d04716ede0e785c492a2f2983e886a257c3f", + "code/complex/inputs/complex/sources/Work__GCert__Data__Raw.lean": "aba94a004c94dcae7cf3047c88a6da9561555f4ebe8ab92e299e6ce09ee7aa66", + "code/complex/inputs/complex/sources/Work__GCert__Data__SolutionB2Gp193x.lean": "45c768c9d71a7cc18bd6db74cb036db880d89580ca60557bb4a492280296b169", + "code/complex/inputs/complex/sources/Work__GFrame__Engine__Adapt.lean": "feec0a3828867968a5c7c2c30b86ed70449abc3c660a60ada67203a75bae2ef7", + "code/complex/inputs/complex/sources/Work__GFrame__Engine__Letters.lean": "34906dbf5ae16b5174db00b4881a5cc1d2e583b8c8806db6523a5e2f86565f09", + "code/complex/inputs/complex/sources/Work__GFrame__Engine__Level.lean": "80fb3daa9a45de0ed6da570eb4476b9104734be65d0116f58bcfcbcd67f771d0", + "code/complex/inputs/complex/sources/tools__gx__ORIGIN.md": "6ba897a9495ddadcf8558b93133fdfaf66fc35ce7fa2c53e2d5667335c315e0b", + "code/complex/inputs/complex/sources/tools__gx__gx.py": "6f3dc8bb639933227a8dae181ec4a542e85c7276be9c9e330f49518e7b630b95", + "code/complex/inputs/complex/sources/tools__gx__gxbind.py": "9c9dcfac47f0535bf3aa8ebf7c662cdef0ebda50a9f0a9282b8f3cf34809f835", + "code/complex/inputs/complex/sources/tools__gx__gxconv.py": "dab7fec9f44c2d368ed334055d7126e202017feb46e41a8d86e2d998720f67c2", + "code/complex/inputs/complex/sources/tools__gx__gxcore.py": "eb972c06fe8c322db2d9a8d9a7d05596e8f40c4ca8e5f42eb6df3c7361b5d517", + "code/complex/inputs/e8/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "code/complex/inputs/e8/NOTICE": "557c9ad4660eebd14a00583736c4d12d2c45f3fc9bc148845f9f3efec72c9434", + "code/complex/inputs/e8/Work/GCert/Data/B2Ge8.lean": "842b217147cf84e8042d6ef1c33104d5444b6587b594664bc9eb89b237ab4ad0", + "code/complex/inputs/e8/Work/GCert/Data/B2Ge8Main.lean": "987103107d5586c096016f0a702d0de35b74398dbb50ac66f5886a43a5ca0d05", + "code/complex/inputs/e8/Work/GCert/Data/ChallengeB2Ge8x.lean": "a59db9d54b83adc73391916f7c1ef5e381ff073027781c26cb350f43b79839e3", + "code/complex/inputs/e8/Work/GCert/Data/E8Cert.lean": "13a243c7d7be31ae429d19b5ecd5d428d60c41b7cca8a330f0c4179b110ba7ea", + "code/complex/inputs/e8/Work/GCert/Data/E8Price.lean": "cd250dd72406dde37765c501f666ceeedcc18f831070b26369bcb154c1f99a8e", + "code/complex/inputs/e8/Work/GCert/Data/E8ScalOK.lean": "6bd5e68effe8913a3f73e25ea59142cd9928ddf81e94250a6ea28aa7317388b3", + "code/complex/inputs/e8/Work/GCert/Data/Gen/E8.lean": "5c7fb23df2c10b690f638a19bf066905b5b620b8a2ad0ffde76cc9348d8aa2b4", + "code/complex/inputs/e8/Work/GCert/Data/Gen/E8/S0.lean": "36de82f6969c23082876a4d6848428623d1c65d2df3fc917f23ecba003189dd2", + "code/complex/inputs/e8/Work/GCert/Data/Gen/E8End.lean": "6ea83365afe01664b2132a630511b4de65f938dc328744ce7f77a01fad97f32d", + "code/complex/inputs/e8/Work/GCert/Data/Gen/E8Hist.lean": "cce81699abe1f85a870dcf64edd395d2cf5a586da7700af565b557093095ab51", + "code/complex/inputs/e8/Work/GCert/Data/Gen/E8Par.lean": "a343219b419f30f8ac4dd3a0a98bf53550c5fec6b2cbd245320a95977c319016", + "code/complex/inputs/e8/Work/GCert/Data/Gen/E8Scal0.lean": "78036e5443775ade5bde46a77ba3e0433fe22160da11b5b6c96c7f1075ecfbbd", + "code/complex/inputs/e8/Work/GCert/Data/Gen/E8Seg0.lean": "f6b248dc4c3b2c94db95989b6bd5ad3c3f0d7ece3a511e5b69069550b821b138", + "code/complex/inputs/e8/Work/GCert/Data/Gen/E8Seg1.lean": "79d16ccceb61391446ea97f77fddadafa9150e9dea97919e775f6c78daa71839", + "code/complex/inputs/e8/Work/GCert/Data/Gen/E8SegF.lean": "924340aebc6f68b5a6526311ce33341af0a0a5a8375416762f08c1914ec08abe", + "code/complex/inputs/e8/Work/GCert/Data/Gen/E8Tab0.lean": "650600b631a21221956f9abbab9abebcc9cca628512d3e9a017e2373e2649b17", + "code/complex/inputs/e8/Work/GCert/Data/Gen/E8Tab1.lean": "60036fa4deeb19d39fc0dddf31359d2b6d2407ff66070f145b111bff16190eb0", + "code/complex/inputs/e8/Work/GCert/Data/Gen/E8Tab2.lean": "c8a248da3eb770ba55ef267d118b29d49983311087ef789398d555e2c44b3a41", + "code/complex/inputs/e8/Work/GCert/Data/Gen/E8Tab3.lean": "41975d430ec0095ad465a36d4903e90c01bc891d3abe5e2c372ef786c029a7ed", + "code/complex/inputs/e8/Work/GCert/Data/Gen/E8YChk.lean": "a290360c175544cb85edffe1b92fcf7d447cba09128e19de8dc87e0a1ff0c524", + "code/complex/inputs/e8/Work/GCert/Data/InstB2Ge8.lean": "c1fee298187ea19b5d70fcfccef7d4fd4161be70c0adda19a89ca9933a759954", + "code/complex/inputs/e8/Work/GCert/Data/RateB2Ge8.lean": "7b6e59724c0f140e714afba237d5a1a91b22da70abc096ce274690140b39a3a6", + "code/complex/inputs/e8/Work/GCert/Data/RateB2Ge8x.lean": "7c56d865ed6bfcb6919dabc1a6e53f8744ff4824a2f78335787485f3090970d1", + "code/complex/inputs/e8/Work/GCert/Data/SolutionB2Ge8x.lean": "dd52f1fe0a372480edaf5e6c64903d6257c410e43d406f8acb6bf8f60a1ee28f", + "code/complex/inputs/e8/comparator/B2Ge8x.json": "ddad06c37f9268986f3ec8ce43da5230ee2bd887da2480328413a0dc58f2a926", + "code/complex/inputs/e8/tools/certificate/gcert1-e8-r783.json.gz": "4b92f00fc7454b9b15e6d71a3b05062792eacca0a0ca4efee46f87827d57c8aa", + "code/complex/inputs/e8/tools/e8/replay.py": "be41ee310f28121c3e424cc8637d8fa02ef7c47fc8945e9bbd3856138fd800d6", + "code/complex/inputs/e8/tools/gen/foldgen.py": "a0f16e2c9e078ffbfb2174281ee93a48c18593aefb880318fc105ec85a205932", + "code/complex/inputs/e8/tools/gen/foldlib.py": "7a3c38a698c129e13a767da75926a1305eb0c031b908450afc6feb185505c59a", + "code/complex/inputs/e8/tools/gen/gen_rates.py": "ef8c869e4cf8da33a4c10b96f7f6faafd46e15d66766238070a60315aa169994", + "code/complex/inputs/e8/tools/gen/gen_sharp.py": "1b5eb3730cb16cf516e760879951fdfb9b065efc55f78c29a5c6404fcca57a78", + "code/complex/inputs/e8/tools/gen/templates/ChallengeB2L16x.lean.txt": "0488b7a2442c795414f103df912d1e6cc66d37b5be270940ea9564b7f2b666be", + "code/complex/inputs/e8/tools/gen/templates/SolutionB2L16x.lean.txt": "d414a890dfe126916374c1afc804b90e5081b7760f894b9ccdcf23d83a12f9ee", + "code/complex/inputs/e8/tools/gx/gsmirror.py": "0e22bbe5924284e2fb916337ccefc8e41f6e54469749986ad15b3b81cfaec534", + "code/complex/inputs/e8/tools/gx/gxbind.py": "9c9dcfac47f0535bf3aa8ebf7c662cdef0ebda50a9f0a9282b8f3cf34809f835", + "code/complex/inputs/e8/tools/gx/gxcore.py": "eb972c06fe8c322db2d9a8d9a7d05596e8f40c4ca8e5f42eb6df3c7361b5d517", + "code/complex/inputs/e8/tools/gx/gxgen.py": "ce9151054370c2210ed08f54c249a19dcb6946d182cdf934dee1a3781b53040f", + "code/complex/inputs/e8/tools/gx/gxpaths.py": "f00802d48ef3fedb00278f0b1c7bde074cc49dd30f202d7f32a9d2aebb3be443", + "code/complex/inputs/e8/tools/gx/gxrate.py": "514a5719f970fe36b1273cf59df0396db0e042dd7864c2eea53ab2a2fd1e2ad6", + "code/complex/inputs/e8/tools/gx/gxunit.py": "3cc09a9c1a2db681c0f2016bc821af5b674d34834dbd6f195b9d482ce7c0ff58", + "code/complex/inputs/e8/tools/gx/regen_check.py": "b6172d58749c0b3b9138570c74827bcb23bf5db4ff9643740768cd7782ac4ca6", + "code/complex/inputs/e8/tools/gx/regen_check_e8.py": "ad8fe9811c6ea0d89c795caef48686cfca600f5d540ebfd5d1251d6777cec7cf", + "code/complex/pins-e8.json": "bf66f785878f636616ceab193e5a222143945ea06fc2f13dfb99b204ebba82ff", + "code/complex/portable_complex.py": "44e8ae8a5b915358a97dbed5fe4e70195ed3581fd45a216df48fc82a029db87d", + "code/complex/regress_pr346.py": "29479da1547cd39cf20fe387cde4cad847a2880266db9d0ef3fb474f68591feb", + "code/pricing/base_two_moment.py": "aee70c242a2f1d225528fabe2002e1564d1dc884797c07d28a831c7878ee9098", + "code/pricing/moment.py": "81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482", + "code/pricing/outer.py": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c", + "code/pricing/prime_witnesses.py": "98cd03bc9582e7bd0ab194c191ea8eea940539e510051443ab9fd3e572a364ab", + "code/secondary/bridged.py": "5fe7174cd3a6580a74e4c1bf8fa7b426e8673f1c285603bf3076d4e758d70731", + "code/secondary/seven_stage.py": "96e11030a3a82da37e18b9acb89c1ecd6a93412dc940efded106d0521632ab50", + "data/bit/RECORD-SHA256SUMS": "cfc30216f441a1c44a533f2f26954f90e454136af8842c497de4e2da9bd32d8d", + "data/bit/bitE8-r865.json.gz": "1fb726ea3818fe0837cceb0dd22a71a0814f064e5e781628104610d6468e0e55", + "data/regression-p10/BASE-RECORDS.bin.gz": "caabc13126e8f87d08f7697f51512cb3431ff52861f4190149251d8e19224430", + "data/regression-p10/BASE-frames.json.gz": "35070b83d12ebc60003ed344315328713134a43bdb04217c2c5cbc39e101391f", + "data/regression-p10/BASE-states.json.gz": "1e37ae5001447dd78a8287d8aa23d73a1d5862c4017f44db49af327f58d7cf22", + "data/regression-p10/receipts-loans/banks.json.gz": "0bd464f873b0f59622026793affb308bf087833de6f3197202adc7a36d9d0782", + "data/regression-p10/receipts-loans/finite.json.gz": "82b21b4e6bb4b20e0ecbca44f59941362f57a26a019f179e19b5b7b86262a116", + "data/regression-p10/receipts-loans/global_result.json.gz": "7dccea4b8c4a81597779dc0944297d5f60efd9e2e5b19469417712e2192c6cca", + "data/regression-p10/receipts-loans/math.json.gz": "c4074b86171c5bde8fbbff6df0022a116f17e11f0d2116ae3dfe75c8b2a18c64", + "data/regression-p10/receipts-loans/raw.json.gz": "505c13c667230e946e708d7c9086de34d1c5e259a557f6685765054001e29981", + "data/regression-p10/receipts-loans/scalar.json.gz": "e7bb691b741227ce389ff6341fa0548ff8f638cc492a06be40fcd829fac0bed9", + "requirements.txt": "b9f87c1ec529679c19b8421a7a69b377b54b89949cfc5e1b1ed8c134bfab8917", + "verify.sh": "9657a46eb8073434d23fb06e46ea5722edcec8c2f38091208ea363d77db346c7" + }, + "complex_pr": "https://github.com/CrocSwap/integer-mult-bounds/pull/377", + "complex_commit": "d0a620fcc99ba012468d61d01f5bb14007076d50", + "complex_manifest_sha256": "3743f954b5a652e51fa9ae5101318345d79f4c897ff9a29d5c54387b92118458" +} diff --git a/research/e8-bit-complex-nine/PROOF.txt b/research/e8-bit-complex-nine/PROOF.txt new file mode 100644 index 0000000000..31efe31268 --- /dev/null +++ b/research/e8-bit-complex-nine/PROOF.txt @@ -0,0 +1,191 @@ +Compressed nine-stage E8 bit supplier and combined conditional bound + +Claim and source assumptions + +The conditional combined value is + kappa = 998243154231047 / 10^18 = 0.000998243154231047 > 1/1024. +It is approximately 2^-9.9683211064. This is a conditional finite construction +in the inherited supplier framework, not a Lean proof of integer multiplication. +No priority claim is made. + +The E8 bit word, its 120 root lines, all 865 helpers, and nine retained totals +are taken without modification from Dylan Crow's PR #370, commit +b7fe9cdf2da009c947ff6b334c562bc190b30373. Its raw word has SHA256 +1fb726ea3818fe0837cceb0dd22a71a0814f064e5e781628104610d6468e0e55. +The original verification is rerun, including regeneration, independent +1105-column F2 checking, official record legality/formal columns, all-frame +Gram and prime witnesses, negative controls, and the original regression set. +Its five-stage c is 904072820242522/10^18, insufficient by itself for -10. + +The complex supplier is the separately reconstructed compressed nine-stage +component from PR #377, with b = 999240641319551/10^18. Its complete source, +notices, exact Clifford and Z4 phase checks, global template and finite bill +remain included. In particular, its terminal X_q and every-live-family +X_delta(g) corrections are retained; equality of binary matrices is not +substituted for equality of complex operators. + +The inherited all-size weighted bit compiler, tape/prime/precision and +analytic transfer interfaces remain conditional. PR #370's explicit admission +of nine copied totals at h=8 is retained. The complex local E8 theorem, +Clifford compiler, common fine-grid, restored-row and analytic interfaces +remain conditional exactly as stated in the companion component. The new +window, banking and two-level finite charges are described below rather +than inferred from a rank histogram. + +Exact bit operators and compressed ambient space + +Over an admitted odd address field, the E8 form is G=I_8/2. For a nondegenerate +subspace U, write P_U for its orthogonal projector. On the doubled address +space define + D_U = [[I-P_U, P_U], [P_U, I-P_U]]. +Thus D_U is an exact involution. If U is contained in V then +D_V D_U = D_(V intersect U-perp), with rank dim(V)-dim(U). Also + D_I D_P = D_(I-P). +These are literal address matrices. Unlike the complex C operators, they +have no hidden scalar phase. The auditor reconstructs all 944 rational +projectors and checks all 3289 used nested pairs, in both orientations. + +Set V_global = Q^8 direct_sum (Q^7)^8, m=64, with form I_64/2. +Let E_s be the first s exterior 7-blocks, s=0,...,8. At stage s lift the +entire local word by replacing U with U direct_sum E_s. Both ends of every +local transition contain the same E_s, so it cancels exactly; the child +projector and rank are unchanged. This holds for copied totals as well: +the temporary transforms between the source and scatter frames, whose +common E_s cancels. COPY/ERASE windows remain sequential and immutable. +No assumption that m is a multiple of 9h is used. + +Port routes + +The reference root is q*=2e_0. For every root q, the checked product g_q +of at most two E8 root reflections sends q* to plus or minus q. Let A_q be +its last seven columns. They form an orthonormal basis of q-perp: + A_q^T A_q=I_7, A_q A_q^T=I_8-P_q, P_q=q q^T/4. +For stage s>0 use, on the local block and exterior block s, + rho_(s,q) = [[P_q, A_q], [A_q^T, 0]], +and fix all other coordinates. For s=0 use the identity. These matrices +are orthogonal involutions. Conjugating the lifted endpoints gives + (P_q,E_s) -> (I_8,E_(s-1)), (I_8,E_s) -> (I_8,E_s), + (0,E_s) -> (I_8-P_q,E_(s-1)), + (I_8-P_q,E_s) -> (I_8-P_q,E_s). +These equalities are checked as exact rational matrices for every port. +Each nontrivial route has a replayed elementary factorization, at most +77 factors, with denominators 1,2,4. Omitting a factor fails. Thus all +routes remain defined at every odd address prime; there is no new odd +exceptional prime. The existing local prime witnesses are rerun separately. + +Nine-stage scalar recipe and deferred endpoint completion + +Use four data pairs (X_j,Y_j). Start with F_0: Y_0 += X_0. For j=0,...,3, +apply B_j: X_j -= Y_j; when j<3 insert the two shears + X_j += X_(j+1), Y_(j+1) -= Y_j; +apply F_j; then undo those two shears. After all stages, for j=2,1,0 apply + X_(j+1) += X_j, Y_j -= Y_(j+1). +Finally replace (X_j,Y_j) by (Y_j,-X_j). The complete signed integer +8-by-8 scalar matrix is the identity. Omitting any of the eighteen +individual bridge shears changes it. + +Each B_j is the reflected inverse of the actual local record stream: +reverse the order, negate ADD coefficients, replace U by U-perp, and +turn ERASE into a fresh COPY from the original unchanged center. No erase +is inverted. PR #370 stores zero in the ERASE rank field; the reflected +COPY rank is freshly derived from its two frames, giving rank 8. Both +oriented streams replay all 1105 independent input columns and close work. + +Before each bridge the newly used pair is advanced to the active level. +The two idle increments are (14,7), (28,7), (42,7). Endpoint completion of +the earlier pairs is deferred to the final stage, with ranks 42,28,14,0. +Every increment acts on both members of every port pair and every replica. +The schedule checker requires equal complete frames at every bridge. +The signed terminal exchange completes the data transform using the exact +identity D_I D_P=D_(I-P). Scalar replay on 8745 independent columns includes +960 data and 7785 separate stage-helper inputs. All are restored after +the exchange; the reflected copy work closes to zero. + +Whole-block banks and arbitrary correlated dirt + +Use eight replicas. There are 4*2*120*8=7680 data families. For each stage, +number a local helper occurrence by z=865*replica+helper, and assign it +to bank floor(z/8), slot z mod 8. There are 865 banks at each of nine +stages. Each slot is one whole 8-dimensional coordinate block in Q^64. +The eight slots are mutually perpendicular and fill the ambient space; +no padding child is needed. Live recursion stock is 7680+9*865=15465. +Nine private center slots are reserved and excluded from recursion volume, +so charged physical stock is 15474. Only one such slot is used at a time. + +Let Pi_slot exchange the first eight coordinates with its bank block. +For a cover class d in O(I_64/2,F_q), the helper owner is the bank class +g=d Pi_slot^-1, and a data owner is d rho_(s,q). Right multiplication is a +bijection of the finite cover. Within every local invocation, helpers in +the same bank have different slots, hence different actual cover classes; +all data and work families are disjoint from banks. All 62280 assignments +are checked, and every physical bank receives each of its eight slots once. + +The local all-column theorem permits arbitrary helper inputs, including +correlations created by earlier invocations. After its endpoint each helper +has only the known residual D_H. The common E_s cancels, so no cleanliness +assumption is imposed by a previous bank action. Complete cover sweeps run +sequentially. At a fixed bank owner g the residuals are D on the eight +orthogonal coordinate blocks conjugated by g. They commute and multiply +to D_I. Since diag(g,g) commutes with the literal head/tail exchange D_I, +no complex-style cover phase correction is needed on the bit side. +This is a symbolic finite cover proof, not an enumeration of O(64,F_q). + +Actual emitted ledger + +The source-bound template emits 72 local invocations and 1355328 events. +All local COPY/ERASE and helper lifetimes are rechecked. Its paid profile is + 1:149472, 2:67824, 3:32256, 4:30096, 5:22176, 6:144, + 7:5760, 8:1296, 14:3840, 28:3840, 42:3840. +There are 320544 paid children, rank mass 987264 and deficit + 64*15465-987264 = 2496 = 8*(8*120-9*72). +The independent auditor recomputes the profile from the emitted template +and rejects missing idle/bridge/exchange/invocation events, bank-slot aliasing, +understated stock, a missing local MOVE and a wrong reflected COPY charge. + +Finite cost, precision allowance and two-level halving + +The largest child is 42, so one-level halving is false. Two levels suffice: + 2*42^2=3528 < 64^2=4096. +Floors only reduce descendant widths. The exact one-level moment, including +the inherited 10^-16 bad-branch envelope, is strictly below one; composing +two levels squares this contraction. The finite composite may be used with +the inherited halving-based compiler and direct small leaves. + +The old five-stage 104-bit payload-prefix guard is not reused. Fresh local +cancellation-free row bounds are 742 forward and 6308 reverse. For five +forward calls, four reflected calls and eighteen bridge shears, the bound + 2^18 * 742^5 * 6308^4 +has 117 bits. We explicitly charge 192 bits per nine-stage block. The actual +source operations, copy episodes, 77-factor routes, selectors, all owner +adapters and this prefix bound enter certify.py's finite coefficient. It +has 117 bits; the charged two-level coefficient has 269 bits and is bounded +by 2^512. This deliberately increases the finite cutoff, rather than passing +the old 104-bit assertion. The exact three bootstrap cutoff inequalities +are checked using the changed coefficient. + +For cover/routing enumeration use the inherited coarse q^(m^2+1) bound; +two levels and the retained additive row charges give + 2*(64^2+1)+9909+252 = 18355 < 20161. +The explicit rational bit routes introduce only powers of two. The new +finite constants fit well below the companion bridge's 2^30000 reserve, +and the common external C0=2^210000 and row allowance 20161 are retained. +As for the companion complex component, the general compiler/common-grid +interfaces are assumptions; no new Lean formalization is asserted. + +Exact price and combined assembly + +Two independent rational moment engines, both with the 10^-16 envelope, +admit c=1057833103534317/10^18 and reject c+10^-18. The complex supplier +therefore binds. With eta=10^-12 and beta=10^-9 choose + s=999240640320309/10^18 < (1-beta)*b < c. +Start a0=384599/10^10 and apply a_(j+1)=(1-s)s+s*a_j three times. The retained +outer assembly at (a3,b) admits kappa=998243154231047/10^18. All 47 strict +constraints are positive; the next 10^-18 kappa grid point is rejected. +The strict excess over 1/1024 is 21680654231047/10^18. Final kappa is about +24.0286% above frozen #361, within the explicitly retained assumptions. + +Attribution: Dylan Crow / Anthropic Claude for PR #370's new local bit word; +Jacob Sussman for E8 and the complex unit; the inherited source527, PR234, +PR266, PR315, PR346, PR352 and PR363 contributors as listed in the preserved +notices; Zhihao Chen with OpenAI Codex assistance for this compressed bit +composition, its independent audit, and the combined nine-stage package. diff --git a/research/e8-bit-complex-nine/README.md b/research/e8-bit-complex-nine/README.md new file mode 100644 index 0000000000..93fecd364a --- /dev/null +++ b/research/e8-bit-complex-nine/README.md @@ -0,0 +1,26 @@ +# Conditional κ = 9.98243154231047e-4 > 2^-10 + +This combines the pinned E8 bit word from [PR #370](https://github.com/CrocSwap/integer-mult-bounds/pull/370) with the compressed nine-stage complex component from [PR #377](https://github.com/CrocSwap/integer-mult-bounds/pull/377). The new bit construction uses nine stages in dimension 64, eight replicas and exact whole-block banks. Directly pairing #370's original five-stage bit supplier with the new complex supplier would **not** cross `2^-10`. + +| Quantity | Verified conditional value | +| --- | --- | +| New bit coarse saving | `1057833103534317 / 10^18` | +| Complex coarse saving | `999240641319551 / 10^18` | +| Final κ | `998243154231047 / 10^18 ≈ 2^-9.9683211064` | +| Excess over `2^-10` | `21680654231047 / 10^18` | + +The complex side binds. The final value is about 24.0286% above frozen #361. Two independent rational moment engines and all 47 strict outer constraints are checked; adjacent grid points are rejected. This is a conditional finite construction, with the supplier/compiler/precision/analytic interfaces listed in [PROOF.txt](PROOF.txt). It is not a new Lean proof or a claim of priority. + +Run from the repository root with Python 3.11+, NumPy, SymPy, mpmath, a C++17 compiler and Boost headers: + +```sh +python3 -B research/e8-bit-complex-nine/verify.py --work /tmp/e8-bit-complex-nine-fresh +``` + +The destination must not exist. The runner verifies all source manifests, freshly rebuilds the entire #370 package and the eight-stage #377 verification, then runs the new geometry, emitted-word, independent-audit and combined-price checks. The portable standard-header shim only supplies standard C++ includes for Clang; inherited source files are unchanged. Optional OR-Tools is used by #370's separate center-minimality check when installed. + +The new finite evidence includes all 120 port routes, 944 exact frame projectors, 3,289 nested and reflected pairs, 8,745 scalar columns, 62,280 bank assignments, 72 actual local invocations and 1,355,328 emitted events. Eight new structural mutations are rejected, in addition to inherited word and record mutations. + +The largest bit child is 42 of 64. Two-level halving is proved and charged explicitly. The old five-stage 104-bit prefix assertion is replaced by a freshly derived 117-bit bound with a charged 192-bit allowance; the two-level finite constant fits 512 bits and the row coefficient is 18,355 below the retained 20,161 allowance. + +The local E8 bit word and #370's explicit nine-total admission are credited to Dylan Crow with Anthropic Claude assistance. Jacob Sussman's E8 unit and all upstream notices remain intact. This composition and its audit were prepared by Zhihao Chen with substantial OpenAI Codex assistance, under Apache-2.0. See [NOTICE.txt](NOTICE.txt). diff --git a/research/e8-bit-complex-nine/audit.py b/research/e8-bit-complex-nine/audit.py new file mode 100644 index 0000000000..a9c0749ad0 --- /dev/null +++ b/research/e8-bit-complex-nine/audit.py @@ -0,0 +1,118 @@ +"""Independent audit of the emitted bit template, including mutation controls. +Prepared by Zhihao Chen with OpenAI Codex assistance; Apache-2.0. +""" +import argparse, copy, gzip, hashlib, json, struct, time +from collections import Counter, defaultdict +from pathlib import Path +import sympy as S + +def sha(p): return hashlib.sha256(p.read_bytes()).hexdigest() + +def main(): + ap=argparse.ArgumentParser(); ap.add_argument('--local-check',type=Path,required=True); ap.add_argument('--out',type=Path,required=True) + a=ap.parse_args(); start=time.monotonic(); out=a.out + blob=gzip.decompress((out/'GLOBAL-TEMPLATE.json.gz').read_bytes()); t=json.loads(blob) + g=json.loads((out/'GLOBAL.json').read_text()); geo=json.loads((out/'GEOMETRY.json').read_text()) + assert hashlib.sha256(blob).hexdigest()==g['template_sha256'] + assert t['geometry_sha256']==sha(out/'GEOMETRY.json') and t['source_record_sha256']==sha(a.local_check/'records/249-records.bin') + fs=json.loads((a.local_check/'records/frames.json').read_text())['frames'] + records=list(struct.iter_unpack('<6i',(a.local_check/'records/249-records.bin').read_bytes())) + I=S.eye(8); proj={}; dimensions={} + for key,f in fs.items(): + k=int(key); B=S.Matrix(f['B']) if f['B'] else S.zeros(0,8) + P=B.T*(B*B.T).inv()*B if B.rows else S.zeros(8) + assert P.T==P and P*P==P and P.trace()==f['dim'] + proj[k]=P; dimensions[k]=f['dim'] + pairs={} + for op,x,y,c,r,z in records: + if op==0: + key=(y,c) + if key not in pairs: + D=proj[c]-proj[y] + assert proj[c]*proj[y]==proj[y] and proj[y]*proj[c]==proj[y] + assert D*D==D and D.trace()==r + # Reflected reverse has exactly the same positive projector. + assert (I-proj[y])-(I-proj[c])==D + pairs[key]=r + assert len(proj)==944 + print('exact frame projectors',len(proj),'nested pairs',len(pairs),flush=True) + expected={} + for rev in (False,True): + es=[] + for op,x,y,c,f,z in (reversed(records) if rev else records): + if op==0: es.append([0,x,c if rev else y,y if rev else c,f,int(rev)]) + elif op==1: es.append([1,x,y,-c if rev else c,f,int(rev)]) + elif op==(3 if rev else 2): es.append([2,x,y,c,f,abs(dimensions[c]-dimensions[f]),int(rev)]) + else: es.append([3,x,y,c,f,z,int(rev)]) + expected['reverse' if rev else 'forward']=es + assert t['local_programs']==expected + + def validate(q,check_profile=True): + assert (q['m'],q['live'],q['replicas'],q['stages'])==(64,15465,8,9) + assert q['bank_padding'] is None and q['local_programs']==expected + hist=Counter(); occupation=defaultdict(set); calls=set() + for c in q['calls']: + st,rep,p=c['stage'],c['replica'],c['pair']; rev=c['orientation']=='reverse' + assert 0<=st<9 and 0<=rep<8 and p==max(0,(st-1)//2) + assert rev==(st in (1,3,5,7)) and (st,rep) not in calls; calls.add((st,rep)) + own=c['owners']; assert len(own)==1105 + assert len({(f,tuple(r)) for f,r in own})==1105 + for i,(family,route) in enumerate(own): + assert 0<=family<15465 + if i<240: + side=i//120; side=1-side if rev else side + assert family==rep*960+(2*p+side)*120+i%120 and route==['data',st,i%120] + else: + j=i-240; bank,slot=divmod(rep*865+j,8) + assert family==7680+st*865+bank and route==['bank',slot] + assert slot not in occupation[family]; occupation[family].add(slot) + for e in q['local_programs'][c['orientation']]: + if e[0]==0 and e[4]: hist[e[4]]+=1 + if e[0]==2: hist[e[5]]+=1 + assert calls=={(s,r) for s in range(9) for r in range(8)} + assert set(occupation)==set(range(7680,15465)) and all(s==set(range(8)) for s in occupation.values()) + levels=[-1]*4; scalar=[1<0 + bound=max(1,ceilq(36/gap**2),ceilq(2*(4+(two_level_coefficient-1).bit_length())/gap)) + assert Q(bound)*gap**2>=36 and Q(bound)*gap>=2*(4+(two_level_coefficient-1).bit_length()) + cutoff.append(dict(gap=str(gap),cutoff_log2=str(bound))); chain.append(z) + bridge=dict(semantic=dict(C0=dict(base=2,exponent=210000),strict_literal_gap=1), + rows=dict(degree_gap=Q(10**6)-Q(51*20161,25))) + q=chain[-1]*(1-2*eta); bound=(1-eta)*q/(1+q); ticks=bound/grid + k=Q((ticks.numerator-1)//ticks.denominator,10**18) + asm=outer.assembly(chain[-1],b,bridge,k,eta=eta,beta=beta) + assert len(asm['strict_constraints'])==47 and min(asm['strict_constraints'].values())>0 + try: outer.assembly(chain[-1],b,bridge,k+grid,eta=eta,beta=beta) + except AssertionError: pass + else: raise AssertionError('next combined grid point admitted') + assert k>Q(1,1024) and k==Q(998243154231047,10**18) + result=dict(status='PASS_CONDITIONAL_COMBINED_KAPPA_ABOVE_2_POW_MINUS_10', + bit_coarse=str(c),complex_coarse=str(b),selected_bit_coarse=str(sv), + kappa=str(k),kappa_decimal=format(float(k),'.18f'),log2_kappa=math.log2(float(k)), + threshold='1/1024',strict_excess=str(k-Q(1,1024)),gain_over_frozen_361_percent=float(k/Q(804849251275843,10**18)-1)*100, + binding='complex',bit_moment_interval=list(map(str,bm)),next_bit_grid_rejected=True, + two_rational_engines=True,composed_moment_upper=str(bm[1]**2),halving_depth=2, + bootstrap_chain=list(map(str,chain)),strict_constraints={n:str(z) for n,z in asm['strict_constraints'].items()}, + next_kappa_grid_rejected=True,local_and_global_bit_sha256=sha(out/'GLOBAL.json'), + independent_bit_audit_sha256=sha(out/'AUDIT.json'), + complex_verification_sha256=sha(v),complex_global_sha256=sha(cx), + finite=dict(unit_additions=unit,route_items=J,selector_calls=selectors,coefficient=str(coefficient), + coefficient_bits=coefficient.bit_length(),two_level_coefficient=str(two_level_coefficient), + two_level_coefficient_bits=two_level_coefficient.bit_length(),charged_bound_bits=512, + payload_prefix_bits=prefix.bit_length(),charged_payload_prefix_bits=192, + row_coefficient=row,retained_row_coefficient=20161,cutoff=cutoff), + retained_obligations=['PR370 E8 local bit and nine copied-total admission', + 'All-size weighted bit compiler, prime/tape/precision and analytic transfer interfaces', + 'PR377 local E8 complex theorem, exact Clifford compiler and common fine-grid/row/analytic interfaces'], + scope='Conditional finite construction and exact arithmetic assembly. No Lean proof or priority claim; no enumeration of the entire orthogonal cover.') + (out/'COMBINED.json').write_text(json.dumps(result,indent=2)+'\n') + print(json.dumps({k:v for k,v in result.items() if k not in ('strict_constraints','bootstrap_chain','finite','bit_moment_interval','composed_moment_upper')}),flush=True) + +if __name__=='__main__': main() diff --git a/research/e8-bit-complex-nine/geometry.py b/research/e8-bit-complex-nine/geometry.py new file mode 100644 index 0000000000..91594e0223 --- /dev/null +++ b/research/e8-bit-complex-nine/geometry.py @@ -0,0 +1,121 @@ +"""Exact compressed nine-stage E8 bit geometry; no external research fetches. + +Prepared by Zhihao Chen with OpenAI Codex assistance, Apache-2.0. +Uses the E8 root data and port-reflection construction credited to PR #370. +""" +import argparse, gzip, hashlib, json, time +from pathlib import Path +import sympy as S + +def dump(p, x): p.write_text(json.dumps(x,indent=2,default=str)+'\n') +def digest(p): return hashlib.sha256(p.read_bytes()).hexdigest() + +def factor(a): + """Exact elementary factorization, reconstructed from the identity.""" + n=a.rows; z=a.copy(); ops=[] + for j in range(n): + p=next(i for i in range(j,n) if z[i,j]) + if p!=j: z.row_swap(p,j); ops.append(['swap',p,j,None]) + if z[j,j]!=1: + c=1/z[j,j]; z[j,:]=c*z[j,:]; ops.append(['scale',j,None,c]) + for i in range(n): + if i!=j and z[i,j]: + c=-z[i,j]; z[i,:]=z[i,:]+c*z[j,:]; ops.append(['add',i,j,c]) + assert z==S.eye(n) + def replay(skip=-1): + z=S.eye(n) + for k in reversed(range(len(ops))): + if k==skip: continue + typ,i,j,c=ops[k] + if typ=='swap': z.row_swap(i,j) + elif typ=='scale': z[i,:]=z[i,:]/c + else: z[i,:]=z[i,:]-c*z[j,:] + return z + assert replay()==a + assert ops and replay(0)!=a + return [[t,i,j,None if c is None else str(c)] for t,i,j,c in ops] + +def main(): + ap=argparse.ArgumentParser(); ap.add_argument('--source',type=Path,required=True) + ap.add_argument('--out',type=Path,required=True); a=ap.parse_args(); t0=time.monotonic() + a.out.mkdir(parents=True,exist_ok=True) + p=a.source/'data/bit/bitE8-r865.json.gz'; w=json.loads(gzip.decompress(p.read_bytes())) + assert (w['h'],w['v'],w['R'],w['form'])==(8,120,865,'/2') + lines=[S.Matrix(x) for x in w['lines']]; I=S.eye(8); Z=S.zeros(8) + assert lines[0]==S.Matrix([2,0,0,0,0,0,0,0]) + ip=lambda u,v:(u.T*v)[0]/2 + gs={0:I}; todo=[0] + while todo: + more=[] + for i in todo: + for j in range(120): + if j in gs or abs(ip(lines[i],lines[j]))!=1: continue + d=lines[i]-lines[j] if ip(lines[i],lines[j])==1 else lines[i]+lines[j] + r=I-d*d.T/(d.T*d)[0]*2 + gs[j]=r*gs[i]; more.append(j) + todo=more + assert len(gs)==120 + recipes=[]; denoms=set(); max_factors=0 + for t,q in enumerate(lines): + g=gs[t]; assert g.T*g==I and g*lines[0] in (q,-q) + P=q*q.T/4; K=I-P; A=g[:,1:] + assert A.T*A==S.eye(7) and A*A.T==K and P*A==S.zeros(8,7) + rho=P.row_join(A).col_join(A.T.row_join(S.zeros(7))) + assert rho.T==rho and rho*rho==S.eye(15) + expected={'P':S.diag(I,S.zeros(7)), 'H':S.eye(15), + '0':S.diag(K,S.zeros(7)), 'K':S.diag(K,S.eye(7))} + for name,U in [('P',P),('H',I),('0',Z),('K',K)]: + assert rho*S.diag(U,S.eye(7))*rho==expected[name] + # Exact bit address operators D_U: head/tail exchange on U. + # Unlike complex C_U, they carry no omitted scalar/translation phase. + def D(U): return (I-U).row_join(U).col_join(U.row_join(I-U)) + assert D(I)*D(P)==D(K) and D(P)*D(P)==S.eye(16) + ops=factor(rho); max_factors=max(max_factors,len(ops)) + for typ,i,j,c in ops: + if c is not None: denoms.add(int(S.Rational(c).q)) + # Compact exact global matrices: these 15 axes are the first eight + # local coordinates and exterior block s. All other axes are fixed. + routes=[dict(stage=0,axes=list(range(8)),identity=True)] + for s in range(1,9): + axes=list(range(8))+list(range(8+7*(s-1),8+7*s)) + assert len(set(axes))==15 and max(axes)<64 + routes.append(dict(stage=s,axes=axes,elementary_inverse_replay=ops)) + recipes.append(dict(port=t,q=list(map(int,q)),complement_columns=[[str(x) for x in row] for row in A.tolist()], + rho15=[[str(x) for x in row] for row in rho.tolist()],routes=routes)) + if t%30==0: print('compressed geometry',t+1,flush=True) + # Exact nested data levels: local I (or K_q) plus s exterior rank-7 + # blocks. Width 64=8+8*7; each bridge sees identical complete operators. + idle=[] + for j in range(1,4): + idle += [dict(pair=j,source_level=-1,target_level=2*j-1,rank=14*j,phase='before_positive_bridge'), + dict(pair=j,source_level=2*j-1,target_level=2*j,rank=7,phase='before_negative_bridge')] + for j in range(4): + idle.append(dict(pair=j,source_level=2*j+2,target_level=8,rank=14*(3-j),phase='terminal')) + assert sum(z['rank'] for z in idle)==189 + # Whole h=8 residual blocks are mutually perpendicular and fill Q^64. + slots=[list(range(8*s,8*(s+1))) for s in range(8)] + assert sorted(sum(slots,[]))==list(range(64)) + perms=[] + for s in range(8): + perm=list(range(64)) + if s: + for j in range(8): perm[j],perm[8*s+j]=perm[8*s+j],perm[j] + assert [perm[perm[j]] for j in range(64)]==list(range(64)) + assert sorted(perm)==list(range(64)) and [perm[j] for j in range(8)]==slots[s] + perms.append(perm) + assert len({tuple(p) for p in perms})==8 + assert set(sum(slots[:7]+[slots[6]],[]))!=set(range(64)) + out=dict(status='PASS_COMPRESSED_NINE_BIT_GEOMETRY_AND_BANK_BLOCKS',h=8,m=64,stages=9, + word_sha256=digest(p),ports=recipes,idle_per_port_and_data_member=idle, + local_window='U direct_sum E_s, with E_s the first s exterior coordinate 7-blocks', + ambient_form='I_64/2',bank_slots=slots,bank_permutations=perms, + route_checks=1080,exact_bit_endpoint_operator_checks=240, + max_route_factors=max_factors,route_denominators=sorted(denoms), + bad_prime_factors=sorted({int(q) for d in denoms for q in S.factorint(d)}), + missing_route_factor_controls=120,duplicate_bank_slot_rejected=True, + scope='All port isometries, stage boundary identities, nested idle ranks, exact bit endpoint operators and bank coordinate slots. Full local-word scalar and chronological lowering are checked separately.', + seconds=time.monotonic()-t0) + dump(a.out/'GEOMETRY.json',out) + print(json.dumps({k:v for k,v in out.items() if k not in ('ports','bank_permutations','idle_per_port_and_data_member')}),flush=True) + +if __name__=='__main__': main() diff --git a/research/e8-bit-complex-nine/global_word.py b/research/e8-bit-complex-nine/global_word.py new file mode 100644 index 0000000000..644791ac12 --- /dev/null +++ b/research/e8-bit-complex-nine/global_word.py @@ -0,0 +1,222 @@ +"""Source-bound compressed nine-stage bit template and exact scalar audits. + +Prepared by Zhihao Chen with OpenAI Codex assistance, Apache-2.0. +The local E8 bit word is Dylan Crow's pinned PR #370 contribution. +""" +import argparse, gzip, hashlib, json, struct, time +from collections import Counter +from pathlib import Path + +H,V,R,L,K,T,M=8,120,865,9,4,8,64 +LOCAL=2*V+R; DATA=2*K*V*T; LIVE=DATA+L*R +def sha(p): return hashlib.sha256(p.read_bytes()).hexdigest() +def write(p,x): p.write_text(json.dumps(x,indent=2)+'\n') + +def recipe(): + out=[dict(kind='local',stage=0,pair=0,reverse=False)]; stage=1 + for j in range(K): + out.append(dict(kind='local',stage=stage,pair=j,reverse=True)); stage+=1 + if j=0 + cur[x]=newf + if f: hist[f]+=1 + events.append([0,x,oldf,newf,f,int(reverse)]) + elif op==1: + assert cur[x]==cur[y]==f and x!=y and x +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#endif diff --git a/research/e8-bit-complex-nine/verify.py b/research/e8-bit-complex-nine/verify.py new file mode 100644 index 0000000000..1b101ce28c --- /dev/null +++ b/research/e8-bit-complex-nine/verify.py @@ -0,0 +1,55 @@ +#!/usr/bin/env python3 +"""Fresh offline reconstruction of both suppliers and their combined bound.""" +import argparse, hashlib, json, os, subprocess, sys, time +from pathlib import Path +assert __debug__ and sys.version_info>=(3,11) +ROOT=Path(__file__).resolve().parent +def sha(p): return hashlib.sha256(p.read_bytes()).hexdigest() +def read(p): return json.loads(p.read_text()) +def files(root): + return {p.relative_to(root).as_posix():sha(p) for p in root.rglob('*') + if p.is_file() and '__pycache__' not in p.parts and p.suffix!='.pyc'} + +ap=argparse.ArgumentParser(); ap.add_argument('--work',type=Path,required=True) +ap.add_argument('--bit-source',type=Path,default=ROOT.parent/'e8-bit') +ap.add_argument('--complex-source',type=Path,default=ROOT.parent/'nine-stage-complex-e8') +a=ap.parse_args(); wd=a.work.resolve(); bit=a.bit_source.resolve(); cx=a.complex_source.resolve() +assert not wd.exists() and not wd.is_relative_to(ROOT) +own=files(ROOT); own.pop('MANIFEST.json'); assert own==read(ROOT/'MANIFEST.json')['files'] +pins=read(ROOT/'PINS.json') +assert files(bit)==pins['bit_files'] and sha(cx/'MANIFEST.json')==pins['complex_manifest_sha256'] +assert not any(p.is_symlink() for p in ROOT.rglob('*')) +wd.mkdir(); (wd/'logs').mkdir(); steps=[]; started=time.monotonic() +env=os.environ.copy(); env['PYTHONDONTWRITEBYTECODE']='1' +env['PATH']=str(Path(sys.executable).parent)+os.pathsep+env.get('PATH','') +includes=[str(ROOT/'portable-include')] +for p in ('/usr/local/include','/opt/homebrew/include'): + if Path(p).is_dir(): includes.append(p) +if env.get('CPLUS_INCLUDE_PATH'): includes.append(env['CPLUS_INCLUDE_PATH']) +env['CPLUS_INCLUDE_PATH']=os.pathsep.join(includes) +def run(name,cmd): + print(name,flush=True); start=time.monotonic(); log=wd/'logs'/(name+'.log') + with log.open('w') as f: r=subprocess.run(cmd,cwd=wd,env=env,stdout=f,stderr=subprocess.STDOUT) + assert r.returncode==0,(name,r.returncode,str(log)) + steps.append(dict(stage=name,returncode=0,seconds=time.monotonic()-start,log_sha256=sha(log))) +try: + run('pinned-pr370-full-rebuild',['bash',str(bit/'verify.sh'),str(wd/'bit-local')]) + run('pinned-pr377-full-rebuild',[sys.executable,'-B',str(cx/'verify.py'),'--work',str(wd/'complex')]) + for name,script,args in [ + ('compressed-bit-geometry','geometry.py',['--source',str(bit),'--out',str(wd/'bit-nine')]), + ('source-bound-bit-word','global_word.py',['--source',str(bit),'--local-check',str(wd/'bit-local'),'--out',str(wd/'bit-nine')]), + ('independent-bit-template-audit','audit.py',['--local-check',str(wd/'bit-local'),'--out',str(wd/'bit-nine')]), + ('two-moments-finite-bill-combined-assembly','certify.py',['--source',str(bit),'--out',str(wd/'bit-nine'),'--complex-check',str(wd/'complex')])]: + run(name,[sys.executable,'-B',str(ROOT/script)]+args) + result=read(wd/'bit-nine/COMBINED.json') + assert result['status']=='PASS_CONDITIONAL_COMBINED_KAPPA_ABOVE_2_POW_MINUS_10' + assert result['kappa']=='998243154231047/1000000000000000000' + receipt=dict(status='PASS_FRESH_CONDITIONAL_E8_BIT_COMPLEX_NINE',source_manifest_sha256=sha(ROOT/'MANIFEST.json'), + pins_sha256=sha(ROOT/'PINS.json'),stages=steps,combined=result, + final_receipt_sha256=sha(wd/'bit-nine/COMBINED.json'),seconds=time.monotonic()-started, + scope='Offline fresh reconstruction. All inherited supplier/compiler/precision/analytic obligations remain explicit in PROOF.txt. No Lean or priority claim.') + (wd/'VERIFICATION.json').write_text(json.dumps(receipt,indent=2)+'\n') + print(receipt['status'],result['kappa'],flush=True) +except BaseException as e: + (wd/'FAILURE.json').write_text(json.dumps(dict(error=str(e),completed=steps),indent=2)+'\n') + raise diff --git a/research/e8-bit/HANDOFF.md b/research/e8-bit/HANDOFF.md new file mode 100644 index 0000000000..47cf9f27f9 --- /dev/null +++ b/research/e8-bit/HANDOFF.md @@ -0,0 +1,54 @@ +# Handoff: e8-bit package + +**Status.** `bash verify.sh ` passes end to end in about 2.5 minutes. `VERIFY-LOG.txt` is a clean run. The +final line is + + PASS conditional kappa = 875481145306751/1000000000000000000 = 0.000875481145306751 (complex-bound; bit coarse 452036410121261/500000000000000000 = 0.000904072820242522 ) + +## File map + +| path | content | +| --- | --- | +| `data/bit/bitE8-r865.json.gz` | the word (format `bitE8/1`: lines, frames as root-line lists, start/final, ret, scatter, gate lists D/A/B/C) | +| `data/bit/RECORD-SHA256SUMS` | hashes of the exported PR249 records/states/frames | +| `code/bit/producer/` | the design code: `e8lib`, `frames`, `ham1`/`ham2` hierarchy, `compile`/`compile2` compiler, `fullword` (word + dirt + cleanup), `search2` (local search), `params-r865.json` | +| `code/bit/export_records.py` | bitE8 → PR249 records (MOVE/ADD/COPY/ERASE), B/A integer frame bases | +| `code/bit/independent/` | `checkword.py` (independent all-column checker), `mutate.py` (6 controls), `centres_sat.py` (no 8-centre decoder) | +| `code/bit/checkers/` | generalized official checkers: `legality_h.cpp`, `columns_h.cpp` (NCOPY); `gram_frames.py`; `geometry_g.py`; `tile_g.py`; `certify_bit_g.py` (+ `cost.py`); `finite_g.py` | +| `code/bit/regression/` | the unmodified PR #346/#352 sources the generalizations are compared against | +| `code/bit/receipts_e8.py`, `code/bit/mutate_records.py` | finite-bill inputs from this run's receipts; record-level controls | +| `code/complex/`, `code/pricing/` | PR #352's complex checks and PR #315's engines, unchanged | +| `code/secondary/` | PR #363's `bridged.py` (unchanged); `seven_stage.py` (κ under b₃; the bit word in B₃) | +| `data/regression-p10/` | PR #325 p10b base word (from #352's `data/bit`); agent G's p = 10 loans receipts (raw/scalar/banks/math/finite/global_result) | + +## How the numbers relate + +- **Bit side.** c = 9.0407e-4. The deficit is 120 = 4·120 − 5·72, and W = 1345. +- **κ under each complex supplier:** + - with #352's b = 8.7625e-4: complex-bound, κ = 8.7548e-4; + - with #363's seven-stage b₃ = 9.3278e-4: bit-bound, κ = 9.0326e-4 (reported, not claimed); + - with a seven-stage *bit* layout (an estimate, c = 9.682e-4) and b₃: κ = 9.3191e-4. +- **Bit-side headroom.** The search stopped at R = 865 (`search2.py` plateau). Further gains on the bit side do not move + κ while #352's complex supplier binds. Known slack: + - about 500 dead non-host helper registers that could be reused; + - frame retiming; + - carriers for single lines (274). + +## What a reviewer should look at + +1. The NCOPY admission: 9 retained totals at h = 8. See the README section on retained totals. +2. PR234 for a non-paired-cube family. Port isometries are W(E8) reflection words, rational with denominators 2 and 4; + every port route is checked as an exact elementary program with power-of-two denominators, so they are units modulo + any odd prime. The original uses coordinate permutations. +3. Two finite-bill quantities, both computed by the original formulas: + - K uses the identity chart only, since every helper starts at frame 0; + - T = 1 replica, since all residual widths are h = 8 and 5 ∣ R. + +## Regenerate + +```sh +cd code/bit/producer && E8COORD=ham python3 -B fullword.py params-r865.json /tmp/w.json.gz # the word +E8COORD=ham python3 -B search2.py SEED ITERS [start.pkl] # the local search (pickle params) +``` + +Prepared by Dylan Crow, with Anthropic Claude assistance. diff --git a/research/e8-bit/LICENSE b/research/e8-bit/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/e8-bit/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/e8-bit/MANIFEST.sha256 b/research/e8-bit/MANIFEST.sha256 new file mode 100644 index 0000000000..8a244d8a15 --- /dev/null +++ b/research/e8-bit/MANIFEST.sha256 @@ -0,0 +1,156 @@ +ce8d68b25c3a36864d80c8fc43c9f84b2fe652a9e7a2a65aa41187ba3cf8e44e ./HANDOFF.md +c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4 ./LICENSE +967e6d7e76e216e4898cf543c75b527e8d397ec1ddba3800cb20701f24c89524 ./NOTICE-PR352.md +c788ace1c9a99e3292fed6b62b8c942b8ff80e47c4abe4ead344f869afc07d9b ./NOTICE-PR363.md +025773f32fb43667395e64c627a1752877bdc93afbfe01b106703eee438d21d3 ./NOTICE.md +8b24ac1c09b64ca1c545e04c439d9773396e4e92e6b8fe39a2c2a1488163d560 ./PR-STATEMENT.md +c1ff70a03a49e362ae3d2f0e349f4d3fa0386c46dd2dc5fd3153c5940e730770 ./README.md +c9a31508126f34e7ac95d802c39e8919a872cd705314de5bf3538de1636ce8ce ./code/bit/checkers/certify_bit_g.py +d1297f9052be4f2496e1ff2a77e4db2c0cdbd7d460d489b4c03e50bf317238ce ./code/bit/checkers/columns_h.cpp +d55d2b865d1c3d35e343e1a38c592b9172ed8e2596d1107e34d92e2a80c7d03f ./code/bit/checkers/cost.py +28a0d8ee29ac75b8a789705454987f07d618f135ed1f1bd45b97f18bcc4163e3 ./code/bit/checkers/exactnd_h.py +a591d8caa9ab50a4c7ec6934c71c93fc18fd14680180b43071e8d9d704f7ac9a ./code/bit/checkers/finite_g.py +b9fa3cd05f36f5fcebfdebfb4a86fb90e92ed3c1d9157c52918ee8c5b563b54f ./code/bit/checkers/geometry_g.py +223a5a07731fc315a90a3e48177796babc155c1d9985c7ae5017eff6af2a0608 ./code/bit/checkers/gram_frames.py +aaf127c04cb31c406e5b04a63f1ae89369fccde6d8fa7cdda1ed4f32dfc5de63 ./code/bit/checkers/json.hpp +6c1ef2b24e57781d6951c172a1024fc4300e6fd392c9d6672079a7806ab663b3 ./code/bit/checkers/legality_h.cpp +8140eec180e42202f2c6a9f11f5c92885e60861c38a7611dd805c524e3438138 ./code/bit/checkers/tile_g.py +8a5999601f917dbb492bb9ae9a344611f18cc7cedc53dc3c76496a369e530eb3 ./code/bit/export_records.py +f69379968367544807db2f0cf14359977e56299383b3edcc4469ddea7c7ecb40 ./code/bit/independent/centres_sat.py +11bf9620ca9db16d52d9fe806b814fc9ec9a89c4d7645354d1861d96f6e805ad ./code/bit/independent/checkword.py +0ff65aace5da4b57d96235bf830f8f11969322e75134d498aeb70e9753ec6b0d ./code/bit/independent/mutate.py +b0e75d6550412a7be4017695e6b237392b611bb852ad8ff309d6682c9f166a4e ./code/bit/mutate_records.py +60fea6a9d6617a3f87376d3fda040642e9cb70e7c179015e03ede8d289f30357 ./code/bit/producer/compile.py +0e23d4282ceb75768e82631da016aaff9818aec53c7d75a6b2a28ee1b1160dc3 ./code/bit/producer/compile2.py +4f8a6843e83bc4f7055d7337f33dbe12ce499051f46bee1b81bbf6b34c652574 ./code/bit/producer/e8lib.py +ba71f77dd3e3c1c54f361c066cebe9faadbc78db46376046e7af625bf1de8c24 ./code/bit/producer/frames.py +0daf87599e9e48646b985ad87351c56c1b73cfc99cdf9eca081483846ddbfa90 ./code/bit/producer/fullword.py +359040fb432fd392472af6b8f5dca0234dd6c2be744a791df27ba62bc5da5175 ./code/bit/producer/ham1.py +fdf0af785ce697bd7f80b4e75f7163735f3b599d9dc42f652f0ffdbdf18ea8bf ./code/bit/producer/ham2.py +1256c54debe0a551da8e24896ab73ef0bd4a5233ff8e6fedf21a9e6301d6e6f3 ./code/bit/producer/params-r865.json +46c858e60ba0a117bf8227b864abf55e85ebee2d56a0dce64472b706499ac405 ./code/bit/producer/price.py +4999c5d6bac9757e4236c45435201631eae21f644dc9543d8c0b6e3cc8360daf ./code/bit/producer/search2.py +935ea65d9c6739e868ccf1aa439bd3c246657dfc887e4a0222a8f0901a5b41a5 ./code/bit/receipts_e8.py +fc03e8f7bf73d7d70346b87c835d44508b0581c9ff9aec708fbbd4f0121e0394 ./code/bit/regression/certify_bit.py +26f5c9be3a7f545d50be458e3d17403921b5542a7dcd2986c848664a774977a8 ./code/bit/regression/columns_h_pr346.cpp +d55d2b865d1c3d35e343e1a38c592b9172ed8e2596d1107e34d92e2a80c7d03f ./code/bit/regression/cost.py +aaf127c04cb31c406e5b04a63f1ae89369fccde6d8fa7cdda1ed4f32dfc5de63 ./code/bit/regression/json.hpp +5661d0b91e07d95736bde4c1824f27bebaecce0a84e38403f5391ebc51a52056 ./code/bit/regression/legality_h_pr346.cpp +7bd5cb48537621f1217d174274d42483da4e2d02feec238643c798c36b30366a ./code/bit/regression/prime_new.py +98cd03bc9582e7bd0ab194c191ea8eea940539e510051443ab9fd3e572a364ab ./code/bit/regression/prime_witnesses.py +6c288f6f234b528c1a7c0a4adfb724e91e0fe6b18c8dffad96af3f973de1829a ./code/bit/regression/stage_cohort.py +38c3f78daac118395565a65fa3543b1c349638ff2519ce7fda0dad2d788e90ae ./code/bit/regression/tile_check.py +7e480b7761fa700944a7dca41ccbefd530203b5e9168b6b37fe879b7e6da57fa ./code/complex/certify_complex.py +52d68781eaf6d9decf02446a532a7336fcf15924a9f6781ba0833d038decb9f8 ./code/complex/code/complex_basis.py +ccc924537db0c0d55f0c1934e79b8cf4d85b4fb336473d7b42d69e12557aa9f2 ./code/complex/code/complex_gx.py +e000ee131389fec427388b85f632879cbaaf10e5e5d979a47d6307d64ce58982 ./code/complex/code/complex_labels.py +38e985ebe8c8e7f8c83c03828abde0c80be418caf95e97afdf2d0c357c0ed919 ./code/complex/code/complex_scalars.py +aaf46c8e5c68875b8315892e924e082b2f219f8d042dd14937e7cd2f72456dce ./code/complex/code/complex_splice.py +93b78a2e038b23264d04836928c78b6ebf33b87ff3dcc0e43ba0f1748fadd143 ./code/complex/code/p10pins.py +dfd1afbbb3ff86f54db6a0313916403ec8ee6f939caa62f3edcc9d7a151bff95 ./code/complex/code/scatter.py +c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4 ./code/complex/inputs/complex/LICENSE +9419dd03a2f52cf8bdfc4d18216ce29f263ab583b27f01ced8e420985bcb7c81 ./code/complex/inputs/complex/NOTICE +66d8f4ea8752abd89952d6674a636575a0db16e18b1c16e293f48f64242f0c46 ./code/complex/inputs/complex/retained/FINITE_BRIDGE.txt +2bc28e50f3eb092195294cafa81213e520f6d42e7935e9905ad8a6199e2a7c87 ./code/complex/inputs/complex/retained/compact-control-layout.tex +b963c3d2f4e1b7059aa289bb4b4ac89b688920bcf42f5b20d7698cdef0132cc6 ./code/complex/inputs/complex/retained/compact-control-movement.tex +00117892971ae766188ace0af03030c44164fda105e42b70d84f52c3339a7dcb ./code/complex/inputs/complex/retained/copied-centers-assembly.tex +d0ce6d3d504996aadb098227885224e48df46101daec8893523a0a8b7364d8fe ./code/complex/inputs/complex/retained/copied-centers-lemma.tex +dfee33b0281e5551bb6927f757ff0240abade60ae1800f715afd88853ae0191e ./code/complex/inputs/complex/retained/endpoint-gauge-complex.tex +c9bb9655b594583c6b4bab8cb485233f1d1e588f83858cf1e4c3530cee8fed54 ./code/complex/inputs/complex/retained/general-clifford-frames.tex +4738089103a4b263b3b0ef458f5ef35519c696f1ea871ae79e508d3720f5870a ./code/complex/inputs/complex/retained/stopped-product-complex.tex +0d76527bf9c259b9532466a7b056ad6ff118867a96e044ff8e1a24aca12e1dbb ./code/complex/inputs/complex/source-pins.json +5c24746a6330907b9b37d6064095035a58575d64ce793d6d7c9881121fdc3980 ./code/complex/inputs/complex/sources/Work__Bridge__Cert.lean +cf7d7d330b1bffe2e66712c873e647b13dc32db1ccfc0e0f4cd62ee6caf584f0 ./code/complex/inputs/complex/sources/Work__Bridge__Net.lean +6d0649eb62589e66057f044e1e2103fc42f3f57a1498f82a26565bd8eb4026d0 ./code/complex/inputs/complex/sources/Work__Carrier__Live.lean +71dc3dda23dfe510d5d53cbada3a6c540cd1dc2825503fda618a5bd6cfc3e812 ./code/complex/inputs/complex/sources/Work__Carrier__Phases.lean +2e8e88efd4dcbdf0b1a6e39ce7eea8c5fd5ffee2faf360a8c0c9cba84c0e4ef3 ./code/complex/inputs/complex/sources/Work__Fourier__Main.lean +c302f5834287421f11f3b0da7112fcde876cbc702896f2af4145b2d72ee393a2 ./code/complex/inputs/complex/sources/Work__GCert__Chain__Geom.lean +ade7e7873da75ca63a4b5ce2f562dde9c12bfbb69d87d7ae831039ff790e5adb ./code/complex/inputs/complex/sources/Work__GCert__Chain__InvThm.lean +22ae34809466b4ac2a2c5cdde526f51ff246f5189f7c142b38aa4c0dcffb04a4 ./code/complex/inputs/complex/sources/Work__GCert__Chain__NetCert.lean +6e17a68b1e988969f6eb77000028f7ed877e687b8ad3976ec1707fcfe1d2f520 ./code/complex/inputs/complex/sources/Work__GCert__Chain__NetDef.lean +c122bc01392a6fdcc0bee918fed81804d3c9b1d3e071016dab65a4ed804ef0b6 ./code/complex/inputs/complex/sources/Work__GCert__Chain__NetStage.lean +0de429c80231334f1ce92575c1e8ac382ca2d5e7d956767b547639a8941d9a8c ./code/complex/inputs/complex/sources/Work__GCert__Chain__Phased.lean +c33ec3fce09c0971c32ddcbb86d9383ffbe4c6d05cf36f20460005e6547bb845 ./code/complex/inputs/complex/sources/Work__GCert__Chain__WinB.lean +cb61f304da51f1dd0a2ec25bca4b63eb095eeb2863289e1e2bdee7c82beff48b ./code/complex/inputs/complex/sources/Work__GCert__Data__B2Gp193Main.lean +d5314f2b93a7f0e1c949fb502331825bfc6d9d8762d35f865443e7c95b6c7ef7 ./code/complex/inputs/complex/sources/Work__GCert__Data__Glue.lean +9587ddb9961f44938032b609307ab91c0b0e757e3991f1ad95480dd50fd4f72b ./code/complex/inputs/complex/sources/Work__GCert__Data__InstB2Gp193.lean +d92ee6889be4753fc99f467bd84039743325123a1165128378b9c906a04f2703 ./code/complex/inputs/complex/sources/Work__GCert__Data__P193Cert.lean +0299bcd0fe255960eec682eef0f045f7e5cb1e4711af2aab4393526eae2caea3 ./code/complex/inputs/complex/sources/Work__GCert__Data__P193Price.lean +479434815822e98f015e335361089c3788d00dc3dd39c2944f75410aa0c158fe ./code/complex/inputs/complex/sources/Work__GCert__Data__P193ScalOK.lean +6b40cac1481c931d47b1a092e382d04716ede0e785c492a2f2983e886a257c3f ./code/complex/inputs/complex/sources/Work__GCert__Data__RateB2Gp193x.lean +aba94a004c94dcae7cf3047c88a6da9561555f4ebe8ab92e299e6ce09ee7aa66 ./code/complex/inputs/complex/sources/Work__GCert__Data__Raw.lean +45c768c9d71a7cc18bd6db74cb036db880d89580ca60557bb4a492280296b169 ./code/complex/inputs/complex/sources/Work__GCert__Data__SolutionB2Gp193x.lean +feec0a3828867968a5c7c2c30b86ed70449abc3c660a60ada67203a75bae2ef7 ./code/complex/inputs/complex/sources/Work__GFrame__Engine__Adapt.lean +34906dbf5ae16b5174db00b4881a5cc1d2e583b8c8806db6523a5e2f86565f09 ./code/complex/inputs/complex/sources/Work__GFrame__Engine__Letters.lean +80fb3daa9a45de0ed6da570eb4476b9104734be65d0116f58bcfcbcd67f771d0 ./code/complex/inputs/complex/sources/Work__GFrame__Engine__Level.lean +6ba897a9495ddadcf8558b93133fdfaf66fc35ce7fa2c53e2d5667335c315e0b ./code/complex/inputs/complex/sources/tools__gx__ORIGIN.md +6f3dc8bb639933227a8dae181ec4a542e85c7276be9c9e330f49518e7b630b95 ./code/complex/inputs/complex/sources/tools__gx__gx.py +9c9dcfac47f0535bf3aa8ebf7c662cdef0ebda50a9f0a9282b8f3cf34809f835 ./code/complex/inputs/complex/sources/tools__gx__gxbind.py +dab7fec9f44c2d368ed334055d7126e202017feb46e41a8d86e2d998720f67c2 ./code/complex/inputs/complex/sources/tools__gx__gxconv.py +eb972c06fe8c322db2d9a8d9a7d05596e8f40c4ca8e5f42eb6df3c7361b5d517 ./code/complex/inputs/complex/sources/tools__gx__gxcore.py +c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4 ./code/complex/inputs/e8/LICENSE +557c9ad4660eebd14a00583736c4d12d2c45f3fc9bc148845f9f3efec72c9434 ./code/complex/inputs/e8/NOTICE +842b217147cf84e8042d6ef1c33104d5444b6587b594664bc9eb89b237ab4ad0 ./code/complex/inputs/e8/Work/GCert/Data/B2Ge8.lean +987103107d5586c096016f0a702d0de35b74398dbb50ac66f5886a43a5ca0d05 ./code/complex/inputs/e8/Work/GCert/Data/B2Ge8Main.lean +a59db9d54b83adc73391916f7c1ef5e381ff073027781c26cb350f43b79839e3 ./code/complex/inputs/e8/Work/GCert/Data/ChallengeB2Ge8x.lean +13a243c7d7be31ae429d19b5ecd5d428d60c41b7cca8a330f0c4179b110ba7ea ./code/complex/inputs/e8/Work/GCert/Data/E8Cert.lean +cd250dd72406dde37765c501f666ceeedcc18f831070b26369bcb154c1f99a8e ./code/complex/inputs/e8/Work/GCert/Data/E8Price.lean +6bd5e68effe8913a3f73e25ea59142cd9928ddf81e94250a6ea28aa7317388b3 ./code/complex/inputs/e8/Work/GCert/Data/E8ScalOK.lean +5c7fb23df2c10b690f638a19bf066905b5b620b8a2ad0ffde76cc9348d8aa2b4 ./code/complex/inputs/e8/Work/GCert/Data/Gen/E8.lean +36de82f6969c23082876a4d6848428623d1c65d2df3fc917f23ecba003189dd2 ./code/complex/inputs/e8/Work/GCert/Data/Gen/E8/S0.lean +6ea83365afe01664b2132a630511b4de65f938dc328744ce7f77a01fad97f32d ./code/complex/inputs/e8/Work/GCert/Data/Gen/E8End.lean +cce81699abe1f85a870dcf64edd395d2cf5a586da7700af565b557093095ab51 ./code/complex/inputs/e8/Work/GCert/Data/Gen/E8Hist.lean +a343219b419f30f8ac4dd3a0a98bf53550c5fec6b2cbd245320a95977c319016 ./code/complex/inputs/e8/Work/GCert/Data/Gen/E8Par.lean +78036e5443775ade5bde46a77ba3e0433fe22160da11b5b6c96c7f1075ecfbbd ./code/complex/inputs/e8/Work/GCert/Data/Gen/E8Scal0.lean +f6b248dc4c3b2c94db95989b6bd5ad3c3f0d7ece3a511e5b69069550b821b138 ./code/complex/inputs/e8/Work/GCert/Data/Gen/E8Seg0.lean +79d16ccceb61391446ea97f77fddadafa9150e9dea97919e775f6c78daa71839 ./code/complex/inputs/e8/Work/GCert/Data/Gen/E8Seg1.lean +924340aebc6f68b5a6526311ce33341af0a0a5a8375416762f08c1914ec08abe ./code/complex/inputs/e8/Work/GCert/Data/Gen/E8SegF.lean +650600b631a21221956f9abbab9abebcc9cca628512d3e9a017e2373e2649b17 ./code/complex/inputs/e8/Work/GCert/Data/Gen/E8Tab0.lean +60036fa4deeb19d39fc0dddf31359d2b6d2407ff66070f145b111bff16190eb0 ./code/complex/inputs/e8/Work/GCert/Data/Gen/E8Tab1.lean +c8a248da3eb770ba55ef267d118b29d49983311087ef789398d555e2c44b3a41 ./code/complex/inputs/e8/Work/GCert/Data/Gen/E8Tab2.lean +41975d430ec0095ad465a36d4903e90c01bc891d3abe5e2c372ef786c029a7ed ./code/complex/inputs/e8/Work/GCert/Data/Gen/E8Tab3.lean +a290360c175544cb85edffe1b92fcf7d447cba09128e19de8dc87e0a1ff0c524 ./code/complex/inputs/e8/Work/GCert/Data/Gen/E8YChk.lean +c1fee298187ea19b5d70fcfccef7d4fd4161be70c0adda19a89ca9933a759954 ./code/complex/inputs/e8/Work/GCert/Data/InstB2Ge8.lean +7b6e59724c0f140e714afba237d5a1a91b22da70abc096ce274690140b39a3a6 ./code/complex/inputs/e8/Work/GCert/Data/RateB2Ge8.lean +7c56d865ed6bfcb6919dabc1a6e53f8744ff4824a2f78335787485f3090970d1 ./code/complex/inputs/e8/Work/GCert/Data/RateB2Ge8x.lean +dd52f1fe0a372480edaf5e6c64903d6257c410e43d406f8acb6bf8f60a1ee28f ./code/complex/inputs/e8/Work/GCert/Data/SolutionB2Ge8x.lean +ddad06c37f9268986f3ec8ce43da5230ee2bd887da2480328413a0dc58f2a926 ./code/complex/inputs/e8/comparator/B2Ge8x.json +4b92f00fc7454b9b15e6d71a3b05062792eacca0a0ca4efee46f87827d57c8aa ./code/complex/inputs/e8/tools/certificate/gcert1-e8-r783.json.gz +be41ee310f28121c3e424cc8637d8fa02ef7c47fc8945e9bbd3856138fd800d6 ./code/complex/inputs/e8/tools/e8/replay.py +a0f16e2c9e078ffbfb2174281ee93a48c18593aefb880318fc105ec85a205932 ./code/complex/inputs/e8/tools/gen/foldgen.py +7a3c38a698c129e13a767da75926a1305eb0c031b908450afc6feb185505c59a ./code/complex/inputs/e8/tools/gen/foldlib.py +ef8c869e4cf8da33a4c10b96f7f6faafd46e15d66766238070a60315aa169994 ./code/complex/inputs/e8/tools/gen/gen_rates.py +1b5eb3730cb16cf516e760879951fdfb9b065efc55f78c29a5c6404fcca57a78 ./code/complex/inputs/e8/tools/gen/gen_sharp.py +0488b7a2442c795414f103df912d1e6cc66d37b5be270940ea9564b7f2b666be ./code/complex/inputs/e8/tools/gen/templates/ChallengeB2L16x.lean.txt +d414a890dfe126916374c1afc804b90e5081b7760f894b9ccdcf23d83a12f9ee ./code/complex/inputs/e8/tools/gen/templates/SolutionB2L16x.lean.txt +0e22bbe5924284e2fb916337ccefc8e41f6e54469749986ad15b3b81cfaec534 ./code/complex/inputs/e8/tools/gx/gsmirror.py +9c9dcfac47f0535bf3aa8ebf7c662cdef0ebda50a9f0a9282b8f3cf34809f835 ./code/complex/inputs/e8/tools/gx/gxbind.py +eb972c06fe8c322db2d9a8d9a7d05596e8f40c4ca8e5f42eb6df3c7361b5d517 ./code/complex/inputs/e8/tools/gx/gxcore.py +ce9151054370c2210ed08f54c249a19dcb6946d182cdf934dee1a3781b53040f ./code/complex/inputs/e8/tools/gx/gxgen.py +f00802d48ef3fedb00278f0b1c7bde074cc49dd30f202d7f32a9d2aebb3be443 ./code/complex/inputs/e8/tools/gx/gxpaths.py +514a5719f970fe36b1273cf59df0396db0e042dd7864c2eea53ab2a2fd1e2ad6 ./code/complex/inputs/e8/tools/gx/gxrate.py +3cc09a9c1a2db681c0f2016bc821af5b674d34834dbd6f195b9d482ce7c0ff58 ./code/complex/inputs/e8/tools/gx/gxunit.py +b6172d58749c0b3b9138570c74827bcb23bf5db4ff9643740768cd7782ac4ca6 ./code/complex/inputs/e8/tools/gx/regen_check.py +ad8fe9811c6ea0d89c795caef48686cfca600f5d540ebfd5d1251d6777cec7cf ./code/complex/inputs/e8/tools/gx/regen_check_e8.py +bf66f785878f636616ceab193e5a222143945ea06fc2f13dfb99b204ebba82ff ./code/complex/pins-e8.json +44e8ae8a5b915358a97dbed5fe4e70195ed3581fd45a216df48fc82a029db87d ./code/complex/portable_complex.py +29479da1547cd39cf20fe387cde4cad847a2880266db9d0ef3fb474f68591feb ./code/complex/regress_pr346.py +aee70c242a2f1d225528fabe2002e1564d1dc884797c07d28a831c7878ee9098 ./code/pricing/base_two_moment.py +81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482 ./code/pricing/moment.py +c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c ./code/pricing/outer.py +98cd03bc9582e7bd0ab194c191ea8eea940539e510051443ab9fd3e572a364ab ./code/pricing/prime_witnesses.py +5fe7174cd3a6580a74e4c1bf8fa7b426e8673f1c285603bf3076d4e758d70731 ./code/secondary/bridged.py +96e11030a3a82da37e18b9acb89c1ecd6a93412dc940efded106d0521632ab50 ./code/secondary/seven_stage.py +cfc30216f441a1c44a533f2f26954f90e454136af8842c497de4e2da9bd32d8d ./data/bit/RECORD-SHA256SUMS +1fb726ea3818fe0837cceb0dd22a71a0814f064e5e781628104610d6468e0e55 ./data/bit/bitE8-r865.json.gz +caabc13126e8f87d08f7697f51512cb3431ff52861f4190149251d8e19224430 ./data/regression-p10/BASE-RECORDS.bin.gz +35070b83d12ebc60003ed344315328713134a43bdb04217c2c5cbc39e101391f ./data/regression-p10/BASE-frames.json.gz +1e37ae5001447dd78a8287d8aa23d73a1d5862c4017f44db49af327f58d7cf22 ./data/regression-p10/BASE-states.json.gz +0bd464f873b0f59622026793affb308bf087833de6f3197202adc7a36d9d0782 ./data/regression-p10/receipts-loans/banks.json.gz +82b21b4e6bb4b20e0ecbca44f59941362f57a26a019f179e19b5b7b86262a116 ./data/regression-p10/receipts-loans/finite.json.gz +7dccea4b8c4a81597779dc0944297d5f60efd9e2e5b19469417712e2192c6cca ./data/regression-p10/receipts-loans/global_result.json.gz +c4074b86171c5bde8fbbff6df0022a116f17e11f0d2116ae3dfe75c8b2a18c64 ./data/regression-p10/receipts-loans/math.json.gz +505c13c667230e946e708d7c9086de34d1c5e259a557f6685765054001e29981 ./data/regression-p10/receipts-loans/raw.json.gz +e7bb691b741227ce389ff6341fa0548ff8f638cc492a06be40fcd829fac0bed9 ./data/regression-p10/receipts-loans/scalar.json.gz +b9f87c1ec529679c19b8421a7a69b377b54b89949cfc5e1b1ed8c134bfab8917 ./requirements.txt +9657a46eb8073434d23fb06e46ea5722edcec8c2f38091208ea363d77db346c7 ./verify.sh diff --git a/research/e8-bit/NOTICE-PR352.md b/research/e8-bit/NOTICE-PR352.md new file mode 100644 index 0000000000..4f9a0194a3 --- /dev/null +++ b/research/e8-bit/NOTICE-PR352.md @@ -0,0 +1,33 @@ +# Attribution and provenance + +Prepared by DaysSky, assisted with Claude. Apache-2.0 (see `LICENSE`) applies to the new code and to the inherited Apache-2.0 +code below; third-party notices are preserved where files are vendored. + +- **Complex supplier: the E8 unit** (`code/complex/inputs/e8/`): Jacob Sussman, jacobalansussman/wht-power-saving-lean + at `9c94857bbaee886f8649edee0bc2d3c738f9555e` (Apache-2.0, Copyright 2026 Jacob Sussman; his `LICENSE` and `NOTICE` + are vendored beside the files). The certificate `tools/certificate/gcert1-e8-r783.json.gz`, the 24 Lean modules and + the comparator configuration of his kernel-checked theorem `wht_main_block_B2Ge8x`, his Lean-data generators + (`tools/gx/{gxgen,gxrate,gxbind,gxunit,gxcore,gsmirror,gxpaths,regen_check,regen_check_e8}.py`, + `tools/gen/{foldlib,foldgen,gen_rates,gen_sharp}.py` and templates) and his stand-alone `tools/e8/replay.py` are + vendored byte-identical and sha-pinned in `code/complex/inputs/complex/source-pins.json`. His README credits + devices from this repository in the unit: slot reuse with a compensating read (jamesyc #124, eumemic #143), late + pairing (Chafik Boukhalfa #200/#233), the in-place pair (icekylinx #184, carried in ikeboy's #191/#193). +- **Bit word, Design T, twin condensation, checkers and engines** (`data/bit/`, `code/builders/`, `code/checkers/`, + `code/pricing/`, `code/export_p10.py`, `code/stage_cohort.py`): unchanged from LJH-217's PR #346 at + `11b4de5ff8ed5fccf55d4af1043358d257308e8e`, which builds on DreamingOfClouds' PR #325 p10b word and PR #315 engines + (#285/#276 gen5/gen4 lineage on eumemic's PR168 generator and source527 package, PR #200's physical rules, hcg890 + and Jacob Sussman's five-stage architecture, Evan McKinney's completed banks), utcorvusvolat-dotcom's w3 Design T, + twin condensation and verifier (PR #310) and PR #266's official checkers. See PR #346's notice for detail. + `json.hpp`: Niels Lohmann, MIT license in its header. +- **Complex checks** (`code/complex/portable_complex.py`, `code/complex/code/`, `code/complex/inputs/complex/`): + PR #315's portable complex checks as ported to p = 10 in PR #346 (#256/#233/#202/#200/#194/#184 lineage: + icekylinx, Chafik Boukhalfa, Avi Eisenberg, eumemic and others). Jacob Sussman's `gx.check1`, `gxcore` and pinned + Lean chain sources under `code/complex/inputs/complex/sources` are unchanged from PR #346 (byte-identical at + `9c94857` except his `ORIGIN.md`, kept at `f010392`). +- **New here**: `code/complex/code/scatter.py` and the generalization of the label, scalar, splice and guard checks + from the paired-cube star scatter with h centres of rank h − 2 to any gx scatter (table or star) with any number + of retained totals of any rank (regression: on PR #346's p = 10 program the generalized checks give byte-identical + scalar schedules, splice programs, primitive expansions, ledger and precision guard); the generalized final-climb + partition; the E8 pins; the Lean-binding and replay steps of `certify_complex.py`; `verify.sh` changes. + +Credits do not imply endorsement or review by the credited authors. diff --git a/research/e8-bit/NOTICE-PR363.md b/research/e8-bit/NOTICE-PR363.md new file mode 100644 index 0000000000..a30cf4beae --- /dev/null +++ b/research/e8-bit/NOTICE-PR363.md @@ -0,0 +1,23 @@ +# Attribution and provenance + +Prepared by DaysSky, assisted with Claude. Apache-2.0 (see `LICENSE`) applies to the new code and to the inherited +Apache-2.0 code below; third-party notices are preserved where files are vendored. + +- **The bridged word and the E8 unit** (`code/complex/inputs/e8/`, `code/complex/inputs/complex/sources/`): + Jacob Sussman, jacobalansussman/wht-power-saving-lean at `9c94857bbaee886f8649edee0bc2d3c738f9555e` (Apache-2.0, + Copyright 2026 Jacob Sussman; his `LICENSE` and `NOTICE` are vendored beside the files). + - B₂ is his: the bridged five-stage word (`Work/Bridge/Net.lean`, `Work/BridgeGeom/*.lean`) and its general + stage geometry. `code/complex/code/bridged.py` generalises its schedule and twin gates to K pairs. + - The E8 certificate, gx, gxcore, the Lean-data generators and the stand-alone replay are vendored byte-identical + and sha-pinned in `code/complex/inputs/complex/source-pins.json`. +- **Complex checks and pricing** (`code/complex/`, `code/pricing/`): PR #352 (DaysSky) at + `04b4c3c478b5bd8797d2663d89d8db4dfd0ad9f2`, on LJH-217's PR #346 port of PR #315's portable complex checks and + engines (#256/#233/#202/#200/#194/#184 lineage: icekylinx, Chafik Boukhalfa, Avi Eisenberg, eumemic and others). + `SOURCE-pr352.json` pins the 93 unchanged files by git blob id. +- **New here:** + - `bridged.py`: the bridged word B_K and its finite layout check; + - the layout parameter K in `portable_complex.py`, `complex_splice.py` and `complex_scalars.py`; + - `pins-e8-b3.json`; + - `certify_b3.py`, `provenance.py` and `verify.sh`. + +Credits do not imply endorsement or review by the credited authors. diff --git a/research/e8-bit/NOTICE.md b/research/e8-bit/NOTICE.md new file mode 100644 index 0000000000..c244e3f56a --- /dev/null +++ b/research/e8-bit/NOTICE.md @@ -0,0 +1,47 @@ +# Attribution and provenance + +Prepared by Dylan Crow, with Anthropic Claude assistance. Apache-2.0 (see `LICENSE`) applies to the new code and to the +inherited Apache-2.0 code. Third-party notices are preserved where files are vendored. + +## New in this package + +- The E8 bit word `bitE8-r865` and its producer (`code/bit/producer/`). +- The record exporter. +- The independent checker and the controls. +- The centre-count CP-SAT proof. +- The generalized bit-side checkers, each with a documented default that reproduces the original: + - `NCOPY` in `legality_h.cpp` and `columns_h.cpp`; + - the `--gram` parameter in `gram_frames.py`; + - the label-family parameters in `geometry_g.py`; + - h and replicas in `tile_g.py`; + - h and T in `certify_bit_g.py`; + - NCOPY and the route template in `finite_g.py`. +- The receipt assembler. +- The secondary `seven_stage.py`. + +## Vendored + +- **`code/complex/`, `code/pricing/`**: unchanged from PR #352 (DaysSky) at `04b4c3c478b5bd8797d2663d89d8db4dfd0ad9f2`. This + includes: + - Jacob Sussman's E8 unit, Lean data, generators and replay, from jacobalansussman/wht-power-saving-lean at `9c94857` + (Apache-2.0, Copyright 2026 Jacob Sussman; his `LICENSE`/`NOTICE` are beside the files); + - PR #315's engines (`moment.py`, `base_two_moment.py`, `outer.py`, `prime_witnesses.py`). + See `NOTICE-PR352.md`. +- **`code/bit/regression/`**: unmodified from PR #352 / PR #346 (LJH-217): + - `legality_h_pr346.cpp` and `columns_h_pr346.cpp` (PR #266's official cohort checkers as generalized in h by #346); + - `stage_cohort.py`, `prime_new.py`, `tile_check.py`, `cost.py`, `certify_bit.py`. + The generalized checkers in `code/bit/checkers/` derive from these, and from the source527/p10 packages' + `finite_check.py`, `geometry527.py` and `global_lowering.py`, whose lineage is: + - eumemic's source527 package; + - PR #200 (Chafik Boukhalfa); + - PR234 (hcg890 / Henry Grant), on Jacob Sussman's five-stage architecture; + - Evan McKinney's completed banks; + - the p = 10 ports by DreamingOfClouds and Chafik Boukhalfa. +- **`code/secondary/bridged.py`**: unchanged from PR #363 (DaysSky) at `9df55dad6ddd05c3458793dfd82d1c2fe0ddbbb4`. + See `NOTICE-PR363.md`. +- **`data/regression-p10/BASE-*`**: PR #325's p10b word as exported in PR #352 (DreamingOfClouds; #352 `data/bit`). +- **`data/regression-p10/receipts-loans/`**: verification receipts of agent G's p = 10 passive-loans package, used only as + regression input. +- **`json.hpp`**: Niels Lohmann, MIT license in its header. + +The E8 label family on the bit side follows Jacob Sussman's introduction of the E8 family for the complex supplier. diff --git a/research/e8-bit/PR-STATEMENT.md b/research/e8-bit/PR-STATEMENT.md new file mode 100644 index 0000000000..c37fb030cf --- /dev/null +++ b/research/e8-bit/PR-STATEMENT.md @@ -0,0 +1,51 @@ +# E8 bit word: κ = 8.75481145306751e-4 (complex-bound) + +**Claim.** We claim a conditional κ = 875481145306751/10¹⁸ ≈ 8.75481145306751·10⁻⁴. That is +9.29 % over #352 and ++8.54 % over the best p = 10 bit package. + +**What is new.** This is the first bit supplier that is not a paired-cube word. Its labels are the 120 root lines of E8 +in Q⁸, with the E8 form, which is positive definite, so every frame is nondegenerate: +- h = 8, m = 40, v = 120, R = 865; +- 9 retained totals at the full frame, so copy loss 72 and deficit 120; +- the junk of each target is the E7 in its cap; +- a side network built on D4 blocks and π-coset pairings, after a local search. + +**Bit coarse saving.** c = 9.04072820242522·10⁻⁴. That is +12.0 % over the previous bit root and 3.2 % above +Sussman's E8 complex unit (b = 8.76248285600677·10⁻⁴), which therefore binds. With #363's seven-stage b₃ the same bit +word would bind at κ = 9.0326e-4; this package reports that number but does not claim it. + +**How it is checked** (`bash verify.sh DIR`, about 2.5 min): +1. The word is regenerated from its producer parameters. +2. An independent checker verifies: + - exact rational frame legality; + - the exact F₂ identity on all 1105 columns, with dirty helpers; + - the Gram determinants and the price. + It rejects 6 word-level mutants. +3. The **PR #266 official legality and five-stage formal-columns checkers** run with h = 8 and NCOPY = 9. 6 record-level + mutants are rejected. +4. Exact nondegeneracy under the E8 Gram and PR #315's prime-witness rule. The only prime is 2. +5. PR234's five-stage route and idle geometry is checked on all 120 ports, with W(E8) reflection words as port + isometries. The idle ranks are (14, 7, 18, 4). +6. Banks: 173 exact width-40 banks. +7. PR #352's complex checks, unchanged. +8. PR #315's moment engines and the outer assembly with all 47 constraints. The adjacent grid point is rejected. +9. The finite bill at m = 40: coefficient 41 bits < 2⁸⁰. + +**Regressions.** Every bit-side generalization has a parameter whose default is the original. On the PR #325 p10b word, +and on agent G's p = 10 loans receipts, each one reproduces the original checker's output: +- legality: byte-identical receipt; +- five-stage columns: identical receipt; +- prime witnesses: identical counts; +- banks: byte-identical output; +- certify_bit: identical fields; +- finite bill: the same coefficient, gaps, chain and route hash; +- geometry: the same routes. + +**Admitted explicitly.** 9 retained totals at h = 8: a layout pin of the paired-cube words. It is charged as NCOPY = 9 +copies, temporaries and episodes. All inherited bit-supplier interfaces, and #352's complex obligations, are retained. +PR234's bank construction for a non-paired-cube family is checked on the exact matrices; it is not re-proved. + +Author: Dylan Crow, with Anthropic Claude assistance. Credits: +- Jacob Sussman: the E8 family and unit; +- DaysSky: #352, and #363 for the secondary step; +- #346/#315/#266/source527/PR234 lineage: see `README.md` and `NOTICE.md`. diff --git a/research/e8-bit/README.md b/research/e8-bit/README.md new file mode 100644 index 0000000000..7b63e1feb5 --- /dev/null +++ b/research/e8-bit/README.md @@ -0,0 +1,152 @@ +κ = 8.75481145306751e-4 + +# An E8 bit word: the bit supplier on the E8 label family + +This package gives a conditional finite construction with **κ = 875481145306751/10¹⁸ ≈ 8.75481145306751·10⁻⁴**. That is: + +- +9.29 % over PR #352 (8.01083628465007e-4); +- +8.54 % over the best p = 10 package we had verified (8.06611444687371e-4). + +Until now every bit word has been a paired-cube word: transversal triples of point-pairs, with the form G = I − J/9 on +Q^h. This package replaces it with a bit word on the **E8 label family**: the 120 root lines of E8 in Q⁸. Jacob +Sussman introduced the E8 family for the complex side (#352). + +| side | supplier | coarse saving | +| --- | --- | ---: | +| bit (new) | E8 bit word `bitE8-r865` (h = 8, v = 120, R = 865, m = 40, 9 centres) | c = 452036410121261/(5·10¹⁷) ≈ **9.04072820242522·10⁻⁴** | +| complex | Sussman's E8 unit `gcert1-e8-r783`, PR #352's checks unchanged | b = 876248285600677/10¹⁸ ≈ 8.76248285600677·10⁻⁴ | + +The bit coarse saving is +12.0 % over the previous bit root (8.0726e-4) and 3.2 % above the complex supplier, so **the +complex side binds again**. κ is the complex-bound assembly of PR #315's `outer.assembly`: all 47 constraints hold, the +complex leaf cap itself is rejected, and the adjacent 10⁻¹⁸ grid point is rejected. + +## The construction + +**Labels and form.** The 120 root lines of E8 in Construction-A coordinates (from the [8,4,4] Hamming code) are: +- the 8 frame lines 2eᵢ; +- 112 codeword lines: ±1 on a weight-4 codeword, with a sign pattern taken modulo ±. + +The form is ⟨x,y⟩ = x·y/2. It is positive definite, so **every frame is nondegenerate**. Data role S starts at its line +and ends at the full frame. Target t ends at its cap t^⊥, which has dimension 7. + +**Decoder.** There are 9 retained totals at the full frame: +- T₀ = Σ x; +- Tᵢ = Σ over S with B(aᵢ, S) = 1 of x_S, for an F₂-basis a₁…a₈ of E8/2E8, where B is the symplectic form ⟨·,·⟩ mod 2. + +y_t reads T₀ and the Tᵢ with (t̄)ᵢ = 1. This gives x_t + Σ_{S ⊥ t} x_S over F₂. The junk of t is the 63 lines of the E7 +in t^⊥, all inside the cap. +- Copy loss L = 72, so the deficit is 4v − 5L = 120, as in Sussman's complex unit. +- 9 centres are necessary. With a neighbour 8-clique fixed to the standard basis, which loses no generality, CP-SAT + proves that no rank-8 F₂ decoder exists. It finds a rank-9 decoder in 5 s (`code/bit/independent/centres_sat.py`). + +**Side network.** This is the design `ham2` (`code/bit/producer/ham2.py`). +- Notation for a codeword target t: + - t lies in block c, and c̄ is the complementary block; + - Q is the π-coset of t: the 4 mutually orthogonal lines of c that contain t; + - d is the partner of t in Q, and {a, b} = Q − {t, d}. +- y_t climbs C_c̄ (dim 4) → K_p (dim 5) → C_c̄ ⊕ ⟨a,b⟩ (dim 6) → t^⊥ (dim 7). Along the way it reads: + - E(D4(c̄)): 12 lines, shared by 12 targets; + - M(p): 8 lines; + - N = M(p′) + x_a + x_b: shared with d; + - two tops M+M over the cross planes ⟨a,d⟩ and ⟨b,d⟩, with the single line d folded into one of them. +- How the sums are built: + - each M is a sum of two L's (L = 4 lines spanning an A3), and each L is a sum of two pairs; + - frame targets read along coordinate subspaces; + - all sums are built before the scatter; + - dirt is compensated at frame 0, and cleanup happens at the full frame. +- A local search over pairings, fold sides, level-5 choices, frame-target choices and L splits gave R = 865, i.e. 7.2 + helpers per pair. `code/bit/producer/fullword.py params-r865.json` regenerates the shipped word byte-for-byte in + JSON content. + +The local word's five-stage histogram is {1:10380, 2:4710, 3:2240, 4:2330, 5:1540, 6:10, 7:240, 8:90, 14:240, 18:240}. +W = 4v + R = 1345, m = 5h = 40, deficit 120, and the largest child is 18 < m/2. + +## Verify + + bash verify.sh /fresh/dir # about 2.5 minutes; Python 3.11+ with numpy, mpmath, sympy; g++ (C++17) with Boost + +Optional: ortools, for step 7b. The final line is: + + PASS conditional kappa = 875481145306751/1000000000000000000 = 0.000875481145306751 (complex-bound; ...) + +`VERIFY-LOG.txt` is a clean run. + +| step | what is checked | generalization and regression | +| --- | --- | --- | +| 0 | `MANIFEST.sha256` | — | +| 1 | The word is regenerated from the producer parameters and must equal the shipped word. The PR249 records (`MOVE/ADD/COPY/ERASE`, B/A frame bases) are exported and their hashes compared. | new exporter | +| 2 | **Independent checker** (`independent/checkword.py`, no code shared with the producer): exact rational nesting, one common frame per gate, y at frame 0 at the scatter, start and final frames (y ends at label^⊥), the **exact F₂ identity on all 2v + R = 1105 columns** with arbitrary helper dirt, Gram determinants, histogram and moment root. 6 mutants are rejected. | new | +| 3 | **PR #266 official cohort legality and five-stage formal columns** with h = 8 and **NCOPY = 9**: 14,603 common-frame ADDs, rank mass 8,672, 9 COPY/ERASE, all 1345 global columns over the five stages with bridges, prefix bill 60 bits < 104. 6 record-level mutants are rejected, including the unchanged word under the original copy count h. | `-DNCOPY` defaults to `HDIM`. Built without it, on the PR #325 p10b word, the generalized sources give a **byte-identical** legality receipt and an identical columns receipt (wall-clock aside) to the unmodified PR #346/#352 sources. | +| 4 | Exact nondegeneracy under the **E8 Gram** (positive definite; all leading minors > 0) and **PR #315's prime-witness rule** on all 944 frames. The only prime is 2, so any odd address prime works. | `--gram triple9` is PR #346's formula verbatim. It reproduces `prime_new.py` on the p10b word (12,885 frames, 97 bits, primes {2, 3, 11}). | +| 5 | **PR234 five-stage geometry** for all 120 ports, with W(E8) reflection words (≤ 2 reflections) as port isometries. Checked: routes involutive; the stage boundary chain; eight idle boundary pairs with gap ranks (14,14,7,7,18,18,4,4) = (2h−2, h−1, 2h+2, 4); the D_I D_P identity; the five-window completion for the entrance census {σ = 0: 865 helpers}; a duplicated window is rejected. | The original's coordinate permutation π is the isometry g, with g⁻¹ in place of πᵀ. On paired-cube labels at h = 20 the generalized routes equal the original literal ρ. | +| 6 | **Banks**: residual census {8: 865} tiles exactly into 173 width-40 banks of five blocks (1 replica). | `tile_g.py` with h, replicas as arguments. Its output is byte-identical to `tile_check.py` on p10b. | +| 7 | **Retained totals**: 9 > h = 8, admitted explicitly; see below. | — | +| 8 | Complex supplier: PR #352's `certify_complex.py`, unchanged. This covers gx.check1, gxcore, labels, scalar words, splice, precision guard, Lean regeneration of `wht_main_block_B2Ge8x`, Sussman's stand-alone replay, and the exact b. | vendored | +| 9 | **Bit coarse saving and outer assembly**: PR #315's two moment engines, the 10⁻¹⁶ fallback, the adjacent grid point excluded, and the 47 constraints. | `certify_bit_g.py` takes h and T as arguments. With h = 20, T = 12 it gives receipt fields identical to the original `certify_bit.py` on p10b. | +| 10 | **Finite bill at m = 40**. Values are read from this run's receipts: unit additions 14,603, rows 742 and 6,308, stock 1345, K = 27,347,440. Results: coefficient 1,916,288,151,501 (41 bits) < 2⁸⁰; q-power bound q¹⁶⁰¹ (row constant d + 1 = 1601); payload 60 bits < 104; δ_τ > 0; ordinary bootstrap chain. All 120 port routes are exact elementary programs with power-of-two denominators. | The original finite bill line for line, with NCOPY in place of h for copies and temporaries, and the route template generalized to the port isometry. On agent G's p = 10 loans receipts it reproduces the coefficient 24,463,942,022,302,301, the moment gaps, the chain and the route program hash. | +| 11 | Secondary: the PR #363 numbers (next section). | `bridged.py` vendored from #363 | + +## Retained totals: 9 at h = 8 (admitted) + +The paired-cube layouts have h centres, and both PR #266 checkers pinned the copy count to h. #352 likewise bounds +retained totals by the h reserved centre slots. The E8 bit word needs 9 (step 7b). In this package: +- copies are sequential complete temporary streams, one COPY window at a time, and the legality checker enforces that + lifecycle; +- the finite bill charges NCOPY = 9 copied-centre temporaries and 5·9 copy/erase episodes per replica; +- the deficit 4v − 5L uses the actual L = 72. + +What the count changes is physical stock by one temporary slot, not the price. That is the admission: "≤ h" is a +layout pin of the paired-cube words, not a requirement of the construction. + +## PR #363 (seven-stage) — secondary, conditional + +PR #363 (DaysSky) prices Sussman's unit in a seven-stage bridged word B₃ at b₃ = 932783231884153/10¹⁸. Its conditions +are m = 63 ≤ 72, max child 31 < 31.5, and rows 12,064 < 20,161. #363 notes it has no Lean proof of B₃, and its exchange +identity is checked at the abstraction of the `Net.lean` header. `outer.assembly` reads only (a, b) and the generic +bridge, so b₃ is usable on the same terms as #352's b, conditional on #363's own obligations. Step 11 gives: + +| bit layout | complex | κ | +| --- | --- | --- | +| five-stage (this package) | #352 five-stage b | **8.75481145306751e-4** (complex-bound; the claim of this package) | +| five-stage (this package) | #363 seven-stage b₃ | 9.032562102114e-4 (bit-bound) | +| seven-stage B₃ (estimate: no bit construction yet) | #363 b₃ | 9.319139565121e-4 (complex-bound) | + +The B₃ row prices this word's local histogram with #363's idle climbs at h = 8 (m = 56, W = 1585, deficit 216). That +gives c = 9.68198e-4. B₄ gives 9.57e-4. Using it would need a seven-stage analogue of PR234's bit construction (banks, +bridges, source owners), which does not exist. + +## Open obligations + +- **Inherited from the bit supplier, unchanged:** + - the all-size weighted compiler and common ancestor chart; + - restored rows (the external row coefficient 20161 is as in #315/#352; the additive row constants 9909 + 252 are + inherited); + - tape routing, prime supply, precision/recovery and the analytic transfer. +- **New, written here but not formally proved:** + - that PR234's five-stage bank construction carries over to a positive-definite non-paired-cube label family with + rational, non-permutation port isometries. Step 5 checks every port's matrices exactly; the source527 lowering + program itself is not re-run; + - that 9 retained totals at h = 8 are admissible, as argued in the section on retained totals above. +- **Not run on this word:** the source527 scalar program's signed integer decoder (the word is F₂ throughout; the + checks over F₂ are exact). +- **Complex side:** #352's obligations, unchanged. +- This is a conditional finite construction, not a formal verification of the multiplication theorem. + +## Credits + +- **E8 label family and the complex unit**: Jacob Sussman (wht-power-saving-lean, `gcert1-e8-r783`, the Lean theorem + `wht_main_block_B2Ge8x`, gx/gxcore, generators and replay). +- **Complex checks, generalized to any retained-total count**: DaysSky (#352), on the #346/#315/#256/#233/#202/#200/#194/#184 + lineage. +- **Seven-stage bridged layout and `bridged.py`**: DaysSky (#363), used only in the secondary step. +- **Bit-side checkers and engines generalized here**: + - PR #266's official cohort checkers; + - LJH-217's #346 ports; + - PR #315's moment engines, outer assembly and finite bill (DreamingOfClouds); + - the source527 lineage (eumemic; PR #200 Chafik Boukhalfa's physical rules); + - PR234's five-stage architecture (hcg890 / Henry Grant, on Jacob Sussman's five-stage layout); + - Evan McKinney's completed banks. +- **The E8 bit word, its producer, the independent checker, and the generalizations and regressions**: Dylan Crow, with + Anthropic Claude assistance. + +See `NOTICE.md`, `NOTICE-PR352.md`, `NOTICE-PR363.md`, `PR-STATEMENT.md` and `HANDOFF.md`. diff --git a/research/e8-bit/VERIFY-LOG.txt b/research/e8-bit/VERIFY-LOG.txt new file mode 100644 index 0000000000..a978f061a5 --- /dev/null +++ b/research/e8-bit/VERIFY-LOG.txt @@ -0,0 +1,87 @@ +== 0. package manifest + all files match MANIFEST.sha256 +== 1. the word: regenerate from the producer parameters; export the PR249 records +R 865 gates D/A/B/C 120 1756 472 1756 frames 944 + regenerated word equals the shipped word +exported 18824 records, 944 frames, n 1105 ZERO 0 + exported records/states/frames match RECORD-SHA256SUMS +== 2. independent all-column checker (no shared code with the producer) and its negative controls +labels: 120 distinct lines of norm 2 (pairwise |ip| <= 1), spanning rank 8 +legality + exact F2 on all 1105 columns: PASS (gates D/A/B/C = 120/1756/472/1756) +nondegeneracy: 943 used frames, all Gram dets > 0 (positive-definite form); primes in dets: [2] +histogram {1: 10380, 2: 4710, 3: 2240, 4: 2330, 5: 1540, 6: 10, 7: 240, 8: 90, 14: 240, 18: 240} m 40 W 1345 mass 53680 deficit 120 (4v-5L = 120 ) maxchild 18 +no envelope saving in [0.00090407282109368831, 0.00090407282109368831] +bad envelope saving in [0.00090407282024252275, 0.00090407282024252275] +REJECTED drop a phase-B gate :: AssertionError: ('target', 65) +REJECTED phase-B gate at the full frame (y beyond its cap) :: AssertionError: ('frame not nested', 239, 1, 943) +REJECTED drop a dirt compensation read :: AssertionError: ('target', 0) +REJECTED drop a cleanup gate :: AssertionError: ('helper not restored', 936) +REJECTED wrong scatter row :: AssertionError: ('target', 5) +REJECTED phase-A gate frame not nested :: AssertionError: ('frame not nested', 512, 122, 2) +PASS all 6 word-level negative controls rejected +== 3. official PR #266 cohort checkers, generalized: h = 8 frames, NCOPY = 9 copied centres +PASS pairs 0 ADD 14603 mass 8672 COPY24 + five-stage formal columns PASS (PASS_NEW_COHORT249_ALL_FIVE_STAGE_FORMAL_COLUMNS_AND_PREFIX_BILL 1345 columns) + REJECTED drop a phase-B delivery ADD (columns: defining decoder) [local defining-decoder full formal column] + REJECTED ADD at a frame its registers do not stand at [ what(): ADD not in common frame] + REJECTED MOVE with a wrong rank [ what(): illegal or mispriced MOVE] + REJECTED COPY with a cheaper rank [ what(): COPY rank] + REJECTED drop a dirt-compensation ADD (columns) [local defining-decoder full formal column] + REJECTED unchanged word with the copy count pinned to h = 8 (NCOPY unset) [ what(): unclosed COPY] +PASS all 6 record-level negative controls rejected + regression: unmodified PR #346/#352 sources vs generalized sources (no -DNCOPY), h = 20, on the PR #325 p10b word + legality receipts byte-identical + five-stage columns receipts identical (except wall-clock seconds) +== 4. exact nondegeneracy (E8 Gram) and prime witnesses on every frame +PASS e8ham Gram: 944 frames checked, all nondegenerate and positive definite; prime witnesses valid; max determinant bits 17; primes [2]; by dim {0: 1, 1: 120, 2: 168, 3: 168, 4: 14, 5: 168, 6: 184, 7: 120, 8: 1} + regression (G = I - J/9, h = 20, PR #325 p10b word): the original prime_new.py and the generalized check +PASS prime witnesses for 12885 new frames; max determinant bits 97 ; primes [2, 3, 11] +PASS triple9 Gram: 12885 frames checked, all nondegenerate; prime witnesses valid; max determinant bits 97; primes [2, 3, 11]; by dim {0: 1, 1: 960, 2: 1440, 3: 1440, 5: 940, 6: 180, 7: 520, 8: 279, 10: 359, 12: 275, 13: 500, 14: 352, 15: 698, 16: 120, 17: 1440, 18: 1460, 19: 1920, 20: 1} + same frame count, determinant bits and primes: ('12885', '97', '[2, 3, 11]') +== 5. PR234 five-stage geometry for the E8 labels (W(E8) reflection words as port isometries) + port 1/120 checked (0 reflections) 0s + port 21/120 checked (1 reflections) 1s + port 41/120 checked (1 reflections) 2s + port 61/120 checked (2 reflections) 3s + port 81/120 checked (2 reflections) 4s + port 101/120 checked (2 reflections) 5s +PASS E8 five-stage geometry: all 120 ports (W(E8) reflection words as port isometries), routes involutive, stage boundaries chained, idle gap ranks [14, 14, 7, 7, 18, 18, 4, 4], D_I D_P identity; entrance census {0: 865 helpers}: five-window completion exact, duplicate window rejected +PASS regression: on paired-cube labels (h = 20, G = I - J/9) the generalized routes equal the original literal rho for 3 ports and every stage, and give idle ranks (38, 38, 19, 19, 42, 42, 4, 4) +== 6. banks: exact width-40 tiling of the helper residuals +residual census {8: 865} | freed roles (r = 0) are deleted, not banked +PASS exact width-40 tiling with 1 replicas: (((8, 8, 8, 8, 8), 173),) + regression: generalized tiling output byte-identical to PR #346's tile_check on the p10b word +== 7. copied centres: 9 retained totals at h = 8 (admitted; charged as NCOPY = 9 everywhere) + retained totals 9 > h = 8 ; COPY ranks [8] (full frame); copy loss L = 72, deficit 4v - 5L = 120 + 7b. CP-SAT: no F2 decoder with 8 centres; 9 suffice +k 8 status INFEASIBLE 0s +k 9 status OPTIMAL 5s +== 8. complex supplier: Jacob Sussman's E8 unit, PR #352's checks unchanged + Checking the complex program: gx.check1 with the exact scalar identity, and the gxcore mirror. + Checking every complex source label and paid child. + Deriving both complex scalar words and temporary lifetimes. + Merging scalar events, exact frames and all final climbs. + Recomputing complex cover, router, precision and row inequalities. +guard: PASS_FRESH_COMPLEX_LABEL_SCALAR_SPLICE_PRECISION | gx.check1: ACCEPTED (labels, bl | rows 11119 < 20161 +Lean binding: RESULT: REPRODUCED (25 repository files reproduced byte for byte, 0 different, 3 generated files not in the repository) (wht_main_block_B2Ge8x modules regenerated from this certificate) +stand-alone replay: REPLAY ACCEPTED: R=783 W=1263 D=120 cst=72 N=9039 figure=8762479 E8 family: True (0.6 s) +PASS complex coarse saving b = 876248285600677/1000000000000000000 0.000876248285600677 (two engines, 10^-16 fallback, adjacent grid point excluded) +== 9. bit coarse saving and outer assembly (47 constraints), PR #315 engines, h = 8, T = 1 +normalized W 1345 calls 22020 mass 53680 deficit 120 maxchild 18 +bit coarse c = 452036410121261/500000000000000000 0.000904072820242522 (two engines + 1e-16 fallback, adjacent grid excluded) +complex leaf cap itself rejected (leaf_saving_above_bit), as in PR #315 math_check +complex b = 876248285600677/1000000000000000000 0.000876248285600677 | binding: complex +KAPPA = 875481145306751/1000000000000000000 = 8.754811453068e-04 | 47 strict constraints positive, adjacent grid point rejected + regression: generalized vs original certify_bit on the PR #325 p10b word (h = 20, T = 12) + identical kappa receipt fields; p10b kappa 384842019691667/500000000000000000 +== 10. finite bill at m = 40 +finite-bill input: m 40, v 120, R 865, T 1, stock 1345, NCOPY 9, unit additions 14603, rows 742/6308, K 27347440 +PASS finite bill (E8, m = 40): coefficient 1916288151501 (41 bits) < 2^80, q-power bound q^1601, payload prefix 60 bits < 104, delta_tau 25054818195901, reference route {'swap': 7}; all 120 port routes exact elementary programs, at most 77 factors, denominators [1, 2, 4] (powers of two: units modulo every odd q) +PASS regression: on the p = 10 receipts in /regression/loans the generalized bill reproduces the coefficient 24463942022302301 , the moment gaps, the bootstrap chain and the 40-dimensional route program (sha cf655bf5356b...) +== 11. SECONDARY (conditional on PR #363): kappa under the seven-stage complex value; the bit word in B_3 +bit word in B_2 (5 stages, m 40, W 1345, idle [18, 14, 7, 4]): bit coarse c = 452036410121261/500000000000000000 = 9.040728202425e-04 +bit word in B_3 (7 stages, m 56, W 1585, idle [27, 7, 14, 7, 20, 27, 1, 7, 6]): bit coarse c = 968197503705007/1000000000000000000 = 9.681975037050e-04 +kappa [five-stage bit + #352 five-stage complex (PRIMARY)]: 875481145306751/1000000000000000000 = 8.754811453068e-04 (complex-bound) +kappa [five-stage bit + #363 seven-stage complex]: 112907026276423/125000000000000000 = 9.032562102114e-04 (bit-bound) +kappa [seven-stage bit (no construction yet) + #363 seven-stage complex]: 93191395651209/100000000000000000 = 9.319139565121e-04 (complex-bound) +PASS conditional kappa = 875481145306751/1000000000000000000 = 0.000875481145306751 (complex-bound; bit coarse 452036410121261/500000000000000000 = 0.000904072820242522 ) diff --git a/research/e8-bit/code/bit/checkers/certify_bit_g.py b/research/e8-bit/code/bit/checkers/certify_bit_g.py new file mode 100644 index 0000000000..d257992e31 --- /dev/null +++ b/research/e8-bit/code/bit/checkers/certify_bit_g.py @@ -0,0 +1,46 @@ +"""Generalized (Dylan Crow, with Anthropic Claude assistance): h, the normalization T and the output path are arguments; +h = 20, T = 12 is the original. usage: certify_bit_g.py WORDDIR B H T OUT.json +Exact bit coarse saving + outer assembly for a PR249-format local word, using PR #315's engines +(moment.py, base_two_moment.py, outer.py) and its math_check.run logic, with a given complex coarse b.""" +import sys, json, importlib.util, os +from fractions import Fraction as Q +from collections import Counter +sys.path.insert(0,os.path.dirname(os.path.abspath(__file__))) +import cost as C +P=os.environ.get('PR315',os.path.join(os.path.dirname(os.path.abspath(__file__)),'..','..','pricing'))+'/' +def load(n): + s=importlib.util.spec_from_file_location(n,P+n+'.py'); m=importlib.util.module_from_spec(s); s.loader.exec_module(m); return m +moment=load('moment'); other=load('base_two_moment'); outer=load('outer') +d=sys.argv[1]; b=Q(sys.argv[2]); HH=int(sys.argv[3]); T=int(sys.argv[4]); OUT=sys.argv[5] +s,fr,dim,rec=C.load_snapshot(d) +H,resid,v=C.local_profile(rec,s,dim,h=HH); prof,W,m,deficit=C.five_stage(H,resid,v,h=HH) +norm={int(k):int(c)*T for k,c in prof.items() if c}; Wn=Q(4*v*HH+resid,HH)*T; assert Wn.denominator==1; Wn=int(Wn); m=5*HH +mass=sum(k*c for k,c in norm.items()); print('normalized W',Wn,'calls',sum(norm.values()),'mass',mass,'deficit',m*Wn-mass,'maxchild',max(norm)) +root=moment.certify(dict(norm),m,Wn,True); c=Q(int(Q(root['lower'])*10**18),10**18) +bm=moment.moment(norm,m,Wn,c,True); nextbm=moment.moment(norm,m,Wn,c+Q(1,10**18),True); assert bm[1]<1cap-grid, 'complex-bound saving not tight against the cap' +chain=[Q(384599,10**10)] +for _ in range(3): + a=(1-sv)*sv+sv*chain[-1]; assert chain[-1]0 +try: + outer.assembly(bit,b,bridge,k+Q(1,10**18),eta=eta,beta=beta); raise SystemExit('ADJACENT ADMITTED') +except AssertionError: pass +if binding=='complex': + try: outer.assembly(cap,b,bridge,k,eta=eta,beta=beta) + except AssertionError as e: assert 'leaf_saving_above_bit' in str(e); print('complex leaf cap itself rejected (leaf_saving_above_bit), as in PR #315 math_check') + else: raise SystemExit('complex leaf cap admitted') +print('complex b =',b,float(b),'| binding:',binding) +print('KAPPA =',k,'=',format(float(k),'.12e'),'| 47 strict constraints positive, adjacent grid point rejected') +json.dump(dict(word=d,h=HH,T=T,maxchild=max(norm),bit_moment_interval=[str(x) for x in bm],normalized_histogram=norm,W=Wn,m=m,bit_coarse=str(c),complex_coarse=str(b),binding=binding,kappa=str(k),kappa_float=float(k)),open(OUT,'w'),indent=1) diff --git a/research/e8-bit/code/bit/checkers/columns_h.cpp b/research/e8-bit/code/bit/checkers/columns_h.cpp new file mode 100644 index 0000000000..00c5a3a5d8 --- /dev/null +++ b/research/e8-bit/code/bit/checkers/columns_h.cpp @@ -0,0 +1,48 @@ +// Generalization (Dylan Crow, with Anthropic Claude assistance): the copied-centre count is the macro NCOPY, defaulting to +// HDIM, so the unmodified PR #346/#352 build (no -DNCOPY) is exactly the original checker. The E8 bit word has 9 +// retained totals at h = 8 (-DNCOPY=9). +#ifndef NCOPY +#define NCOPY HDIM +#endif +#include "json.hpp" +#include +#include +using boost::multiprecision::cpp_int; +#include +#include +#include +#include +#include +#include +#include +using J=nlohmann::json; +struct E{int kind,dst,src,c;}; +void need(bool x,const char*s){if(!x)throw std::runtime_error(s);} +int main(int argc,char**argv){try{ +need(argc==3,"usage RAW6_RECORDS OUTPUT");std::string pre=argv[1];int v=VPORTS,r=RHELP,loc=2*v+r,global=4*v+r,temp=global; +struct Raw{int op,a,b,c,f,z;};std::ifstream f(pre,std::ios::binary|std::ios::ate);size_t sz=f.tellg();need(sz%sizeof(Raw)==0,"stream alignment");std::vectorp(sz/sizeof(Raw));f.seekg(0);f.read((char*)p.data(),sz);std::vectore;std::mapH;for(auto q:p){if(q.op==0){if(q.f)H[q.f]++;}else if(q.op==1)e.push_back({0,q.a,q.b,q.c});else if(q.op==2){H[q.z]++;e.push_back({1,loc,q.a,0});}else if(q.op==3)e.push_back({2,loc,q.a,0});else need(false,"opcode");} +J prefix=J::array();cpp_int largestF=0,largestB=0;for(int rev=0;rev<2;rev++){std::vectornorms(loc+1,1);cpp_int maxrow=1;bool isopen=false;for(size_t z=0;zmaxrow)maxrow=norms[q.dst];}else if(k==1){need(!isopen,"boundcopy");norms[loc]=norms[q.src];isopen=true;}else {need(isopen,"bounderase");norms[loc]=0;isopen=false;}}need(!isopen,"prefix copy closure");if(rev)largestB=maxrow;else largestF=maxrow;prefix.push_back({{"reverse",bool(rev)},{"cancellation_free_signed_row_l1_upper",maxrow.convert_to()},{"bits",boost::multiprecision::msb(maxrow)+1}});} +cpp_int payload=64*largestF*largestF*largestF*largestB*largestB;need(payload<(cpp_int(1)<<104),"payloadfiniteprefix2^104"); +long long copies=0,adds=0,odd=0;bool open=false;int center=-1;long long reverseCopies=0; +for(auto q:e){need(q.kind>=0&&q.kind<=2,"kind");need(q.dst>=0&&q.dst<=loc,"local dst");if(q.kind==0){need(q.src>=0&&q.src<=loc&&q.dst!=q.src,"source distinct");need(q.dst!=loc,"copy immutable");need(q.src!=loc||open,"temp not open");if(open)need(q.dst!=center,"source changes inside copied-center block");adds++;odd+=q.c&1;} +else if(q.kind==1){need(!open&&q.dst==loc&&q.src>=0&&q.srca((size_t)(global+1)*words);auto row=[&](int i){return a.data()+(size_t)i*words;};for(int i=0;i=v&&i<2*v&&w==(size_t)(i-v)/64)want^=1ull<<((i-v)%64);need(x[w]==want,"local defining-decoder full formal column");}}} +if(stage==1||stage==2||stage==4){int b=stage==1?0:stage==2?1:2;for(auto q:bridges[b])for(int i=0;i(std::chrono::steady_clock::now()-t0).count()<<"s\n";} +for(int bank=0;bank<4;bank+=2)for(int i=0;i()},{"payload_prefix_bits",boost::multiprecision::msb(payload)+1},{"new_Q_categories",{28,29}},{"local_raw_H",H},{"negative_controls",controls},{"seconds",std::chrono::duration(std::chrono::steady_clock::now()-t0).count()}};std::ofstream(argv[2])< 0: H[int(r[4])] += 1 + copies = rec[rec[:, 0] == 2] + for r in copies: + if r[5] > 0: H[int(r[5])] += 1 + init = s['initial'] + resid = sum(h - dim[init[str(r)]] for r in range(2 * v, n)) + return H, resid, v + +def five_stage(H, resid, v, h=24, stages=5): + m = stages * h + prof = collections.Counter() + for j, c in H.items(): prof[j] += stages * c + for j in (2*h - 2, h - 1, 2*h + 2, 4): prof[j] += 2 * v + W = mpf(4 * v) + mpf(resid) / h + mass = sum(j * c for j, c in prof.items()) + return prof, W, m, W * m - mass + +def solve_moment(prof, W, m, bad=mpf('1e-16')): + calls = sum(prof.values()) + items = [(mpf(j) / m, c) for j, c in prof.items()] + def mu(sv): + t = 1 - sv + return (sum(c * x ** t for x, c in items) + bad * 32 * m * m * calls * (mpf(1) / m) ** t) / W - 1 + return findroot(mu, mpf('0.0007')) + +def evaluate(rec, s, dim, h=24): + H, resid, v = local_profile(rec, s, dim, h) + prof, W, m, deficit = five_stage(H, resid, v, h) + sv = solve_moment(prof, W, m) + return dict(saving=sv, kappa_approx=sv / (1 + sv), W=W, deficit=deficit, m=m, + calls=sum(prof.values()), local=dict(sorted(H.items())), resid=resid) + +if __name__ == '__main__': + import sys + s, fr, dim, rec = load_snapshot(sys.argv[1]) + r = evaluate(rec, s, dim) + print({k: (float(v) if hasattr(v, 'real') and not isinstance(v, dict) else v) for k, v in r.items() if k != 'local'}) diff --git a/research/e8-bit/code/bit/checkers/exactnd_h.py b/research/e8-bit/code/bit/checkers/exactnd_h.py new file mode 100644 index 0000000000..fa90b5089f --- /dev/null +++ b/research/e8-bit/code/bit/checkers/exactnd_h.py @@ -0,0 +1,44 @@ +import json, sys, collections +def bareiss_det(M): + M=[row[:] for row in M]; n=len(M); sign=1; prev=1 + for k in range(n-1): + if M[k][k]==0: + sw=next((i for i in range(k+1,n) if M[i][k]!=0),None) + if sw is None: return 0 + M[k],M[sw]=M[sw],M[k]; sign=-sign + for i in range(k+1,n): + for j in range(k+1,n): + M[i][j]=(M[i][j]*M[k][k]-M[i][k]*M[k][j])//prev + prev=M[k][k] + return sign*M[n-1][n-1] +def rank_int(B): + # exact rank via fraction-free elimination + M=[r[:] for r in B]; r=0; cols=len(M[0]) if M else 0 + for c in range(cols): + p=next((i for i in range(r,len(M)) if M[i][c]!=0),None) + if p is None: continue + M[r],M[p]=M[p],M[r] + for i in range(len(M)): + if i!=r and M[i][c]!=0: + a,b=M[r][c],M[i][c]; M[i]=[x*a-y*b for x,y in zip(M[i],M[r])] + r+=1 + return r +HH=20 +new_dir=sys.argv[1]; base_dir=sys.argv[2] +fr=json.load(open(new_dir+'/frames.json'))['frames']; old=json.load(open(base_dir+'/frames.json'))['frames'] +new=[k for k in fr if k not in old or fr[k]['B']!=old[k]['B']] +bad=0; stats=collections.Counter() +for k in new: + B=fr[k]['B']; A=fr[k].get('A',[]) + d=len(B) + if d==0: continue + assert rank_int(B)==d, ('basis rank',k) + if A: + assert all(sum(a*b for a,b in zip(ra,rb))==0 for ra in A for rb in B), ('A.B',k) + assert len(A)+d==HH, ('A dim',k) + s=[sum(r) for r in B] + M=[[9*sum(B[i][t]*B[j][t] for t in range(HH))-s[i]*s[j] for j in range(d)] for i in range(d)] + det=bareiss_det(M) + stats[(d, det!=0)]+=1 + if det==0: bad+=1 +print('changed/new frames:',len(new),' exactly degenerate:',bad,' by (dim,nonzero det):',dict(stats)) diff --git a/research/e8-bit/code/bit/checkers/finite_g.py b/research/e8-bit/code/bit/checkers/finite_g.py new file mode 100644 index 0000000000..d1aa38980a --- /dev/null +++ b/research/e8-bit/code/bit/checkers/finite_g.py @@ -0,0 +1,146 @@ +"""Finite bill for the banked five-stage bit word, generalized from the source527/p10 finite_check.run (Dylan Crow, with +Anthropic Claude assistance). The arithmetic is the original line by line; the changes are explicit parameters: + * h, m = 5h, v, R, replicas T, literal stock, literal paid histogram, weighted/unit additions and the forward and + inverse cancellation-free row bounds are inputs (from this package's receipts); + * NCOPY, the copied-centre temporaries per invocation and 5*NCOPY copy/erase episodes per replica (the original + writes h for both, since the paired cube has h centres; the E8 word has 9 retained totals at h = 8); + * the 2h-dimensional rational route template: [[p*, k*], [k*, p*]] for the reference port line q* of the label + family under its form (original: a triple line under G = I - J/9, denominators 1,2,3,6; E8: a root line under + /2), recomputed and factored into elementary operations, exact inverse replay, omitted factor rejected; + * K, the conservative extra bank-selector calls, by the original formula 2*5*T*((live-1) + R*m*factors) with + factors = maxops + (m-1) + m (maxops of the actual charts; an ungauged word has only the identity chart, 0 ops). +usage: python3 finite_g.py e8 RECEIPTS.json | python3 finite_g.py regression P10_RECEIPT_DIR""" +from fractions import Fraction as Q +from collections import Counter +from hashlib import sha256 +import json, sys, os, importlib.util, gzip +HERE=os.path.dirname(os.path.abspath(__file__)) +def ceilq(x): return -((-x.numerator)//x.denominator) +def cutoff_log2(delta,C): + assert 0=1 + return max(1,ceilq(36/delta**2),ceilq(2*(4+(C-1).bit_length())/delta)) +def mm(A,B): return [[sum(A[i][k]*B[k][j] for k in range(len(B))) for j in range(len(B[0]))] for i in range(len(A))] +def route_template(h,q,form,g=None,ginv=None): + """[[g p* g^-1, g k*], [k* g^-1, p*]] with p* = q q^T G/; G given by form(x,y) on coordinate vectors + (bilinear); g = I (the original's reference port) unless a port isometry is given.""" + I=lambda n:[[Q(i==j)for j in range(n)]for i in range(n)] + Gq=[sum(form(i,j)*q[j] for j in range(h)) for i in range(h)]; nq=sum(q[i]*Gq[i] for i in range(h)) + P=[[Q(q[i])*Gq[j]/nq for j in range(h)]for i in range(h)] + K=[[Q(i==j)-P[i][j]for j in range(h)]for i in range(h)] + if g is None: TL,TR,BL=P,K,K + else: TL,TR,BL=mm(mm(g,P),ginv),mm(g,K),mm(K,ginv) + rho=[TL[i]+TR[i]for i in range(h)]+[BL[i]+P[i]for i in range(h)] + a=[r[:]for r in rho];factors=[] + for j in range(2*h): + p=next(i for i in range(j,2*h)if a[i][j]) + if p!=j:a[j],a[p]=a[p],a[j];factors.append(('swap',j,p,None)) + if a[j][j]!=1: + c=1/a[j][j];a[j]=[c*x for x in a[j]];factors.append(('scale',j,None,c)) + for i in range(2*h): + if i!=j and a[i][j]: + c=-a[i][j];a[i]=[x+c*y for x,y in zip(a[i],a[j])];factors.append(('add',i,j,c)) + assert a==I(2*h) + def replay(omit=None): + a=I(2*h) + for z in reversed(range(len(factors))): + if z==omit:continue + kind,i,j,c=factors[z] + if kind=='swap':a[i],a[j]=a[j],a[i] + elif kind=='scale':a[i]=[x/c for x in a[i]] + else:a[i]=[x-c*y for x,y in zip(a[i],a[j])] + return a + assert replay()==rho + omit=next((i for i,f in enumerate(factors)if f[0]=='add'),0) # original: the first addition; a route without additions: the first factor + assert factors and replay(omit)!=rho + counts=dict(Counter(f[0]for f in factors));denoms=sorted({c.denominator for kind,i,j,c in factors if c is not None}) + serialization=[[kind,i,j,None if c is None else str(c)]for kind,i,j,c in factors] + return dict(factors=len(factors),factor_counts=counts,denominators=denoms, + factor_program_sha256=sha256(json.dumps(serialization,separators=(',',':')).encode()).hexdigest(), + exact_inverse_reconstruction=True,missing_addition_rejected=True) +def bill(x): + """x: dict with h,m,v,R,T,stock,literal(hist),ncopy,weighted,unit,fwd_row,inv_row,K,coarse,moment_module,route.""" + h,m,v,R,T,stock,ncopy=x['h'],x['m'],x['v'],x['R'],x['T'],x['stock'],x['ncopy'] + literal=Counter(x['literal']);E=sum(literal.values());mass=sum(r*c for r,c in literal.items()) + assert m==5*h and Q(max(literal),m)0 and delta1>0 + chain=[Q(384599,10**10)];gaps=[] + for j in range(3): + old=chain[-1];a=(1-c)*c+c*old;ds=dict(atom=c-a,borrowing=1-a-c,remainder=1-a-c*(1-old),stock=1-c);assert old0 + delta=min(ds.values());L=cutoff_log2(delta,coefficient);assert Q(L)*delta**2>=36 and Q(L)*delta>=2*(4+(coefficient-1).bit_length()) + gaps.append(dict(stage=j+1,minimum_gap=str(delta),cutoff_log2_at_charged_coefficient=str(L)));chain.append(a) + controls=[] + for name,test in [('zero cutoff gap',lambda:cutoff_log2(Q(0),coefficient)),('negative constant',lambda:cutoff_log2(Q(1,2),0))]: + try:test() + except AssertionError:controls.append(name) + else:raise AssertionError('bad finite cutoff accepted') + return dict(coefficient=coefficient,coefficient_bits=coefficient.bit_length(),low_matrix_power=d,strict_upper='q^'+str(d+1), + positive_rank_children=E,rank_mass=mass,weighted_additions=weighted,unit_expanded_additions=unit,route_families=J, + copy_erase_episodes=5*ncopy*T,payload_prefix_upper=payload,payload_prefix_bits=payload.bit_length(), + delta_tau_lower=str(delta_tau),delta_linear=str(delta1),bootstrap_chain=list(map(str,chain)),gaps=gaps, + row_reserve=dict(internal_coefficient=d+1,external_complex_coefficient=20161),route=x['route'],rejected_controls=controls) +def load_moment(): + s=importlib.util.spec_from_file_location('m',os.path.join(HERE,'..','..','pricing','moment.py'));m=importlib.util.module_from_spec(s);s.loader.exec_module(m);return m +def hist(x): return Counter({int(k):v for k,v in x.items() if v}) +if __name__=='__main__': + mod=load_moment() + if sys.argv[1]=='regression': + d=sys.argv[2]; raw=json.load(open(d+'/raw.json')); sc=json.load(open(d+'/scalar.json')); bk=json.load(open(d+'/banks.json'))['banks'] + ma=json.load(open(d+'/math.json'))['mathematics']; fin=json.load(open(d+'/finite.json')); gl=json.load(open(d+'/global_result.json')) + h=raw['h'];m=5*h;H=hist(raw['five_stage_profile']['histogram']) + for a,cnt in hist(raw.get('completion_rank_histogram',raw['auxiliary_entrance_rank_histogram'])).items(): + H[5*a]-=cnt + if not H[5*a]: del H[5*a] + T=bk['physical_replicas']; literal=Counter({r:T*c for r,c in H.items()}) + q=[int(i<3) for i in range(h)]; form=lambda i,j: Q(int(i==j))-Q(1,9) + x=dict(h=h,m=m,v=raw['v'],R=raw['physical_R'],T=T,stock=bk['literal_stock'],literal=literal,ncopy=h,deficit=4*raw['v']-5*h*(h-2), + weighted=sc['forward']['weighted_additions'],unit=sc['forward']['literal_unit_additions'],fwd_row=sc['forward']['max_intermediate_row_l1'], + inv_row=sc['inverse']['max_intermediate_row_l1'],K=bk['conservative_extra_selector_calls'],coarse=ma['bit_coarse'],moment_module=mod, + route=route_template(h,q,form)) + r=bill(x) + assert r['coefficient']==fin['q_power_bound']['coefficient'],(r['coefficient'],fin['q_power_bound']) + assert r['bootstrap_chain']==fin['bootstrap']['chain'] and r['delta_tau_lower']==fin['moment']['delta_tau_lower'] and r['delta_linear']==fin['moment']['delta_linear'] + assert r['route']['factor_counts']==fin['rational_route']['factor_counts'] and r['route']['factor_program_sha256']==fin['rational_route']['factor_program_sha256'] + assert r['route']['denominators']==[1,2,3,6] + print('PASS regression: on the p = 10 receipts in',d,'the generalized bill reproduces the coefficient',r['coefficient'], + ', the moment gaps, the bootstrap chain and the 40-dimensional route program (sha',r['route']['factor_program_sha256'][:12]+'...)') + else: + x=json.load(open(sys.argv[2])) + q=x['qstar']; form=lambda i,j: Q(int(i==j),2) # E8 form /2 in Construction-A coordinates + x['route']=route_template(x['h'],q,form); x['moment_module']=mod; x['literal']=hist(x['literal']) + # every port: route conjugated by its W(E8) reflection word (the original's coordinate permutations are free + # relabelings; here the isometry is a rational program and is charged as part of the port route) + w=json.load(gzip.open(x['word'],'rt')); Lw=w['lines']; h=x['h'] + ip=lambda a,b: Q(sum(u*t for u,t in zip(a,b)),2) + def refl(r): + return [[Q(int(i==j))-Q(r[i]*r[j],2)*2/ip(r,r) for j in range(h)] for i in range(h)] + isom={0:[[Q(int(i==j)) for j in range(h)] for i in range(h)]}; fr=[0] + while fr: + nx=[] + for a_ in fr: + for b_ in range(len(Lw)): + if b_ in isom or abs(ip(Lw[a_],Lw[b_]))!=1: continue + d_=[u-t for u,t in zip(Lw[a_],Lw[b_])] if ip(Lw[a_],Lw[b_])==1 else [u+t for u,t in zip(Lw[a_],Lw[b_])] + isom[b_]=mm(refl(d_),isom[a_]); nx.append(b_) + fr=nx + assert len(isom)==len(Lw) and Lw[0]==q + ports=[]; allden=set(); maxf=0 + for t,g in isom.items(): + ginv=[[g[j][i]*1 for j in range(h)] for i in range(h)] # G = I/2 is scalar, so g^-1 = g^T + assert mm(g,ginv)==[[Q(int(i==j)) for j in range(h)] for i in range(h)] + gq=[sum(g[i][j]*q[j] for j in range(h)) for i in range(h)]; assert gq==Lw[t] or gq==[-u for u in Lw[t]] + r_=route_template(h,q,form,g,ginv); allden|=set(r_['denominators']); maxf=max(maxf,r_['factors']) + assert all(d_&(d_-1)==0 for d_ in allden), allden # powers of two: units modulo every odd prime q + x['route']['all_ports']=dict(ports=len(isom),max_factors=maxf,denominators=sorted(allden)) + r=bill(x); r.pop('route') if False else None + json.dump({k:(v if not isinstance(v,Counter) else dict(v)) for k,v in r.items()},open(sys.argv[3],'w'),indent=1,default=str) + print('PASS finite bill (E8, m = %d): coefficient %d (%d bits) < 2^80, q-power bound %s, payload prefix %d bits < 104, delta_tau %s, reference route %s; all %d port routes exact elementary programs, at most %d factors, denominators %s (powers of two: units modulo every odd q)'%( + x['m'],r['coefficient'],r['coefficient_bits'],r['strict_upper'],r['payload_prefix_bits'],r['delta_tau_lower'][:14],r['route']['factor_counts'],r['route']['all_ports']['ports'],r['route']['all_ports']['max_factors'],r['route']['all_ports']['denominators'])) diff --git a/research/e8-bit/code/bit/checkers/geometry_g.py b/research/e8-bit/code/bit/checkers/geometry_g.py new file mode 100644 index 0000000000..74eb582247 --- /dev/null +++ b/research/e8-bit/code/bit/checkers/geometry_g.py @@ -0,0 +1,137 @@ +"""PR234's five-stage route and idle geometry with the label family as a parameter (Dylan Crow, with Anthropic Claude assistance; +generalizes the exact matrix checks of code/geometry527.py + global_lowering.Lowerer of the source527/p10 packages). + +The original fixes H = Q^h with G = I - J/9, a reference triple line q*, and port isometries given by coordinate +permutations pi (pi^-1 = pi^T). Here G, q* and the port isometries g_t (exact rational matrices with +g^T G g = G and g q* = +-q_t) are inputs; every formula is the original one with pi -> g and pi^T -> g^-1: + frame projector P_B = B^T (B G B^T)^-1 B G p* = q* q*^T G / , k* = I - p* + route rho(i,t) [[g p* g^-1, g k*], [k* g^-1, p*]] on blocks (0, i) of H^5, identity elsewhere; rho(0,t) = I + tau(i) exchange of blocks 0 and i; stage projector P (+) K (+) ... (+) K (K = k* on blocks 1..i) + data(i,kind) rho(i,t) * stage_projector(i, frame(kind)) * rho(i,t), kinds P (port line), K (its complement), H, 0 +Checks for every port t: rho^2 = I; P_t idempotent of trace 1; data(i-1,H) = data(i,P) and data(i-1,K) = data(i,0) +(i = 1..4); the eight idle boundary pairs (a, b) commute with a*b = a and gap b - a idempotent of trace +(2h-2, 2h-2, h-1, h-1, 2h+2, 2h+2, 4, 4); p (I - p) = 0. For the entrance census of the word (here: every helper +starts at frame 0, the single entrance class sigma = 0), the five-window completion: the tau-conjugates of +(I_h - P_sigma) (+) 0 are pairwise orthogonal and sum to I - completion(sigma); a duplicated window is rejected. +usage: python3 geometry_g.py e8 WORD.json[.gz] (E8 labels, all ports) + python3 geometry_g.py regression (paired-cube h = 20: equals the original literal formulas)""" +import sys, json, gzip, itertools, time +import sympy as sp +def eye(n): return sp.eye(n) +class Geo: + def __init__(self,h,G,qstar): + self.h=h; self.M=5*h; self.G=G; self.q=qstar + nq=(qstar.T*G*qstar)[0]; assert nq!=0 + self.pstar=qstar*(qstar.T*G)/nq; self.kstar=eye(h)-self.pstar + def frame_projector(self,B): + if B.rows==0: return sp.zeros(self.h) + return B.T*(B*self.G*B.T).inv()*B*self.G + def rho(self,stage,g,ginv): + h,M=self.h,self.M; I=eye(M) + if stage==0: return I + I[:h,:h]=g*self.pstar*ginv; I[stage*h:(stage+1)*h,stage*h:(stage+1)*h]=self.pstar + I[:h,stage*h:(stage+1)*h]=g*self.kstar; I[stage*h:(stage+1)*h,:h]=self.kstar*ginv + return I + def tau(self,stage): + I=eye(self.M) + if stage: + for j in range(self.h): I.row_swap(j,stage*self.h+j) + return I + def stage_projector(self,stage,P): + A=sp.zeros(self.M); A[:self.h,:self.h]=P + for j in range(1,stage+1): A[j*self.h:(j+1)*self.h,j*self.h:(j+1)*self.h]=self.kstar + return A + def check_port(self,qt,g,ginv): + h,M=self.h,self.M; I=eye(M); Z=sp.zeros(M) + assert g*ginv==eye(h) and g.T*self.G*g==self.G, 'port map is not a G-isometry' + assert g*self.q==qt or g*self.q==-qt, 'port map does not send q* to the port line' + routes=[self.rho(i,g,ginv) for i in range(5)] + assert all(r*r==I for r in routes) + P=self.frame_projector(qt.T); assert P*P==P and P.trace()==1 + Ph={'P':P,'K':eye(h)-P,'H':eye(h),'0':sp.zeros(h)} + cache={} + def data(i,kind): + if (i,kind) not in cache: cache[i,kind]=routes[i]*self.stage_projector(i,Ph[kind])*routes[i] + return cache[i,kind] + for i in range(1,5): + assert data(i-1,'H')==data(i,'P'); assert data(i-1,'K')==data(i,'0') + p=data(0,'P') + pairs=[(p,data(1,'H')),(Z,data(1,'K')),(data(2,'P'),data(3,'P')),(data(2,'0'),data(3,'0')), + (data(2,'H'),I),(data(2,'K'),I-p),(data(4,'H'),I),(data(4,'K'),I-p)] + ranks=[] + for a,b in pairs: + assert a*b==b*a==a; gap=b-a; assert gap*gap==gap; ranks.append(int(gap.trace())) + assert p*(I-p)==Z and p+(I-p)==I + return ranks,routes,data + def check_entrance(self,Psigma): + h,M=self.h,self.M; Z=sp.zeros(M) + completion=sp.diag(*([Psigma]*5)); residual=eye(M)-completion + assert completion*completion==completion and completion.trace()==5*Psigma.trace() + actual=[] + for i in range(5): + t=self.tau(i); local=sp.zeros(M); local[:h,:h]=eye(h)-Psigma; actual.append(t*local*t) + assert sum(actual,Z)==residual + assert all(a*b==Z for i,a in enumerate(actual) for j,b in enumerate(actual) if i!=j) + assert sum(actual[:4]+[actual[3]],Z)!=residual + return True +def e8(word): + c=json.load(gzip.open(word,'rt') if word.endswith('.gz') else open(word)) + assert c['form']=='/2' and c['h']==8 + h=8; G=eye(h)/2; L=[sp.Matrix(x) for x in c['lines']]; v=len(L) + ip=lambda a,b:(a.T*G*b)[0] + def refl(r): return eye(h)-r*(r.T*G)*2/ip(r,r) # s_r(x) = x - 2/ r, a G-isometry and an involution + star=0; geo=Geo(h,G,L[star]) + # port isometries: products of root reflections (BFS over lines), g q* = +-q_t + isom={star:(eye(h),[])}; frontier=[star] + while frontier: + nxt=[] + for a in frontier: + for r in range(v): + if r in (a,) : continue + if abs(ip(L[a],L[r]))==1: + d=L[a]-L[r] if ip(L[a],L[r])==1 else L[a]+L[r] # a root with s_d(q_a) = +-q_r + S=refl(d); b=r + if b not in isom: + g=S*isom[a][0]; isom[b]=(g,isom[a][1]+[d]); nxt.append(b) + frontier=nxt + assert len(isom)==v + idle=None; t0=time.time() + for t in range(v): + g,word_=isom[t]; ginv=g.inv() + ranks,_,_=geo.check_port(L[t],g,ginv) + if idle is None: idle=ranks + assert ranks==idle==[2*h-2,2*h-2,h-1,h-1,2*h+2,2*h+2,4,4],ranks + if t%20==0: print(' port %d/%d checked (%d reflections) %.0fs'%(t+1,v,len(word_),time.time()-t0),flush=True) + # entrance census of the word: every helper starts at the zero frame + nreg=2*v+c['R']; starts={c['start'][r] for r in range(2*v,nreg)}; assert starts=={c['start'][v]} and len(c['frames'][c['start'][v]])==0 + geo.check_entrance(sp.zeros(h)) + print('PASS E8 five-stage geometry: all %d ports (W(E8) reflection words as port isometries), routes involutive, stage boundaries chained,' + ' idle gap ranks %s, D_I D_P identity; entrance census {0: %d helpers}: five-window completion exact, duplicate window rejected'%(v,idle,c['R'])) +def regression(): + """paired-cube h = 20: the generalized formulas with g = pi equal the original literal ones (global_lowering.Lowerer).""" + h=20; G=eye(h)-sp.ones(h)/9; qstar=sp.Matrix([int(i<3) for i in range(h)]); geo=Geo(h,G,qstar) + def original_rho(stage,q): + I=sp.eye(5*h) + if stage==0: return I + rest=[j for j in range(h) if j not in q]; permutation=list(q)+rest + pi=sp.zeros(h) + for j,dst in enumerate(permutation): pi[dst,j]=1 + pstar=qstar*(qstar.T*G)/2; p=pi*pstar*pi.T; kstar=sp.eye(h)-pstar + I[:h,:h]=p; I[stage*h:(stage+1)*h,stage*h:(stage+1)*h]=pstar + I[:h,stage*h:(stage+1)*h]=pi*kstar; I[stage*h:(stage+1)*h,:h]=kstar*pi.T + return I,pi + for q in [(0,2,4),(1,7,13),(5,11,19)]: + ranks_ok=None + for i in range(5): + Io,pi=original_rho(i,q) if i else (sp.eye(5*h),None) + if i==0: continue + assert geo.rho(i,pi,pi.T)==Io + _,pi=original_rho(1,q) + qt=sp.Matrix([int(j in q) for j in range(h)]) + ranks,_,_=geo.check_port(qt,pi,pi.T) + assert ranks==[2*h-2,2*h-2,h-1,h-1,2*h+2,2*h+2,4,4] + print('PASS regression: on paired-cube labels (h = 20, G = I - J/9) the generalized routes equal the original literal' + ' rho for 3 ports and every stage, and give idle ranks (38, 38, 19, 19, 42, 42, 4, 4)') +if __name__=='__main__': + if sys.argv[1]=='e8': e8(sys.argv[2]) + else: regression() diff --git a/research/e8-bit/code/bit/checkers/gram_frames.py b/research/e8-bit/code/bit/checkers/gram_frames.py new file mode 100644 index 0000000000..b740d47295 --- /dev/null +++ b/research/e8-bit/code/bit/checkers/gram_frames.py @@ -0,0 +1,54 @@ +"""Exact nondegeneracy and PR #315's prime-witness rule for every frame of a PR249-format word, with the ambient Gram +matrix as a parameter. Generalizes PR #346's exactnd_h.py and prime_new.py (Dylan Crow, with Anthropic Claude assistance). + --gram triple9 : the paired-cube form G = I - J/9, integer Gram 9 B G B^t = 9 B B^t - s s^t (exactnd_h/prime_new, verbatim) + --gram e8ham : the E8 form /2 in Construction-A (Hamming) coordinates, integer Gram 2 B G B^t = B B^t +Checks per frame: rank(B) = dim, A.B = 0 and |A| + dim = h (when A given), det(integer Gram) != 0 (exact Bareiss), and +the prime witness: |det| = residual * prod p^e over PR #315's allowed primes with 0 < residual < 2^80. With --new BASE +only frames absent from BASE are checked (prime_new.py's scope); otherwise every frame. +usage: python3 gram_frames.py WORDDIR --gram {triple9,e8ham} --h H [--new BASEDIR] [--positive]""" +import json, sys, argparse, importlib.util, os, collections +ap=argparse.ArgumentParser(); ap.add_argument('word'); ap.add_argument('--gram',required=True); ap.add_argument('--h',type=int,required=True) +ap.add_argument('--new'); ap.add_argument('--positive',action='store_true'); a=ap.parse_args() +HERE=os.path.dirname(os.path.abspath(__file__)) +s=importlib.util.spec_from_file_location('pw',os.path.join(HERE,'..','..','pricing','prime_witnesses.py')); pw=importlib.util.module_from_spec(s); s.loader.exec_module(pw) +def validate_record(row, dimension, determinant, allowed_primes): # PR #315 prime_check.validate_record, verbatim logic + assert type(row['dimension']) is int and type(row['determinant']) is int and type(row['residual']) is int, 'exact integer witness fields' + assert row['dimension'] == dimension and row['determinant'] == determinant != 0, 'exact determinant mismatch or singular basis' + assert 0 < row['residual'] < 2**80, 'retained prime lower bound' + product = row['residual'] + for prime, exponent in row['factors'].items(): + q = int(prime); assert q in allowed_primes and type(exponent) is int and exponent > 0, 'factor shape'; product *= q**exponent + assert product == abs(determinant), 'factor identity' +def gram(B): + if a.gram=='triple9': + s_=list(map(sum,B)); return [[9*sum(x*y for x,y in zip(B[i],B[j]))-s_[i]*s_[j] for j in range(len(B))] for i in range(len(B))] + if a.gram=='e8ham': + return [[sum(x*y for x,y in zip(B[i],B[j])) for j in range(len(B))] for i in range(len(B))] + raise SystemExit('unknown gram') +def rank_int(B): + M=[r[:] for r in B]; r=0 + for c in range(len(M[0]) if M else 0): + p=next((i for i in range(r,len(M)) if M[i][c]!=0),None) + if p is None: continue + M[r],M[p]=M[p],M[r] + for i in range(len(M)): + if i!=r and M[i][c]!=0: x,y=M[r][c],M[i][c]; M[i]=[u*x-w*y for u,w in zip(M[i],M[r])] + r+=1 + return r +fr=json.load(open(a.word+'/frames.json'))['frames'] +old=json.load(open(a.new+'/frames.json'))['frames'] if a.new else {} +keys=[k for k in fr if k not in old] +stats=collections.Counter(); primes=set(); bits=0; nonpos=0 +for k in keys: + B=fr[k]['B']; A=fr[k].get('A',[]); d=len(B); assert fr[k]['dim']==d + assert d==0 or rank_int(B)==d,('basis rank',k) + if A: assert all(sum(x*y for x,y in zip(r,b))==0 for r in A for b in B) and len(A)+d==a.h,('annihilator',k) + M=gram(B) if d else []; det=pw.det(M); assert det!=0,('degenerate frame',k) + if a.positive: # positive-definite ambient form: every leading principal minor positive + for j in range(1,d+1): + if pw.det([r[:j] for r in M[:j]])<=0: nonpos+=1; break + powers,residual=pw.factor_witness(det); row=dict(dimension=d,determinant=det,residual=residual,factors={p:e for p,e in powers.items() if e}) + validate_record(row,d,det,pw.PRIMES); primes.update(map(int,row['factors'])); bits=max(bits,abs(det).bit_length()); stats[d]+=1 +assert nonpos==0 +print('PASS %s Gram: %d frames checked, all nondegenerate%s; prime witnesses valid; max determinant bits %d; primes %s; by dim %s'%( + a.gram,sum(stats.values()),' and positive definite' if a.positive else '',bits,sorted(primes),dict(sorted(stats.items())))) diff --git a/research/e8-bit/code/bit/checkers/json.hpp b/research/e8-bit/code/bit/checkers/json.hpp new file mode 100644 index 0000000000..82d69f7c5d --- /dev/null +++ b/research/e8-bit/code/bit/checkers/json.hpp @@ -0,0 +1,25526 @@ +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + +/****************************************************************************\ + * Note on documentation: The source files contain links to the online * + * documentation of the public API at https://json.nlohmann.me. This URL * + * contains the most recent documentation and should also be applicable to * + * previous versions; documentation for deprecated functions is not * + * removed, but marked deprecated. See "Generate documentation" section in * + * file docs/README.md. * +\****************************************************************************/ + +#ifndef INCLUDE_NLOHMANN_JSON_HPP_ +#define INCLUDE_NLOHMANN_JSON_HPP_ + +#include // all_of, find, for_each +#include // nullptr_t, ptrdiff_t, size_t +#include // hash, less +#include // initializer_list +#ifndef JSON_NO_IO + #include // istream, ostream +#endif // JSON_NO_IO +#include // random_access_iterator_tag +#include // unique_ptr +#include // string, stoi, to_string +#include // declval, forward, move, pair, swap +#include // vector + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +// This file contains all macro definitions affecting or depending on the ABI + +#ifndef JSON_SKIP_LIBRARY_VERSION_CHECK + #if defined(NLOHMANN_JSON_VERSION_MAJOR) && defined(NLOHMANN_JSON_VERSION_MINOR) && defined(NLOHMANN_JSON_VERSION_PATCH) + #if NLOHMANN_JSON_VERSION_MAJOR != 3 || NLOHMANN_JSON_VERSION_MINOR != 12 || NLOHMANN_JSON_VERSION_PATCH != 0 + #warning "Already included a different version of the library!" + #endif + #endif +#endif + +#define NLOHMANN_JSON_VERSION_MAJOR 3 // NOLINT(modernize-macro-to-enum) +#define NLOHMANN_JSON_VERSION_MINOR 12 // NOLINT(modernize-macro-to-enum) +#define NLOHMANN_JSON_VERSION_PATCH 0 // NOLINT(modernize-macro-to-enum) + +#ifndef JSON_DIAGNOSTICS + #define JSON_DIAGNOSTICS 0 +#endif + +#ifndef JSON_DIAGNOSTIC_POSITIONS + #define JSON_DIAGNOSTIC_POSITIONS 0 +#endif + +#ifndef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON + #define JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON 0 +#endif + +#if JSON_DIAGNOSTICS + #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS _diag +#else + #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS +#endif + +#if JSON_DIAGNOSTIC_POSITIONS + #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTIC_POSITIONS _dp +#else + #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTIC_POSITIONS +#endif + +#if JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON + #define NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON _ldvcmp +#else + #define NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON +#endif + +#ifndef NLOHMANN_JSON_NAMESPACE_NO_VERSION + #define NLOHMANN_JSON_NAMESPACE_NO_VERSION 0 +#endif + +// Construct the namespace ABI tags component +#define NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c) json_abi ## a ## b ## c +#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b, c) \ + NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c) + +#define NLOHMANN_JSON_ABI_TAGS \ + NLOHMANN_JSON_ABI_TAGS_CONCAT( \ + NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS, \ + NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON, \ + NLOHMANN_JSON_ABI_TAG_DIAGNOSTIC_POSITIONS) + +// Construct the namespace version component +#define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) \ + _v ## major ## _ ## minor ## _ ## patch +#define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT(major, minor, patch) \ + NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) + +#if NLOHMANN_JSON_NAMESPACE_NO_VERSION +#define NLOHMANN_JSON_NAMESPACE_VERSION +#else +#define NLOHMANN_JSON_NAMESPACE_VERSION \ + NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT(NLOHMANN_JSON_VERSION_MAJOR, \ + NLOHMANN_JSON_VERSION_MINOR, \ + NLOHMANN_JSON_VERSION_PATCH) +#endif + +// Combine namespace components +#define NLOHMANN_JSON_NAMESPACE_CONCAT_EX(a, b) a ## b +#define NLOHMANN_JSON_NAMESPACE_CONCAT(a, b) \ + NLOHMANN_JSON_NAMESPACE_CONCAT_EX(a, b) + +#ifndef NLOHMANN_JSON_NAMESPACE +#define NLOHMANN_JSON_NAMESPACE \ + nlohmann::NLOHMANN_JSON_NAMESPACE_CONCAT( \ + NLOHMANN_JSON_ABI_TAGS, \ + NLOHMANN_JSON_NAMESPACE_VERSION) +#endif + +#ifndef NLOHMANN_JSON_NAMESPACE_BEGIN +#define NLOHMANN_JSON_NAMESPACE_BEGIN \ + namespace nlohmann \ + { \ + inline namespace NLOHMANN_JSON_NAMESPACE_CONCAT( \ + NLOHMANN_JSON_ABI_TAGS, \ + NLOHMANN_JSON_NAMESPACE_VERSION) \ + { +#endif + +#ifndef NLOHMANN_JSON_NAMESPACE_END +#define NLOHMANN_JSON_NAMESPACE_END \ + } /* namespace (inline namespace) NOLINT(readability/namespace) */ \ + } // namespace nlohmann +#endif + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // transform +#include // array +#include // forward_list +#include // inserter, front_inserter, end +#include // map +#ifdef JSON_HAS_CPP_17 + #include // optional +#endif +#include // string +#include // tuple, make_tuple +#include // is_arithmetic, is_same, is_enum, underlying_type, is_convertible +#include // unordered_map +#include // pair, declval +#include // valarray + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // nullptr_t +#include // exception +#if JSON_DIAGNOSTICS + #include // accumulate +#endif +#include // runtime_error +#include // to_string +#include // vector + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // array +#include // size_t +#include // uint8_t +#include // string + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // declval, pair +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +// #include + + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +template struct make_void +{ + using type = void; +}; +template using void_t = typename make_void::type; + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END + + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +// https://en.cppreference.com/w/cpp/experimental/is_detected +struct nonesuch +{ + nonesuch() = delete; + ~nonesuch() = delete; + nonesuch(nonesuch const&) = delete; + nonesuch(nonesuch const&&) = delete; + void operator=(nonesuch const&) = delete; + void operator=(nonesuch&&) = delete; +}; + +template class Op, + class... Args> +struct detector +{ + using value_t = std::false_type; + using type = Default; +}; + +template class Op, class... Args> +struct detector>, Op, Args...> +{ + using value_t = std::true_type; + using type = Op; +}; + +template class Op, class... Args> +using is_detected = typename detector::value_t; + +template class Op, class... Args> +struct is_detected_lazy : is_detected { }; + +template class Op, class... Args> +using detected_t = typename detector::type; + +template class Op, class... Args> +using detected_or = detector; + +template class Op, class... Args> +using detected_or_t = typename detected_or::type; + +template class Op, class... Args> +using is_detected_exact = std::is_same>; + +template class Op, class... Args> +using is_detected_convertible = + std::is_convertible, To>; + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END + +// #include + + +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-FileCopyrightText: 2016 - 2021 Evan Nemerson +// SPDX-License-Identifier: MIT + +/* Hedley - https://nemequ.github.io/hedley + * Created by Evan Nemerson + */ + +#if !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < 15) +#if defined(JSON_HEDLEY_VERSION) + #undef JSON_HEDLEY_VERSION +#endif +#define JSON_HEDLEY_VERSION 15 + +#if defined(JSON_HEDLEY_STRINGIFY_EX) + #undef JSON_HEDLEY_STRINGIFY_EX +#endif +#define JSON_HEDLEY_STRINGIFY_EX(x) #x + +#if defined(JSON_HEDLEY_STRINGIFY) + #undef JSON_HEDLEY_STRINGIFY +#endif +#define JSON_HEDLEY_STRINGIFY(x) JSON_HEDLEY_STRINGIFY_EX(x) + +#if defined(JSON_HEDLEY_CONCAT_EX) + #undef JSON_HEDLEY_CONCAT_EX +#endif +#define JSON_HEDLEY_CONCAT_EX(a,b) a##b + +#if defined(JSON_HEDLEY_CONCAT) + #undef JSON_HEDLEY_CONCAT +#endif +#define JSON_HEDLEY_CONCAT(a,b) JSON_HEDLEY_CONCAT_EX(a,b) + +#if defined(JSON_HEDLEY_CONCAT3_EX) + #undef JSON_HEDLEY_CONCAT3_EX +#endif +#define JSON_HEDLEY_CONCAT3_EX(a,b,c) a##b##c + +#if defined(JSON_HEDLEY_CONCAT3) + #undef JSON_HEDLEY_CONCAT3 +#endif +#define JSON_HEDLEY_CONCAT3(a,b,c) JSON_HEDLEY_CONCAT3_EX(a,b,c) + +#if defined(JSON_HEDLEY_VERSION_ENCODE) + #undef JSON_HEDLEY_VERSION_ENCODE +#endif +#define JSON_HEDLEY_VERSION_ENCODE(major,minor,revision) (((major) * 1000000) + ((minor) * 1000) + (revision)) + +#if defined(JSON_HEDLEY_VERSION_DECODE_MAJOR) + #undef JSON_HEDLEY_VERSION_DECODE_MAJOR +#endif +#define JSON_HEDLEY_VERSION_DECODE_MAJOR(version) ((version) / 1000000) + +#if defined(JSON_HEDLEY_VERSION_DECODE_MINOR) + #undef JSON_HEDLEY_VERSION_DECODE_MINOR +#endif +#define JSON_HEDLEY_VERSION_DECODE_MINOR(version) (((version) % 1000000) / 1000) + +#if defined(JSON_HEDLEY_VERSION_DECODE_REVISION) + #undef JSON_HEDLEY_VERSION_DECODE_REVISION +#endif +#define JSON_HEDLEY_VERSION_DECODE_REVISION(version) ((version) % 1000) + +#if defined(JSON_HEDLEY_GNUC_VERSION) + #undef JSON_HEDLEY_GNUC_VERSION +#endif +#if defined(__GNUC__) && defined(__GNUC_PATCHLEVEL__) + #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__) +#elif defined(__GNUC__) + #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, 0) +#endif + +#if defined(JSON_HEDLEY_GNUC_VERSION_CHECK) + #undef JSON_HEDLEY_GNUC_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_GNUC_VERSION) + #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GNUC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_MSVC_VERSION) + #undef JSON_HEDLEY_MSVC_VERSION +#endif +#if defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 140000000) && !defined(__ICL) + #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 10000000, (_MSC_FULL_VER % 10000000) / 100000, (_MSC_FULL_VER % 100000) / 100) +#elif defined(_MSC_FULL_VER) && !defined(__ICL) + #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 1000000, (_MSC_FULL_VER % 1000000) / 10000, (_MSC_FULL_VER % 10000) / 10) +#elif defined(_MSC_VER) && !defined(__ICL) + #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_VER / 100, _MSC_VER % 100, 0) +#endif + +#if defined(JSON_HEDLEY_MSVC_VERSION_CHECK) + #undef JSON_HEDLEY_MSVC_VERSION_CHECK +#endif +#if !defined(JSON_HEDLEY_MSVC_VERSION) + #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (0) +#elif defined(_MSC_VER) && (_MSC_VER >= 1400) + #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 10000000) + (minor * 100000) + (patch))) +#elif defined(_MSC_VER) && (_MSC_VER >= 1200) + #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 1000000) + (minor * 10000) + (patch))) +#else + #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_VER >= ((major * 100) + (minor))) +#endif + +#if defined(JSON_HEDLEY_INTEL_VERSION) + #undef JSON_HEDLEY_INTEL_VERSION +#endif +#if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && !defined(__ICL) + #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, __INTEL_COMPILER_UPDATE) +#elif defined(__INTEL_COMPILER) && !defined(__ICL) + #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, 0) +#endif + +#if defined(JSON_HEDLEY_INTEL_VERSION_CHECK) + #undef JSON_HEDLEY_INTEL_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_INTEL_VERSION) + #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_INTEL_CL_VERSION) + #undef JSON_HEDLEY_INTEL_CL_VERSION +#endif +#if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && defined(__ICL) + #define JSON_HEDLEY_INTEL_CL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER, __INTEL_COMPILER_UPDATE, 0) +#endif + +#if defined(JSON_HEDLEY_INTEL_CL_VERSION_CHECK) + #undef JSON_HEDLEY_INTEL_CL_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_INTEL_CL_VERSION) + #define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_CL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_PGI_VERSION) + #undef JSON_HEDLEY_PGI_VERSION +#endif +#if defined(__PGI) && defined(__PGIC__) && defined(__PGIC_MINOR__) && defined(__PGIC_PATCHLEVEL__) + #define JSON_HEDLEY_PGI_VERSION JSON_HEDLEY_VERSION_ENCODE(__PGIC__, __PGIC_MINOR__, __PGIC_PATCHLEVEL__) +#endif + +#if defined(JSON_HEDLEY_PGI_VERSION_CHECK) + #undef JSON_HEDLEY_PGI_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_PGI_VERSION) + #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PGI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_SUNPRO_VERSION) + #undef JSON_HEDLEY_SUNPRO_VERSION +#endif +#if defined(__SUNPRO_C) && (__SUNPRO_C > 0x1000) + #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((((__SUNPRO_C >> 16) & 0xf) * 10) + ((__SUNPRO_C >> 12) & 0xf), (((__SUNPRO_C >> 8) & 0xf) * 10) + ((__SUNPRO_C >> 4) & 0xf), (__SUNPRO_C & 0xf) * 10) +#elif defined(__SUNPRO_C) + #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_C >> 8) & 0xf, (__SUNPRO_C >> 4) & 0xf, (__SUNPRO_C) & 0xf) +#elif defined(__SUNPRO_CC) && (__SUNPRO_CC > 0x1000) + #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((((__SUNPRO_CC >> 16) & 0xf) * 10) + ((__SUNPRO_CC >> 12) & 0xf), (((__SUNPRO_CC >> 8) & 0xf) * 10) + ((__SUNPRO_CC >> 4) & 0xf), (__SUNPRO_CC & 0xf) * 10) +#elif defined(__SUNPRO_CC) + #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_CC >> 8) & 0xf, (__SUNPRO_CC >> 4) & 0xf, (__SUNPRO_CC) & 0xf) +#endif + +#if defined(JSON_HEDLEY_SUNPRO_VERSION_CHECK) + #undef JSON_HEDLEY_SUNPRO_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_SUNPRO_VERSION) + #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_SUNPRO_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION) + #undef JSON_HEDLEY_EMSCRIPTEN_VERSION +#endif +#if defined(__EMSCRIPTEN__) + #define JSON_HEDLEY_EMSCRIPTEN_VERSION JSON_HEDLEY_VERSION_ENCODE(__EMSCRIPTEN_major__, __EMSCRIPTEN_minor__, __EMSCRIPTEN_tiny__) +#endif + +#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK) + #undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION) + #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_EMSCRIPTEN_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_ARM_VERSION) + #undef JSON_HEDLEY_ARM_VERSION +#endif +#if defined(__CC_ARM) && defined(__ARMCOMPILER_VERSION) + #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCOMPILER_VERSION / 1000000, (__ARMCOMPILER_VERSION % 1000000) / 10000, (__ARMCOMPILER_VERSION % 10000) / 100) +#elif defined(__CC_ARM) && defined(__ARMCC_VERSION) + #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCC_VERSION / 1000000, (__ARMCC_VERSION % 1000000) / 10000, (__ARMCC_VERSION % 10000) / 100) +#endif + +#if defined(JSON_HEDLEY_ARM_VERSION_CHECK) + #undef JSON_HEDLEY_ARM_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_ARM_VERSION) + #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_ARM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_IBM_VERSION) + #undef JSON_HEDLEY_IBM_VERSION +#endif +#if defined(__ibmxl__) + #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ibmxl_version__, __ibmxl_release__, __ibmxl_modification__) +#elif defined(__xlC__) && defined(__xlC_ver__) + #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, (__xlC_ver__ >> 8) & 0xff) +#elif defined(__xlC__) + #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, 0) +#endif + +#if defined(JSON_HEDLEY_IBM_VERSION_CHECK) + #undef JSON_HEDLEY_IBM_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_IBM_VERSION) + #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IBM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TI_VERSION) + #undef JSON_HEDLEY_TI_VERSION +#endif +#if \ + defined(__TI_COMPILER_VERSION__) && \ + ( \ + defined(__TMS470__) || defined(__TI_ARM__) || \ + defined(__MSP430__) || \ + defined(__TMS320C2000__) \ + ) +#if (__TI_COMPILER_VERSION__ >= 16000000) + #define JSON_HEDLEY_TI_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) +#endif +#endif + +#if defined(JSON_HEDLEY_TI_VERSION_CHECK) + #undef JSON_HEDLEY_TI_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TI_VERSION) + #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TI_CL2000_VERSION) + #undef JSON_HEDLEY_TI_CL2000_VERSION +#endif +#if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C2000__) + #define JSON_HEDLEY_TI_CL2000_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) +#endif + +#if defined(JSON_HEDLEY_TI_CL2000_VERSION_CHECK) + #undef JSON_HEDLEY_TI_CL2000_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TI_CL2000_VERSION) + #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL2000_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TI_CL430_VERSION) + #undef JSON_HEDLEY_TI_CL430_VERSION +#endif +#if defined(__TI_COMPILER_VERSION__) && defined(__MSP430__) + #define JSON_HEDLEY_TI_CL430_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) +#endif + +#if defined(JSON_HEDLEY_TI_CL430_VERSION_CHECK) + #undef JSON_HEDLEY_TI_CL430_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TI_CL430_VERSION) + #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL430_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TI_ARMCL_VERSION) + #undef JSON_HEDLEY_TI_ARMCL_VERSION +#endif +#if defined(__TI_COMPILER_VERSION__) && (defined(__TMS470__) || defined(__TI_ARM__)) + #define JSON_HEDLEY_TI_ARMCL_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) +#endif + +#if defined(JSON_HEDLEY_TI_ARMCL_VERSION_CHECK) + #undef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TI_ARMCL_VERSION) + #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_ARMCL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TI_CL6X_VERSION) + #undef JSON_HEDLEY_TI_CL6X_VERSION +#endif +#if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C6X__) + #define JSON_HEDLEY_TI_CL6X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) +#endif + +#if defined(JSON_HEDLEY_TI_CL6X_VERSION_CHECK) + #undef JSON_HEDLEY_TI_CL6X_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TI_CL6X_VERSION) + #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL6X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TI_CL7X_VERSION) + #undef JSON_HEDLEY_TI_CL7X_VERSION +#endif +#if defined(__TI_COMPILER_VERSION__) && defined(__C7000__) + #define JSON_HEDLEY_TI_CL7X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) +#endif + +#if defined(JSON_HEDLEY_TI_CL7X_VERSION_CHECK) + #undef JSON_HEDLEY_TI_CL7X_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TI_CL7X_VERSION) + #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL7X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TI_CLPRU_VERSION) + #undef JSON_HEDLEY_TI_CLPRU_VERSION +#endif +#if defined(__TI_COMPILER_VERSION__) && defined(__PRU__) + #define JSON_HEDLEY_TI_CLPRU_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) +#endif + +#if defined(JSON_HEDLEY_TI_CLPRU_VERSION_CHECK) + #undef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TI_CLPRU_VERSION) + #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CLPRU_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_CRAY_VERSION) + #undef JSON_HEDLEY_CRAY_VERSION +#endif +#if defined(_CRAYC) + #if defined(_RELEASE_PATCHLEVEL) + #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, _RELEASE_PATCHLEVEL) + #else + #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, 0) + #endif +#endif + +#if defined(JSON_HEDLEY_CRAY_VERSION_CHECK) + #undef JSON_HEDLEY_CRAY_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_CRAY_VERSION) + #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_CRAY_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_IAR_VERSION) + #undef JSON_HEDLEY_IAR_VERSION +#endif +#if defined(__IAR_SYSTEMS_ICC__) + #if __VER__ > 1000 + #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE((__VER__ / 1000000), ((__VER__ / 1000) % 1000), (__VER__ % 1000)) + #else + #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE(__VER__ / 100, __VER__ % 100, 0) + #endif +#endif + +#if defined(JSON_HEDLEY_IAR_VERSION_CHECK) + #undef JSON_HEDLEY_IAR_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_IAR_VERSION) + #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IAR_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TINYC_VERSION) + #undef JSON_HEDLEY_TINYC_VERSION +#endif +#if defined(__TINYC__) + #define JSON_HEDLEY_TINYC_VERSION JSON_HEDLEY_VERSION_ENCODE(__TINYC__ / 1000, (__TINYC__ / 100) % 10, __TINYC__ % 100) +#endif + +#if defined(JSON_HEDLEY_TINYC_VERSION_CHECK) + #undef JSON_HEDLEY_TINYC_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TINYC_VERSION) + #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TINYC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_DMC_VERSION) + #undef JSON_HEDLEY_DMC_VERSION +#endif +#if defined(__DMC__) + #define JSON_HEDLEY_DMC_VERSION JSON_HEDLEY_VERSION_ENCODE(__DMC__ >> 8, (__DMC__ >> 4) & 0xf, __DMC__ & 0xf) +#endif + +#if defined(JSON_HEDLEY_DMC_VERSION_CHECK) + #undef JSON_HEDLEY_DMC_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_DMC_VERSION) + #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_DMC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_COMPCERT_VERSION) + #undef JSON_HEDLEY_COMPCERT_VERSION +#endif +#if defined(__COMPCERT_VERSION__) + #define JSON_HEDLEY_COMPCERT_VERSION JSON_HEDLEY_VERSION_ENCODE(__COMPCERT_VERSION__ / 10000, (__COMPCERT_VERSION__ / 100) % 100, __COMPCERT_VERSION__ % 100) +#endif + +#if defined(JSON_HEDLEY_COMPCERT_VERSION_CHECK) + #undef JSON_HEDLEY_COMPCERT_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_COMPCERT_VERSION) + #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_COMPCERT_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_PELLES_VERSION) + #undef JSON_HEDLEY_PELLES_VERSION +#endif +#if defined(__POCC__) + #define JSON_HEDLEY_PELLES_VERSION JSON_HEDLEY_VERSION_ENCODE(__POCC__ / 100, __POCC__ % 100, 0) +#endif + +#if defined(JSON_HEDLEY_PELLES_VERSION_CHECK) + #undef JSON_HEDLEY_PELLES_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_PELLES_VERSION) + #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PELLES_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_MCST_LCC_VERSION) + #undef JSON_HEDLEY_MCST_LCC_VERSION +#endif +#if defined(__LCC__) && defined(__LCC_MINOR__) + #define JSON_HEDLEY_MCST_LCC_VERSION JSON_HEDLEY_VERSION_ENCODE(__LCC__ / 100, __LCC__ % 100, __LCC_MINOR__) +#endif + +#if defined(JSON_HEDLEY_MCST_LCC_VERSION_CHECK) + #undef JSON_HEDLEY_MCST_LCC_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_MCST_LCC_VERSION) + #define JSON_HEDLEY_MCST_LCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_MCST_LCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_MCST_LCC_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_GCC_VERSION) + #undef JSON_HEDLEY_GCC_VERSION +#endif +#if \ + defined(JSON_HEDLEY_GNUC_VERSION) && \ + !defined(__clang__) && \ + !defined(JSON_HEDLEY_INTEL_VERSION) && \ + !defined(JSON_HEDLEY_PGI_VERSION) && \ + !defined(JSON_HEDLEY_ARM_VERSION) && \ + !defined(JSON_HEDLEY_CRAY_VERSION) && \ + !defined(JSON_HEDLEY_TI_VERSION) && \ + !defined(JSON_HEDLEY_TI_ARMCL_VERSION) && \ + !defined(JSON_HEDLEY_TI_CL430_VERSION) && \ + !defined(JSON_HEDLEY_TI_CL2000_VERSION) && \ + !defined(JSON_HEDLEY_TI_CL6X_VERSION) && \ + !defined(JSON_HEDLEY_TI_CL7X_VERSION) && \ + !defined(JSON_HEDLEY_TI_CLPRU_VERSION) && \ + !defined(__COMPCERT__) && \ + !defined(JSON_HEDLEY_MCST_LCC_VERSION) + #define JSON_HEDLEY_GCC_VERSION JSON_HEDLEY_GNUC_VERSION +#endif + +#if defined(JSON_HEDLEY_GCC_VERSION_CHECK) + #undef JSON_HEDLEY_GCC_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_GCC_VERSION) + #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_HAS_ATTRIBUTE) + #undef JSON_HEDLEY_HAS_ATTRIBUTE +#endif +#if \ + defined(__has_attribute) && \ + ( \ + (!defined(JSON_HEDLEY_IAR_VERSION) || JSON_HEDLEY_IAR_VERSION_CHECK(8,5,9)) \ + ) +# define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) __has_attribute(attribute) +#else +# define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) (0) +#endif + +#if defined(JSON_HEDLEY_GNUC_HAS_ATTRIBUTE) + #undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE +#endif +#if defined(__has_attribute) + #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_HAS_ATTRIBUTE(attribute) +#else + #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_GCC_HAS_ATTRIBUTE) + #undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE +#endif +#if defined(__has_attribute) + #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_HAS_ATTRIBUTE(attribute) +#else + #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE) + #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE +#endif +#if \ + defined(__has_cpp_attribute) && \ + defined(__cplusplus) && \ + (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0)) + #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) __has_cpp_attribute(attribute) +#else + #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) (0) +#endif + +#if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS) + #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS +#endif +#if !defined(__cplusplus) || !defined(__has_cpp_attribute) + #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0) +#elif \ + !defined(JSON_HEDLEY_PGI_VERSION) && \ + !defined(JSON_HEDLEY_IAR_VERSION) && \ + (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0)) && \ + (!defined(JSON_HEDLEY_MSVC_VERSION) || JSON_HEDLEY_MSVC_VERSION_CHECK(19,20,0)) + #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(ns::attribute) +#else + #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0) +#endif + +#if defined(JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE) + #undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE +#endif +#if defined(__has_cpp_attribute) && defined(__cplusplus) + #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute) +#else + #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE) + #undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE +#endif +#if defined(__has_cpp_attribute) && defined(__cplusplus) + #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute) +#else + #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_HAS_BUILTIN) + #undef JSON_HEDLEY_HAS_BUILTIN +#endif +#if defined(__has_builtin) + #define JSON_HEDLEY_HAS_BUILTIN(builtin) __has_builtin(builtin) +#else + #define JSON_HEDLEY_HAS_BUILTIN(builtin) (0) +#endif + +#if defined(JSON_HEDLEY_GNUC_HAS_BUILTIN) + #undef JSON_HEDLEY_GNUC_HAS_BUILTIN +#endif +#if defined(__has_builtin) + #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin) +#else + #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_GCC_HAS_BUILTIN) + #undef JSON_HEDLEY_GCC_HAS_BUILTIN +#endif +#if defined(__has_builtin) + #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin) +#else + #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_HAS_FEATURE) + #undef JSON_HEDLEY_HAS_FEATURE +#endif +#if defined(__has_feature) + #define JSON_HEDLEY_HAS_FEATURE(feature) __has_feature(feature) +#else + #define JSON_HEDLEY_HAS_FEATURE(feature) (0) +#endif + +#if defined(JSON_HEDLEY_GNUC_HAS_FEATURE) + #undef JSON_HEDLEY_GNUC_HAS_FEATURE +#endif +#if defined(__has_feature) + #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature) +#else + #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_GCC_HAS_FEATURE) + #undef JSON_HEDLEY_GCC_HAS_FEATURE +#endif +#if defined(__has_feature) + #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature) +#else + #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_HAS_EXTENSION) + #undef JSON_HEDLEY_HAS_EXTENSION +#endif +#if defined(__has_extension) + #define JSON_HEDLEY_HAS_EXTENSION(extension) __has_extension(extension) +#else + #define JSON_HEDLEY_HAS_EXTENSION(extension) (0) +#endif + +#if defined(JSON_HEDLEY_GNUC_HAS_EXTENSION) + #undef JSON_HEDLEY_GNUC_HAS_EXTENSION +#endif +#if defined(__has_extension) + #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension) +#else + #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_GCC_HAS_EXTENSION) + #undef JSON_HEDLEY_GCC_HAS_EXTENSION +#endif +#if defined(__has_extension) + #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension) +#else + #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE) + #undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE +#endif +#if defined(__has_declspec_attribute) + #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) __has_declspec_attribute(attribute) +#else + #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) (0) +#endif + +#if defined(JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE) + #undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE +#endif +#if defined(__has_declspec_attribute) + #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute) +#else + #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE) + #undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE +#endif +#if defined(__has_declspec_attribute) + #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute) +#else + #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_HAS_WARNING) + #undef JSON_HEDLEY_HAS_WARNING +#endif +#if defined(__has_warning) + #define JSON_HEDLEY_HAS_WARNING(warning) __has_warning(warning) +#else + #define JSON_HEDLEY_HAS_WARNING(warning) (0) +#endif + +#if defined(JSON_HEDLEY_GNUC_HAS_WARNING) + #undef JSON_HEDLEY_GNUC_HAS_WARNING +#endif +#if defined(__has_warning) + #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning) +#else + #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_GCC_HAS_WARNING) + #undef JSON_HEDLEY_GCC_HAS_WARNING +#endif +#if defined(__has_warning) + #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning) +#else + #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if \ + (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \ + defined(__clang__) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,0,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0) || \ + JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,17) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(8,0,0) || \ + (JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) && defined(__C99_PRAGMA_OPERATOR)) + #define JSON_HEDLEY_PRAGMA(value) _Pragma(#value) +#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) + #define JSON_HEDLEY_PRAGMA(value) __pragma(value) +#else + #define JSON_HEDLEY_PRAGMA(value) +#endif + +#if defined(JSON_HEDLEY_DIAGNOSTIC_PUSH) + #undef JSON_HEDLEY_DIAGNOSTIC_PUSH +#endif +#if defined(JSON_HEDLEY_DIAGNOSTIC_POP) + #undef JSON_HEDLEY_DIAGNOSTIC_POP +#endif +#if defined(__clang__) + #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("clang diagnostic push") + #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("clang diagnostic pop") +#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)") + #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)") +#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0) + #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("GCC diagnostic push") + #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("GCC diagnostic pop") +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_DIAGNOSTIC_PUSH __pragma(warning(push)) + #define JSON_HEDLEY_DIAGNOSTIC_POP __pragma(warning(pop)) +#elif JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) + #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("push") + #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("pop") +#elif \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,4,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) + #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("diag_push") + #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("diag_pop") +#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0) + #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)") + #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)") +#else + #define JSON_HEDLEY_DIAGNOSTIC_PUSH + #define JSON_HEDLEY_DIAGNOSTIC_POP +#endif + +/* JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_ is for + HEDLEY INTERNAL USE ONLY. API subject to change without notice. */ +#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_) + #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_ +#endif +#if defined(__cplusplus) +# if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat") +# if JSON_HEDLEY_HAS_WARNING("-Wc++17-extensions") +# if JSON_HEDLEY_HAS_WARNING("-Wc++1z-extensions") +# define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \ + _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \ + _Pragma("clang diagnostic ignored \"-Wc++1z-extensions\"") \ + xpr \ + JSON_HEDLEY_DIAGNOSTIC_POP +# else +# define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \ + _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \ + xpr \ + JSON_HEDLEY_DIAGNOSTIC_POP +# endif +# else +# define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \ + xpr \ + JSON_HEDLEY_DIAGNOSTIC_POP +# endif +# endif +#endif +#if !defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(x) x +#endif + +#if defined(JSON_HEDLEY_CONST_CAST) + #undef JSON_HEDLEY_CONST_CAST +#endif +#if defined(__cplusplus) +# define JSON_HEDLEY_CONST_CAST(T, expr) (const_cast(expr)) +#elif \ + JSON_HEDLEY_HAS_WARNING("-Wcast-qual") || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) +# define JSON_HEDLEY_CONST_CAST(T, expr) (__extension__ ({ \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL \ + ((T) (expr)); \ + JSON_HEDLEY_DIAGNOSTIC_POP \ + })) +#else +# define JSON_HEDLEY_CONST_CAST(T, expr) ((T) (expr)) +#endif + +#if defined(JSON_HEDLEY_REINTERPRET_CAST) + #undef JSON_HEDLEY_REINTERPRET_CAST +#endif +#if defined(__cplusplus) + #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) (reinterpret_cast(expr)) +#else + #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) ((T) (expr)) +#endif + +#if defined(JSON_HEDLEY_STATIC_CAST) + #undef JSON_HEDLEY_STATIC_CAST +#endif +#if defined(__cplusplus) + #define JSON_HEDLEY_STATIC_CAST(T, expr) (static_cast(expr)) +#else + #define JSON_HEDLEY_STATIC_CAST(T, expr) ((T) (expr)) +#endif + +#if defined(JSON_HEDLEY_CPP_CAST) + #undef JSON_HEDLEY_CPP_CAST +#endif +#if defined(__cplusplus) +# if JSON_HEDLEY_HAS_WARNING("-Wold-style-cast") +# define JSON_HEDLEY_CPP_CAST(T, expr) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("clang diagnostic ignored \"-Wold-style-cast\"") \ + ((T) (expr)) \ + JSON_HEDLEY_DIAGNOSTIC_POP +# elif JSON_HEDLEY_IAR_VERSION_CHECK(8,3,0) +# define JSON_HEDLEY_CPP_CAST(T, expr) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("diag_suppress=Pe137") \ + JSON_HEDLEY_DIAGNOSTIC_POP +# else +# define JSON_HEDLEY_CPP_CAST(T, expr) ((T) (expr)) +# endif +#else +# define JSON_HEDLEY_CPP_CAST(T, expr) (expr) +#endif + +#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED) + #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wdeprecated-declarations") + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"") +#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warning(disable:1478 1786)") +#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:1478 1786)) +#elif JSON_HEDLEY_PGI_VERSION_CHECK(20,7,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1216,1444,1445") +#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444") +#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"") +#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:4996)) +#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444") +#elif \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1291,1718") +#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && !defined(__cplusplus) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,E_DEPRECATED_ATT,E_DEPRECATED_ATT_MESS)") +#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && defined(__cplusplus) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,symdeprecated,symdeprecated2)") +#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress=Pe1444,Pe1215") +#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warn(disable:2241)") +#else + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED +#endif + +#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS) + #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas") + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("clang diagnostic ignored \"-Wunknown-pragmas\"") +#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("warning(disable:161)") +#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:161)) +#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 1675") +#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("GCC diagnostic ignored \"-Wunknown-pragmas\"") +#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:4068)) +#elif \ + JSON_HEDLEY_TI_VERSION_CHECK(16,9,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163") +#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163") +#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress=Pe161") +#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 161") +#else + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS +#endif + +#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES) + #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wunknown-attributes") + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("clang diagnostic ignored \"-Wunknown-attributes\"") +#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"") +#elif JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("warning(disable:1292)") +#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:1292)) +#elif JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:5030)) +#elif JSON_HEDLEY_PGI_VERSION_CHECK(20,7,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097,1098") +#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097") +#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("error_messages(off,attrskipunsup)") +#elif \ + JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1173") +#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress=Pe1097") +#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097") +#else + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES +#endif + +#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL) + #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wcast-qual") + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("clang diagnostic ignored \"-Wcast-qual\"") +#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("warning(disable:2203 2331)") +#elif JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("GCC diagnostic ignored \"-Wcast-qual\"") +#else + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL +#endif + +#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION) + #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wunused-function") + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("clang diagnostic ignored \"-Wunused-function\"") +#elif JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("GCC diagnostic ignored \"-Wunused-function\"") +#elif JSON_HEDLEY_MSVC_VERSION_CHECK(1,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION __pragma(warning(disable:4505)) +#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("diag_suppress 3142") +#else + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION +#endif + +#if defined(JSON_HEDLEY_DEPRECATED) + #undef JSON_HEDLEY_DEPRECATED +#endif +#if defined(JSON_HEDLEY_DEPRECATED_FOR) + #undef JSON_HEDLEY_DEPRECATED_FOR +#endif +#if \ + JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated("Since " # since)) + #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated("Since " #since "; use " #replacement)) +#elif \ + (JSON_HEDLEY_HAS_EXTENSION(attribute_deprecated_with_message) && !defined(JSON_HEDLEY_IAR_VERSION)) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(18,1,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__("Since " #since))) + #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__("Since " #since "; use " #replacement))) +#elif defined(__cplusplus) && (__cplusplus >= 201402L) + #define JSON_HEDLEY_DEPRECATED(since) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since)]]) + #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since "; use " #replacement)]]) +#elif \ + JSON_HEDLEY_HAS_ATTRIBUTE(deprecated) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \ + JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0) + #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__)) + #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__)) +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \ + JSON_HEDLEY_PELLES_VERSION_CHECK(6,50,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated) + #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated) +#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) + #define JSON_HEDLEY_DEPRECATED(since) _Pragma("deprecated") + #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) _Pragma("deprecated") +#else + #define JSON_HEDLEY_DEPRECATED(since) + #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) +#endif + +#if defined(JSON_HEDLEY_UNAVAILABLE) + #undef JSON_HEDLEY_UNAVAILABLE +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(warning) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_UNAVAILABLE(available_since) __attribute__((__warning__("Not available until " #available_since))) +#else + #define JSON_HEDLEY_UNAVAILABLE(available_since) +#endif + +#if defined(JSON_HEDLEY_WARN_UNUSED_RESULT) + #undef JSON_HEDLEY_WARN_UNUSED_RESULT +#endif +#if defined(JSON_HEDLEY_WARN_UNUSED_RESULT_MSG) + #undef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(warn_unused_result) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_WARN_UNUSED_RESULT __attribute__((__warn_unused_result__)) + #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) __attribute__((__warn_unused_result__)) +#elif (JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard) >= 201907L) + #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]]) + #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard(msg)]]) +#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard) + #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]]) + #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]]) +#elif defined(_Check_return_) /* SAL */ + #define JSON_HEDLEY_WARN_UNUSED_RESULT _Check_return_ + #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) _Check_return_ +#else + #define JSON_HEDLEY_WARN_UNUSED_RESULT + #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) +#endif + +#if defined(JSON_HEDLEY_SENTINEL) + #undef JSON_HEDLEY_SENTINEL +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(sentinel) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_SENTINEL(position) __attribute__((__sentinel__(position))) +#else + #define JSON_HEDLEY_SENTINEL(position) +#endif + +#if defined(JSON_HEDLEY_NO_RETURN) + #undef JSON_HEDLEY_NO_RETURN +#endif +#if JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) + #define JSON_HEDLEY_NO_RETURN __noreturn +#elif \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__)) +#elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L + #define JSON_HEDLEY_NO_RETURN _Noreturn +#elif defined(__cplusplus) && (__cplusplus >= 201103L) + #define JSON_HEDLEY_NO_RETURN JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[noreturn]]) +#elif \ + JSON_HEDLEY_HAS_ATTRIBUTE(noreturn) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,2,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0) + #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__)) +#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) + #define JSON_HEDLEY_NO_RETURN _Pragma("does_not_return") +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_NO_RETURN __declspec(noreturn) +#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus) + #define JSON_HEDLEY_NO_RETURN _Pragma("FUNC_NEVER_RETURNS;") +#elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0) + #define JSON_HEDLEY_NO_RETURN __attribute((noreturn)) +#elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0) + #define JSON_HEDLEY_NO_RETURN __declspec(noreturn) +#else + #define JSON_HEDLEY_NO_RETURN +#endif + +#if defined(JSON_HEDLEY_NO_ESCAPE) + #undef JSON_HEDLEY_NO_ESCAPE +#endif +#if JSON_HEDLEY_HAS_ATTRIBUTE(noescape) + #define JSON_HEDLEY_NO_ESCAPE __attribute__((__noescape__)) +#else + #define JSON_HEDLEY_NO_ESCAPE +#endif + +#if defined(JSON_HEDLEY_UNREACHABLE) + #undef JSON_HEDLEY_UNREACHABLE +#endif +#if defined(JSON_HEDLEY_UNREACHABLE_RETURN) + #undef JSON_HEDLEY_UNREACHABLE_RETURN +#endif +#if defined(JSON_HEDLEY_ASSUME) + #undef JSON_HEDLEY_ASSUME +#endif +#if \ + JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_ASSUME(expr) __assume(expr) +#elif JSON_HEDLEY_HAS_BUILTIN(__builtin_assume) + #define JSON_HEDLEY_ASSUME(expr) __builtin_assume(expr) +#elif \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0) + #if defined(__cplusplus) + #define JSON_HEDLEY_ASSUME(expr) std::_nassert(expr) + #else + #define JSON_HEDLEY_ASSUME(expr) _nassert(expr) + #endif +#endif +#if \ + (JSON_HEDLEY_HAS_BUILTIN(__builtin_unreachable) && (!defined(JSON_HEDLEY_ARM_VERSION))) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(18,10,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(13,1,5) || \ + JSON_HEDLEY_CRAY_VERSION_CHECK(10,0,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_UNREACHABLE() __builtin_unreachable() +#elif defined(JSON_HEDLEY_ASSUME) + #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0) +#endif +#if !defined(JSON_HEDLEY_ASSUME) + #if defined(JSON_HEDLEY_UNREACHABLE) + #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, ((expr) ? 1 : (JSON_HEDLEY_UNREACHABLE(), 1))) + #else + #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, expr) + #endif +#endif +#if defined(JSON_HEDLEY_UNREACHABLE) + #if \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0) + #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (JSON_HEDLEY_STATIC_CAST(void, JSON_HEDLEY_ASSUME(0)), (value)) + #else + #define JSON_HEDLEY_UNREACHABLE_RETURN(value) JSON_HEDLEY_UNREACHABLE() + #endif +#else + #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (value) +#endif +#if !defined(JSON_HEDLEY_UNREACHABLE) + #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0) +#endif + +JSON_HEDLEY_DIAGNOSTIC_PUSH +#if JSON_HEDLEY_HAS_WARNING("-Wpedantic") + #pragma clang diagnostic ignored "-Wpedantic" +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat-pedantic") && defined(__cplusplus) + #pragma clang diagnostic ignored "-Wc++98-compat-pedantic" +#endif +#if JSON_HEDLEY_GCC_HAS_WARNING("-Wvariadic-macros",4,0,0) + #if defined(__clang__) + #pragma clang diagnostic ignored "-Wvariadic-macros" + #elif defined(JSON_HEDLEY_GCC_VERSION) + #pragma GCC diagnostic ignored "-Wvariadic-macros" + #endif +#endif +#if defined(JSON_HEDLEY_NON_NULL) + #undef JSON_HEDLEY_NON_NULL +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(nonnull) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) + #define JSON_HEDLEY_NON_NULL(...) __attribute__((__nonnull__(__VA_ARGS__))) +#else + #define JSON_HEDLEY_NON_NULL(...) +#endif +JSON_HEDLEY_DIAGNOSTIC_POP + +#if defined(JSON_HEDLEY_PRINTF_FORMAT) + #undef JSON_HEDLEY_PRINTF_FORMAT +#endif +#if defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && !defined(__USE_MINGW_ANSI_STDIO) + #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(ms_printf, string_idx, first_to_check))) +#elif defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && defined(__USE_MINGW_ANSI_STDIO) + #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(gnu_printf, string_idx, first_to_check))) +#elif \ + JSON_HEDLEY_HAS_ATTRIBUTE(format) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(__printf__, string_idx, first_to_check))) +#elif JSON_HEDLEY_PELLES_VERSION_CHECK(6,0,0) + #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __declspec(vaformat(printf,string_idx,first_to_check)) +#else + #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) +#endif + +#if defined(JSON_HEDLEY_CONSTEXPR) + #undef JSON_HEDLEY_CONSTEXPR +#endif +#if defined(__cplusplus) + #if __cplusplus >= 201103L + #define JSON_HEDLEY_CONSTEXPR JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(constexpr) + #endif +#endif +#if !defined(JSON_HEDLEY_CONSTEXPR) + #define JSON_HEDLEY_CONSTEXPR +#endif + +#if defined(JSON_HEDLEY_PREDICT) + #undef JSON_HEDLEY_PREDICT +#endif +#if defined(JSON_HEDLEY_LIKELY) + #undef JSON_HEDLEY_LIKELY +#endif +#if defined(JSON_HEDLEY_UNLIKELY) + #undef JSON_HEDLEY_UNLIKELY +#endif +#if defined(JSON_HEDLEY_UNPREDICTABLE) + #undef JSON_HEDLEY_UNPREDICTABLE +#endif +#if JSON_HEDLEY_HAS_BUILTIN(__builtin_unpredictable) + #define JSON_HEDLEY_UNPREDICTABLE(expr) __builtin_unpredictable((expr)) +#endif +#if \ + (JSON_HEDLEY_HAS_BUILTIN(__builtin_expect_with_probability) && !defined(JSON_HEDLEY_PGI_VERSION)) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(9,0,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) +# define JSON_HEDLEY_PREDICT(expr, value, probability) __builtin_expect_with_probability( (expr), (value), (probability)) +# define JSON_HEDLEY_PREDICT_TRUE(expr, probability) __builtin_expect_with_probability(!!(expr), 1 , (probability)) +# define JSON_HEDLEY_PREDICT_FALSE(expr, probability) __builtin_expect_with_probability(!!(expr), 0 , (probability)) +# define JSON_HEDLEY_LIKELY(expr) __builtin_expect (!!(expr), 1 ) +# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect (!!(expr), 0 ) +#elif \ + (JSON_HEDLEY_HAS_BUILTIN(__builtin_expect) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,27) || \ + JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) +# define JSON_HEDLEY_PREDICT(expr, expected, probability) \ + (((probability) >= 0.9) ? __builtin_expect((expr), (expected)) : (JSON_HEDLEY_STATIC_CAST(void, expected), (expr))) +# define JSON_HEDLEY_PREDICT_TRUE(expr, probability) \ + (__extension__ ({ \ + double hedley_probability_ = (probability); \ + ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 1) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 0) : !!(expr))); \ + })) +# define JSON_HEDLEY_PREDICT_FALSE(expr, probability) \ + (__extension__ ({ \ + double hedley_probability_ = (probability); \ + ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 0) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 1) : !!(expr))); \ + })) +# define JSON_HEDLEY_LIKELY(expr) __builtin_expect(!!(expr), 1) +# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect(!!(expr), 0) +#else +# define JSON_HEDLEY_PREDICT(expr, expected, probability) (JSON_HEDLEY_STATIC_CAST(void, expected), (expr)) +# define JSON_HEDLEY_PREDICT_TRUE(expr, probability) (!!(expr)) +# define JSON_HEDLEY_PREDICT_FALSE(expr, probability) (!!(expr)) +# define JSON_HEDLEY_LIKELY(expr) (!!(expr)) +# define JSON_HEDLEY_UNLIKELY(expr) (!!(expr)) +#endif +#if !defined(JSON_HEDLEY_UNPREDICTABLE) + #define JSON_HEDLEY_UNPREDICTABLE(expr) JSON_HEDLEY_PREDICT(expr, 1, 0.5) +#endif + +#if defined(JSON_HEDLEY_MALLOC) + #undef JSON_HEDLEY_MALLOC +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(malloc) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_MALLOC __attribute__((__malloc__)) +#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) + #define JSON_HEDLEY_MALLOC _Pragma("returns_new_memory") +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_MALLOC __declspec(restrict) +#else + #define JSON_HEDLEY_MALLOC +#endif + +#if defined(JSON_HEDLEY_PURE) + #undef JSON_HEDLEY_PURE +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(pure) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(2,96,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) +# define JSON_HEDLEY_PURE __attribute__((__pure__)) +#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) +# define JSON_HEDLEY_PURE _Pragma("does_not_write_global_data") +#elif defined(__cplusplus) && \ + ( \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) \ + ) +# define JSON_HEDLEY_PURE _Pragma("FUNC_IS_PURE;") +#else +# define JSON_HEDLEY_PURE +#endif + +#if defined(JSON_HEDLEY_CONST) + #undef JSON_HEDLEY_CONST +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(const) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(2,5,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_CONST __attribute__((__const__)) +#elif \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) + #define JSON_HEDLEY_CONST _Pragma("no_side_effect") +#else + #define JSON_HEDLEY_CONST JSON_HEDLEY_PURE +#endif + +#if defined(JSON_HEDLEY_RESTRICT) + #undef JSON_HEDLEY_RESTRICT +#endif +#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && !defined(__cplusplus) + #define JSON_HEDLEY_RESTRICT restrict +#elif \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \ + JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,4) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)) || \ + JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \ + defined(__clang__) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_RESTRICT __restrict +#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,3,0) && !defined(__cplusplus) + #define JSON_HEDLEY_RESTRICT _Restrict +#else + #define JSON_HEDLEY_RESTRICT +#endif + +#if defined(JSON_HEDLEY_INLINE) + #undef JSON_HEDLEY_INLINE +#endif +#if \ + (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \ + (defined(__cplusplus) && (__cplusplus >= 199711L)) + #define JSON_HEDLEY_INLINE inline +#elif \ + defined(JSON_HEDLEY_GCC_VERSION) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(6,2,0) + #define JSON_HEDLEY_INLINE __inline__ +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,1,0) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_INLINE __inline +#else + #define JSON_HEDLEY_INLINE +#endif + +#if defined(JSON_HEDLEY_ALWAYS_INLINE) + #undef JSON_HEDLEY_ALWAYS_INLINE +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(always_inline) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \ + JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0) +# define JSON_HEDLEY_ALWAYS_INLINE __attribute__((__always_inline__)) JSON_HEDLEY_INLINE +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) +# define JSON_HEDLEY_ALWAYS_INLINE __forceinline +#elif defined(__cplusplus) && \ + ( \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) \ + ) +# define JSON_HEDLEY_ALWAYS_INLINE _Pragma("FUNC_ALWAYS_INLINE;") +#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) +# define JSON_HEDLEY_ALWAYS_INLINE _Pragma("inline=forced") +#else +# define JSON_HEDLEY_ALWAYS_INLINE JSON_HEDLEY_INLINE +#endif + +#if defined(JSON_HEDLEY_NEVER_INLINE) + #undef JSON_HEDLEY_NEVER_INLINE +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(noinline) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \ + JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0) + #define JSON_HEDLEY_NEVER_INLINE __attribute__((__noinline__)) +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline) +#elif JSON_HEDLEY_PGI_VERSION_CHECK(10,2,0) + #define JSON_HEDLEY_NEVER_INLINE _Pragma("noinline") +#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus) + #define JSON_HEDLEY_NEVER_INLINE _Pragma("FUNC_CANNOT_INLINE;") +#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) + #define JSON_HEDLEY_NEVER_INLINE _Pragma("inline=never") +#elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0) + #define JSON_HEDLEY_NEVER_INLINE __attribute((noinline)) +#elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0) + #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline) +#else + #define JSON_HEDLEY_NEVER_INLINE +#endif + +#if defined(JSON_HEDLEY_PRIVATE) + #undef JSON_HEDLEY_PRIVATE +#endif +#if defined(JSON_HEDLEY_PUBLIC) + #undef JSON_HEDLEY_PUBLIC +#endif +#if defined(JSON_HEDLEY_IMPORT) + #undef JSON_HEDLEY_IMPORT +#endif +#if defined(_WIN32) || defined(__CYGWIN__) +# define JSON_HEDLEY_PRIVATE +# define JSON_HEDLEY_PUBLIC __declspec(dllexport) +# define JSON_HEDLEY_IMPORT __declspec(dllimport) +#else +# if \ + JSON_HEDLEY_HAS_ATTRIBUTE(visibility) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \ + ( \ + defined(__TI_EABI__) && \ + ( \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) \ + ) \ + ) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) +# define JSON_HEDLEY_PRIVATE __attribute__((__visibility__("hidden"))) +# define JSON_HEDLEY_PUBLIC __attribute__((__visibility__("default"))) +# else +# define JSON_HEDLEY_PRIVATE +# define JSON_HEDLEY_PUBLIC +# endif +# define JSON_HEDLEY_IMPORT extern +#endif + +#if defined(JSON_HEDLEY_NO_THROW) + #undef JSON_HEDLEY_NO_THROW +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(nothrow) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_NO_THROW __attribute__((__nothrow__)) +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(13,1,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) + #define JSON_HEDLEY_NO_THROW __declspec(nothrow) +#else + #define JSON_HEDLEY_NO_THROW +#endif + +#if defined(JSON_HEDLEY_FALL_THROUGH) + #undef JSON_HEDLEY_FALL_THROUGH +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(fallthrough) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(7,0,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_FALL_THROUGH __attribute__((__fallthrough__)) +#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(clang,fallthrough) + #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[clang::fallthrough]]) +#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(fallthrough) + #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[fallthrough]]) +#elif defined(__fallthrough) /* SAL */ + #define JSON_HEDLEY_FALL_THROUGH __fallthrough +#else + #define JSON_HEDLEY_FALL_THROUGH +#endif + +#if defined(JSON_HEDLEY_RETURNS_NON_NULL) + #undef JSON_HEDLEY_RETURNS_NON_NULL +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(returns_nonnull) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_RETURNS_NON_NULL __attribute__((__returns_nonnull__)) +#elif defined(_Ret_notnull_) /* SAL */ + #define JSON_HEDLEY_RETURNS_NON_NULL _Ret_notnull_ +#else + #define JSON_HEDLEY_RETURNS_NON_NULL +#endif + +#if defined(JSON_HEDLEY_ARRAY_PARAM) + #undef JSON_HEDLEY_ARRAY_PARAM +#endif +#if \ + defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && \ + !defined(__STDC_NO_VLA__) && \ + !defined(__cplusplus) && \ + !defined(JSON_HEDLEY_PGI_VERSION) && \ + !defined(JSON_HEDLEY_TINYC_VERSION) + #define JSON_HEDLEY_ARRAY_PARAM(name) (name) +#else + #define JSON_HEDLEY_ARRAY_PARAM(name) +#endif + +#if defined(JSON_HEDLEY_IS_CONSTANT) + #undef JSON_HEDLEY_IS_CONSTANT +#endif +#if defined(JSON_HEDLEY_REQUIRE_CONSTEXPR) + #undef JSON_HEDLEY_REQUIRE_CONSTEXPR +#endif +/* JSON_HEDLEY_IS_CONSTEXPR_ is for + HEDLEY INTERNAL USE ONLY. API subject to change without notice. */ +#if defined(JSON_HEDLEY_IS_CONSTEXPR_) + #undef JSON_HEDLEY_IS_CONSTEXPR_ +#endif +#if \ + JSON_HEDLEY_HAS_BUILTIN(__builtin_constant_p) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,19) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \ + (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) && !defined(__cplusplus)) || \ + JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_IS_CONSTANT(expr) __builtin_constant_p(expr) +#endif +#if !defined(__cplusplus) +# if \ + JSON_HEDLEY_HAS_BUILTIN(__builtin_types_compatible_p) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \ + JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \ + JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,24) +#if defined(__INTPTR_TYPE__) + #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0)), int*) +#else + #include + #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((intptr_t) ((expr) * 0)) : (int*) 0)), int*) +#endif +# elif \ + ( \ + defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) && \ + !defined(JSON_HEDLEY_SUNPRO_VERSION) && \ + !defined(JSON_HEDLEY_PGI_VERSION) && \ + !defined(JSON_HEDLEY_IAR_VERSION)) || \ + (JSON_HEDLEY_HAS_EXTENSION(c_generic_selections) && !defined(JSON_HEDLEY_IAR_VERSION)) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(5,3,0) +#if defined(__INTPTR_TYPE__) + #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0), int*: 1, void*: 0) +#else + #include + #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((intptr_t) * 0) : (int*) 0), int*: 1, void*: 0) +#endif +# elif \ + defined(JSON_HEDLEY_GCC_VERSION) || \ + defined(JSON_HEDLEY_INTEL_VERSION) || \ + defined(JSON_HEDLEY_TINYC_VERSION) || \ + defined(JSON_HEDLEY_TI_ARMCL_VERSION) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(18,12,0) || \ + defined(JSON_HEDLEY_TI_CL2000_VERSION) || \ + defined(JSON_HEDLEY_TI_CL6X_VERSION) || \ + defined(JSON_HEDLEY_TI_CL7X_VERSION) || \ + defined(JSON_HEDLEY_TI_CLPRU_VERSION) || \ + defined(__clang__) +# define JSON_HEDLEY_IS_CONSTEXPR_(expr) ( \ + sizeof(void) != \ + sizeof(*( \ + 1 ? \ + ((void*) ((expr) * 0L) ) : \ +((struct { char v[sizeof(void) * 2]; } *) 1) \ + ) \ + ) \ + ) +# endif +#endif +#if defined(JSON_HEDLEY_IS_CONSTEXPR_) + #if !defined(JSON_HEDLEY_IS_CONSTANT) + #define JSON_HEDLEY_IS_CONSTANT(expr) JSON_HEDLEY_IS_CONSTEXPR_(expr) + #endif + #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (JSON_HEDLEY_IS_CONSTEXPR_(expr) ? (expr) : (-1)) +#else + #if !defined(JSON_HEDLEY_IS_CONSTANT) + #define JSON_HEDLEY_IS_CONSTANT(expr) (0) + #endif + #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (expr) +#endif + +#if defined(JSON_HEDLEY_BEGIN_C_DECLS) + #undef JSON_HEDLEY_BEGIN_C_DECLS +#endif +#if defined(JSON_HEDLEY_END_C_DECLS) + #undef JSON_HEDLEY_END_C_DECLS +#endif +#if defined(JSON_HEDLEY_C_DECL) + #undef JSON_HEDLEY_C_DECL +#endif +#if defined(__cplusplus) + #define JSON_HEDLEY_BEGIN_C_DECLS extern "C" { + #define JSON_HEDLEY_END_C_DECLS } + #define JSON_HEDLEY_C_DECL extern "C" +#else + #define JSON_HEDLEY_BEGIN_C_DECLS + #define JSON_HEDLEY_END_C_DECLS + #define JSON_HEDLEY_C_DECL +#endif + +#if defined(JSON_HEDLEY_STATIC_ASSERT) + #undef JSON_HEDLEY_STATIC_ASSERT +#endif +#if \ + !defined(__cplusplus) && ( \ + (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)) || \ + (JSON_HEDLEY_HAS_FEATURE(c_static_assert) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(6,0,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + defined(_Static_assert) \ + ) +# define JSON_HEDLEY_STATIC_ASSERT(expr, message) _Static_assert(expr, message) +#elif \ + (defined(__cplusplus) && (__cplusplus >= 201103L)) || \ + JSON_HEDLEY_MSVC_VERSION_CHECK(16,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) +# define JSON_HEDLEY_STATIC_ASSERT(expr, message) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(static_assert(expr, message)) +#else +# define JSON_HEDLEY_STATIC_ASSERT(expr, message) +#endif + +#if defined(JSON_HEDLEY_NULL) + #undef JSON_HEDLEY_NULL +#endif +#if defined(__cplusplus) + #if __cplusplus >= 201103L + #define JSON_HEDLEY_NULL JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(nullptr) + #elif defined(NULL) + #define JSON_HEDLEY_NULL NULL + #else + #define JSON_HEDLEY_NULL JSON_HEDLEY_STATIC_CAST(void*, 0) + #endif +#elif defined(NULL) + #define JSON_HEDLEY_NULL NULL +#else + #define JSON_HEDLEY_NULL ((void*) 0) +#endif + +#if defined(JSON_HEDLEY_MESSAGE) + #undef JSON_HEDLEY_MESSAGE +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas") +# define JSON_HEDLEY_MESSAGE(msg) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \ + JSON_HEDLEY_PRAGMA(message msg) \ + JSON_HEDLEY_DIAGNOSTIC_POP +#elif \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,4,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) +# define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message msg) +#elif JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0) +# define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(_CRI message msg) +#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) +# define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg)) +#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,0,0) +# define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg)) +#else +# define JSON_HEDLEY_MESSAGE(msg) +#endif + +#if defined(JSON_HEDLEY_WARNING) + #undef JSON_HEDLEY_WARNING +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas") +# define JSON_HEDLEY_WARNING(msg) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \ + JSON_HEDLEY_PRAGMA(clang warning msg) \ + JSON_HEDLEY_DIAGNOSTIC_POP +#elif \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,8,0) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) +# define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(GCC warning msg) +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) +# define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(message(msg)) +#else +# define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_MESSAGE(msg) +#endif + +#if defined(JSON_HEDLEY_REQUIRE) + #undef JSON_HEDLEY_REQUIRE +#endif +#if defined(JSON_HEDLEY_REQUIRE_MSG) + #undef JSON_HEDLEY_REQUIRE_MSG +#endif +#if JSON_HEDLEY_HAS_ATTRIBUTE(diagnose_if) +# if JSON_HEDLEY_HAS_WARNING("-Wgcc-compat") +# define JSON_HEDLEY_REQUIRE(expr) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \ + __attribute__((diagnose_if(!(expr), #expr, "error"))) \ + JSON_HEDLEY_DIAGNOSTIC_POP +# define JSON_HEDLEY_REQUIRE_MSG(expr,msg) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \ + __attribute__((diagnose_if(!(expr), msg, "error"))) \ + JSON_HEDLEY_DIAGNOSTIC_POP +# else +# define JSON_HEDLEY_REQUIRE(expr) __attribute__((diagnose_if(!(expr), #expr, "error"))) +# define JSON_HEDLEY_REQUIRE_MSG(expr,msg) __attribute__((diagnose_if(!(expr), msg, "error"))) +# endif +#else +# define JSON_HEDLEY_REQUIRE(expr) +# define JSON_HEDLEY_REQUIRE_MSG(expr,msg) +#endif + +#if defined(JSON_HEDLEY_FLAGS) + #undef JSON_HEDLEY_FLAGS +#endif +#if JSON_HEDLEY_HAS_ATTRIBUTE(flag_enum) && (!defined(__cplusplus) || JSON_HEDLEY_HAS_WARNING("-Wbitfield-enum-conversion")) + #define JSON_HEDLEY_FLAGS __attribute__((__flag_enum__)) +#else + #define JSON_HEDLEY_FLAGS +#endif + +#if defined(JSON_HEDLEY_FLAGS_CAST) + #undef JSON_HEDLEY_FLAGS_CAST +#endif +#if JSON_HEDLEY_INTEL_VERSION_CHECK(19,0,0) +# define JSON_HEDLEY_FLAGS_CAST(T, expr) (__extension__ ({ \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("warning(disable:188)") \ + ((T) (expr)); \ + JSON_HEDLEY_DIAGNOSTIC_POP \ + })) +#else +# define JSON_HEDLEY_FLAGS_CAST(T, expr) JSON_HEDLEY_STATIC_CAST(T, expr) +#endif + +#if defined(JSON_HEDLEY_EMPTY_BASES) + #undef JSON_HEDLEY_EMPTY_BASES +#endif +#if \ + (JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,23918) && !JSON_HEDLEY_MSVC_VERSION_CHECK(20,0,0)) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_EMPTY_BASES __declspec(empty_bases) +#else + #define JSON_HEDLEY_EMPTY_BASES +#endif + +/* Remaining macros are deprecated. */ + +#if defined(JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK) + #undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK +#endif +#if defined(__clang__) + #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) (0) +#else + #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_CLANG_HAS_ATTRIBUTE) + #undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE +#endif +#define JSON_HEDLEY_CLANG_HAS_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_ATTRIBUTE(attribute) + +#if defined(JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE) + #undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE +#endif +#define JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) + +#if defined(JSON_HEDLEY_CLANG_HAS_BUILTIN) + #undef JSON_HEDLEY_CLANG_HAS_BUILTIN +#endif +#define JSON_HEDLEY_CLANG_HAS_BUILTIN(builtin) JSON_HEDLEY_HAS_BUILTIN(builtin) + +#if defined(JSON_HEDLEY_CLANG_HAS_FEATURE) + #undef JSON_HEDLEY_CLANG_HAS_FEATURE +#endif +#define JSON_HEDLEY_CLANG_HAS_FEATURE(feature) JSON_HEDLEY_HAS_FEATURE(feature) + +#if defined(JSON_HEDLEY_CLANG_HAS_EXTENSION) + #undef JSON_HEDLEY_CLANG_HAS_EXTENSION +#endif +#define JSON_HEDLEY_CLANG_HAS_EXTENSION(extension) JSON_HEDLEY_HAS_EXTENSION(extension) + +#if defined(JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE) + #undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE +#endif +#define JSON_HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) + +#if defined(JSON_HEDLEY_CLANG_HAS_WARNING) + #undef JSON_HEDLEY_CLANG_HAS_WARNING +#endif +#define JSON_HEDLEY_CLANG_HAS_WARNING(warning) JSON_HEDLEY_HAS_WARNING(warning) + +#endif /* !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < X) */ + + +// This file contains all internal macro definitions (except those affecting ABI) +// You MUST include macro_unscope.hpp at the end of json.hpp to undef all of them + +// #include + + +// exclude unsupported compilers +#if !defined(JSON_SKIP_UNSUPPORTED_COMPILER_CHECK) + #if defined(__clang__) + #if (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__) < 30400 + #error "unsupported Clang version - see https://github.com/nlohmann/json#supported-compilers" + #endif + #elif defined(__GNUC__) && !(defined(__ICC) || defined(__INTEL_COMPILER)) + #if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) < 40800 + #error "unsupported GCC version - see https://github.com/nlohmann/json#supported-compilers" + #endif + #endif +#endif + +// C++ language standard detection +// if the user manually specified the used c++ version this is skipped +#if !defined(JSON_HAS_CPP_23) && !defined(JSON_HAS_CPP_20) && !defined(JSON_HAS_CPP_17) && !defined(JSON_HAS_CPP_14) && !defined(JSON_HAS_CPP_11) + #if (defined(__cplusplus) && __cplusplus > 202002L) || (defined(_MSVC_LANG) && _MSVC_LANG > 202002L) + #define JSON_HAS_CPP_23 + #define JSON_HAS_CPP_20 + #define JSON_HAS_CPP_17 + #define JSON_HAS_CPP_14 + #elif (defined(__cplusplus) && __cplusplus > 201703L) || (defined(_MSVC_LANG) && _MSVC_LANG > 201703L) + #define JSON_HAS_CPP_20 + #define JSON_HAS_CPP_17 + #define JSON_HAS_CPP_14 + #elif (defined(__cplusplus) && __cplusplus > 201402L) || (defined(_HAS_CXX17) && _HAS_CXX17 == 1) // fix for issue #464 + #define JSON_HAS_CPP_17 + #define JSON_HAS_CPP_14 + #elif (defined(__cplusplus) && __cplusplus > 201103L) || (defined(_HAS_CXX14) && _HAS_CXX14 == 1) + #define JSON_HAS_CPP_14 + #endif + // the cpp 11 flag is always specified because it is the minimal required version + #define JSON_HAS_CPP_11 +#endif + +#ifdef __has_include + #if __has_include() + #include + #endif +#endif + +#if !defined(JSON_HAS_FILESYSTEM) && !defined(JSON_HAS_EXPERIMENTAL_FILESYSTEM) + #ifdef JSON_HAS_CPP_17 + #if defined(__cpp_lib_filesystem) + #define JSON_HAS_FILESYSTEM 1 + #elif defined(__cpp_lib_experimental_filesystem) + #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1 + #elif !defined(__has_include) + #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1 + #elif __has_include() + #define JSON_HAS_FILESYSTEM 1 + #elif __has_include() + #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1 + #endif + + // std::filesystem does not work on MinGW GCC 8: https://sourceforge.net/p/mingw-w64/bugs/737/ + #if defined(__MINGW32__) && defined(__GNUC__) && __GNUC__ == 8 + #undef JSON_HAS_FILESYSTEM + #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #endif + + // no filesystem support before GCC 8: https://en.cppreference.com/w/cpp/compiler_support + #if defined(__GNUC__) && !defined(__clang__) && __GNUC__ < 8 + #undef JSON_HAS_FILESYSTEM + #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #endif + + // no filesystem support before Clang 7: https://en.cppreference.com/w/cpp/compiler_support + #if defined(__clang_major__) && __clang_major__ < 7 + #undef JSON_HAS_FILESYSTEM + #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #endif + + // no filesystem support before MSVC 19.14: https://en.cppreference.com/w/cpp/compiler_support + #if defined(_MSC_VER) && _MSC_VER < 1914 + #undef JSON_HAS_FILESYSTEM + #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #endif + + // no filesystem support before iOS 13 + #if defined(__IPHONE_OS_VERSION_MIN_REQUIRED) && __IPHONE_OS_VERSION_MIN_REQUIRED < 130000 + #undef JSON_HAS_FILESYSTEM + #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #endif + + // no filesystem support before macOS Catalina + #if defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && __MAC_OS_X_VERSION_MIN_REQUIRED < 101500 + #undef JSON_HAS_FILESYSTEM + #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #endif + #endif +#endif + +#ifndef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 0 +#endif + +#ifndef JSON_HAS_FILESYSTEM + #define JSON_HAS_FILESYSTEM 0 +#endif + +#ifndef JSON_HAS_THREE_WAY_COMPARISON + #if defined(__cpp_impl_three_way_comparison) && __cpp_impl_three_way_comparison >= 201907L \ + && defined(__cpp_lib_three_way_comparison) && __cpp_lib_three_way_comparison >= 201907L + #define JSON_HAS_THREE_WAY_COMPARISON 1 + #else + #define JSON_HAS_THREE_WAY_COMPARISON 0 + #endif +#endif + +#ifndef JSON_HAS_RANGES + // ranges header shipping in GCC 11.1.0 (released 2021-04-27) has syntax error + #if defined(__GLIBCXX__) && __GLIBCXX__ == 20210427 + #define JSON_HAS_RANGES 0 + #elif defined(__cpp_lib_ranges) + #define JSON_HAS_RANGES 1 + #else + #define JSON_HAS_RANGES 0 + #endif +#endif + +#ifndef JSON_HAS_STATIC_RTTI + #if !defined(_HAS_STATIC_RTTI) || _HAS_STATIC_RTTI != 0 + #define JSON_HAS_STATIC_RTTI 1 + #else + #define JSON_HAS_STATIC_RTTI 0 + #endif +#endif + +#ifdef JSON_HAS_CPP_17 + #define JSON_INLINE_VARIABLE inline +#else + #define JSON_INLINE_VARIABLE +#endif + +#if JSON_HEDLEY_HAS_ATTRIBUTE(no_unique_address) + #define JSON_NO_UNIQUE_ADDRESS [[no_unique_address]] +#else + #define JSON_NO_UNIQUE_ADDRESS +#endif + +// disable documentation warnings on clang +#if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wdocumentation" + #pragma clang diagnostic ignored "-Wdocumentation-unknown-command" +#endif + +// allow disabling exceptions +#if (defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND)) && !defined(JSON_NOEXCEPTION) + #define JSON_THROW(exception) throw exception + #define JSON_TRY try + #define JSON_CATCH(exception) catch(exception) + #define JSON_INTERNAL_CATCH(exception) catch(exception) +#else + #include + #define JSON_THROW(exception) std::abort() + #define JSON_TRY if(true) + #define JSON_CATCH(exception) if(false) + #define JSON_INTERNAL_CATCH(exception) if(false) +#endif + +// override exception macros +#if defined(JSON_THROW_USER) + #undef JSON_THROW + #define JSON_THROW JSON_THROW_USER +#endif +#if defined(JSON_TRY_USER) + #undef JSON_TRY + #define JSON_TRY JSON_TRY_USER +#endif +#if defined(JSON_CATCH_USER) + #undef JSON_CATCH + #define JSON_CATCH JSON_CATCH_USER + #undef JSON_INTERNAL_CATCH + #define JSON_INTERNAL_CATCH JSON_CATCH_USER +#endif +#if defined(JSON_INTERNAL_CATCH_USER) + #undef JSON_INTERNAL_CATCH + #define JSON_INTERNAL_CATCH JSON_INTERNAL_CATCH_USER +#endif + +// allow overriding assert +#if !defined(JSON_ASSERT) + #include // assert + #define JSON_ASSERT(x) assert(x) +#endif + +// allow to access some private functions (needed by the test suite) +#if defined(JSON_TESTS_PRIVATE) + #define JSON_PRIVATE_UNLESS_TESTED public +#else + #define JSON_PRIVATE_UNLESS_TESTED private +#endif + +/*! +@brief macro to briefly define a mapping between an enum and JSON +@def NLOHMANN_JSON_SERIALIZE_ENUM +@since version 3.4.0 +*/ +#define NLOHMANN_JSON_SERIALIZE_ENUM(ENUM_TYPE, ...) \ + template \ + inline void to_json(BasicJsonType& j, const ENUM_TYPE& e) \ + { \ + /* NOLINTNEXTLINE(modernize-type-traits) we use C++11 */ \ + static_assert(std::is_enum::value, #ENUM_TYPE " must be an enum!"); \ + /* NOLINTNEXTLINE(modernize-avoid-c-arrays) we don't want to depend on */ \ + static const std::pair m[] = __VA_ARGS__; \ + auto it = std::find_if(std::begin(m), std::end(m), \ + [e](const std::pair& ej_pair) -> bool \ + { \ + return ej_pair.first == e; \ + }); \ + j = ((it != std::end(m)) ? it : std::begin(m))->second; \ + } \ + template \ + inline void from_json(const BasicJsonType& j, ENUM_TYPE& e) \ + { \ + /* NOLINTNEXTLINE(modernize-type-traits) we use C++11 */ \ + static_assert(std::is_enum::value, #ENUM_TYPE " must be an enum!"); \ + /* NOLINTNEXTLINE(modernize-avoid-c-arrays) we don't want to depend on */ \ + static const std::pair m[] = __VA_ARGS__; \ + auto it = std::find_if(std::begin(m), std::end(m), \ + [&j](const std::pair& ej_pair) -> bool \ + { \ + return ej_pair.second == j; \ + }); \ + e = ((it != std::end(m)) ? it : std::begin(m))->first; \ + } + +// Ugly macros to avoid uglier copy-paste when specializing basic_json. They +// may be removed in the future once the class is split. + +#define NLOHMANN_BASIC_JSON_TPL_DECLARATION \ + template class ObjectType, \ + template class ArrayType, \ + class StringType, class BooleanType, class NumberIntegerType, \ + class NumberUnsignedType, class NumberFloatType, \ + template class AllocatorType, \ + template class JSONSerializer, \ + class BinaryType, \ + class CustomBaseClass> + +#define NLOHMANN_BASIC_JSON_TPL \ + basic_json + +// Macros to simplify conversion from/to types + +#define NLOHMANN_JSON_EXPAND( x ) x +#define NLOHMANN_JSON_GET_MACRO(_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, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, NAME,...) NAME +#define NLOHMANN_JSON_PASTE(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_GET_MACRO(__VA_ARGS__, \ + NLOHMANN_JSON_PASTE64, \ + NLOHMANN_JSON_PASTE63, \ + NLOHMANN_JSON_PASTE62, \ + NLOHMANN_JSON_PASTE61, \ + NLOHMANN_JSON_PASTE60, \ + NLOHMANN_JSON_PASTE59, \ + NLOHMANN_JSON_PASTE58, \ + NLOHMANN_JSON_PASTE57, \ + NLOHMANN_JSON_PASTE56, \ + NLOHMANN_JSON_PASTE55, \ + NLOHMANN_JSON_PASTE54, \ + NLOHMANN_JSON_PASTE53, \ + NLOHMANN_JSON_PASTE52, \ + NLOHMANN_JSON_PASTE51, \ + NLOHMANN_JSON_PASTE50, \ + NLOHMANN_JSON_PASTE49, \ + NLOHMANN_JSON_PASTE48, \ + NLOHMANN_JSON_PASTE47, \ + NLOHMANN_JSON_PASTE46, \ + NLOHMANN_JSON_PASTE45, \ + NLOHMANN_JSON_PASTE44, \ + NLOHMANN_JSON_PASTE43, \ + NLOHMANN_JSON_PASTE42, \ + NLOHMANN_JSON_PASTE41, \ + NLOHMANN_JSON_PASTE40, \ + NLOHMANN_JSON_PASTE39, \ + NLOHMANN_JSON_PASTE38, \ + NLOHMANN_JSON_PASTE37, \ + NLOHMANN_JSON_PASTE36, \ + NLOHMANN_JSON_PASTE35, \ + NLOHMANN_JSON_PASTE34, \ + NLOHMANN_JSON_PASTE33, \ + NLOHMANN_JSON_PASTE32, \ + NLOHMANN_JSON_PASTE31, \ + NLOHMANN_JSON_PASTE30, \ + NLOHMANN_JSON_PASTE29, \ + NLOHMANN_JSON_PASTE28, \ + NLOHMANN_JSON_PASTE27, \ + NLOHMANN_JSON_PASTE26, \ + NLOHMANN_JSON_PASTE25, \ + NLOHMANN_JSON_PASTE24, \ + NLOHMANN_JSON_PASTE23, \ + NLOHMANN_JSON_PASTE22, \ + NLOHMANN_JSON_PASTE21, \ + NLOHMANN_JSON_PASTE20, \ + NLOHMANN_JSON_PASTE19, \ + NLOHMANN_JSON_PASTE18, \ + NLOHMANN_JSON_PASTE17, \ + NLOHMANN_JSON_PASTE16, \ + NLOHMANN_JSON_PASTE15, \ + NLOHMANN_JSON_PASTE14, \ + NLOHMANN_JSON_PASTE13, \ + NLOHMANN_JSON_PASTE12, \ + NLOHMANN_JSON_PASTE11, \ + NLOHMANN_JSON_PASTE10, \ + NLOHMANN_JSON_PASTE9, \ + NLOHMANN_JSON_PASTE8, \ + NLOHMANN_JSON_PASTE7, \ + NLOHMANN_JSON_PASTE6, \ + NLOHMANN_JSON_PASTE5, \ + NLOHMANN_JSON_PASTE4, \ + NLOHMANN_JSON_PASTE3, \ + NLOHMANN_JSON_PASTE2, \ + NLOHMANN_JSON_PASTE1)(__VA_ARGS__)) +#define NLOHMANN_JSON_PASTE2(func, v1) func(v1) +#define NLOHMANN_JSON_PASTE3(func, v1, v2) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE2(func, v2) +#define NLOHMANN_JSON_PASTE4(func, v1, v2, v3) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE3(func, v2, v3) +#define NLOHMANN_JSON_PASTE5(func, v1, v2, v3, v4) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE4(func, v2, v3, v4) +#define NLOHMANN_JSON_PASTE6(func, v1, v2, v3, v4, v5) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE5(func, v2, v3, v4, v5) +#define NLOHMANN_JSON_PASTE7(func, v1, v2, v3, v4, v5, v6) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE6(func, v2, v3, v4, v5, v6) +#define NLOHMANN_JSON_PASTE8(func, v1, v2, v3, v4, v5, v6, v7) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE7(func, v2, v3, v4, v5, v6, v7) +#define NLOHMANN_JSON_PASTE9(func, v1, v2, v3, v4, v5, v6, v7, v8) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE8(func, v2, v3, v4, v5, v6, v7, v8) +#define NLOHMANN_JSON_PASTE10(func, v1, v2, v3, v4, v5, v6, v7, v8, v9) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE9(func, v2, v3, v4, v5, v6, v7, v8, v9) +#define NLOHMANN_JSON_PASTE11(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE10(func, v2, v3, v4, v5, v6, v7, v8, v9, v10) +#define NLOHMANN_JSON_PASTE12(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE11(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) +#define NLOHMANN_JSON_PASTE13(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE12(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12) +#define NLOHMANN_JSON_PASTE14(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE13(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13) +#define NLOHMANN_JSON_PASTE15(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE14(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14) +#define NLOHMANN_JSON_PASTE16(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE15(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15) +#define NLOHMANN_JSON_PASTE17(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE16(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16) +#define NLOHMANN_JSON_PASTE18(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE17(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17) +#define NLOHMANN_JSON_PASTE19(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE18(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18) +#define NLOHMANN_JSON_PASTE20(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE19(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19) +#define NLOHMANN_JSON_PASTE21(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE20(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20) +#define NLOHMANN_JSON_PASTE22(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE21(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21) +#define NLOHMANN_JSON_PASTE23(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE22(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22) +#define NLOHMANN_JSON_PASTE24(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE23(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23) +#define NLOHMANN_JSON_PASTE25(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE24(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24) +#define NLOHMANN_JSON_PASTE26(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE25(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25) +#define NLOHMANN_JSON_PASTE27(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE26(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26) +#define NLOHMANN_JSON_PASTE28(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE27(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27) +#define NLOHMANN_JSON_PASTE29(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE28(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28) +#define NLOHMANN_JSON_PASTE30(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE29(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29) +#define NLOHMANN_JSON_PASTE31(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE30(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30) +#define NLOHMANN_JSON_PASTE32(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE31(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31) +#define NLOHMANN_JSON_PASTE33(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE32(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32) +#define NLOHMANN_JSON_PASTE34(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE33(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33) +#define NLOHMANN_JSON_PASTE35(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE34(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34) +#define NLOHMANN_JSON_PASTE36(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE35(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35) +#define NLOHMANN_JSON_PASTE37(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE36(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36) +#define NLOHMANN_JSON_PASTE38(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE37(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37) +#define NLOHMANN_JSON_PASTE39(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE38(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38) +#define NLOHMANN_JSON_PASTE40(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE39(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39) +#define NLOHMANN_JSON_PASTE41(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE40(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40) +#define NLOHMANN_JSON_PASTE42(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE41(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41) +#define NLOHMANN_JSON_PASTE43(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE42(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42) +#define NLOHMANN_JSON_PASTE44(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE43(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43) +#define NLOHMANN_JSON_PASTE45(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE44(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44) +#define NLOHMANN_JSON_PASTE46(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE45(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45) +#define NLOHMANN_JSON_PASTE47(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE46(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46) +#define NLOHMANN_JSON_PASTE48(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE47(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47) +#define NLOHMANN_JSON_PASTE49(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE48(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48) +#define NLOHMANN_JSON_PASTE50(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE49(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49) +#define NLOHMANN_JSON_PASTE51(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE50(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50) +#define NLOHMANN_JSON_PASTE52(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE51(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51) +#define NLOHMANN_JSON_PASTE53(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE52(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52) +#define NLOHMANN_JSON_PASTE54(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE53(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53) +#define NLOHMANN_JSON_PASTE55(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE54(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54) +#define NLOHMANN_JSON_PASTE56(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE55(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55) +#define NLOHMANN_JSON_PASTE57(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE56(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56) +#define NLOHMANN_JSON_PASTE58(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE57(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57) +#define NLOHMANN_JSON_PASTE59(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE58(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58) +#define NLOHMANN_JSON_PASTE60(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE59(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59) +#define NLOHMANN_JSON_PASTE61(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE60(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60) +#define NLOHMANN_JSON_PASTE62(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE61(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61) +#define NLOHMANN_JSON_PASTE63(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE62(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62) +#define NLOHMANN_JSON_PASTE64(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE63(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63) + +#define NLOHMANN_JSON_TO(v1) nlohmann_json_j[#v1] = nlohmann_json_t.v1; +#define NLOHMANN_JSON_FROM(v1) nlohmann_json_j.at(#v1).get_to(nlohmann_json_t.v1); +#define NLOHMANN_JSON_FROM_WITH_DEFAULT(v1) nlohmann_json_t.v1 = !nlohmann_json_j.is_null() ? nlohmann_json_j.value(#v1, nlohmann_json_default_obj.v1) : nlohmann_json_default_obj.v1; + +/*! +@brief macro +@def NLOHMANN_DEFINE_TYPE_INTRUSIVE +@since version 3.9.0 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_intrusive/ +*/ +#define NLOHMANN_DEFINE_TYPE_INTRUSIVE(Type, ...) \ + template::value, int> = 0> \ + friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ + template::value, int> = 0> \ + friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT +@since version 3.11.0 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_intrusive/ +*/ +#define NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(Type, ...) \ + template::value, int> = 0> \ + friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ + template::value, int> = 0> \ + friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE +@since version 3.11.3 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_intrusive/ +*/ +#define NLOHMANN_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE(Type, ...) \ + template::value, int> = 0> \ + friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE +@since version 3.9.0 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_non_intrusive/ +*/ +#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(Type, ...) \ + template::value, int> = 0> \ + void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ + template::value, int> = 0> \ + void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT +@since version 3.11.0 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_non_intrusive/ +*/ +#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT(Type, ...) \ + template::value, int> = 0> \ + void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ + template::value, int> = 0> \ + void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE +@since version 3.11.3 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_non_intrusive/ +*/ +#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE(Type, ...) \ + template::value, int> = 0> \ + void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE +@since version 3.12.0 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/ +*/ +#define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE(Type, BaseType, ...) \ + template::value, int> = 0> \ + friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ + template::value, int> = 0> \ + friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_DEFAULT +@since version 3.12.0 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/ +*/ +#define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_DEFAULT(Type, BaseType, ...) \ + template::value, int> = 0> \ + friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ + template::value, int> = 0> \ + friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast(nlohmann_json_t)); const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_ONLY_SERIALIZE +@since version 3.12.0 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/ +*/ +#define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_ONLY_SERIALIZE(Type, BaseType, ...) \ + template::value, int> = 0> \ + friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE +@since version 3.12.0 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/ +*/ +#define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE(Type, BaseType, ...) \ + template::value, int> = 0> \ + void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ + template::value, int> = 0> \ + void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_DEFAULT +@since version 3.12.0 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/ +*/ +#define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_DEFAULT(Type, BaseType, ...) \ + template::value, int> = 0> \ + void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ + template::value, int> = 0> \ + void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast(nlohmann_json_t)); const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE +@since version 3.12.0 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/ +*/ +#define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE(Type, BaseType, ...) \ + template::value, int> = 0> \ + void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } + +// inspired from https://stackoverflow.com/a/26745591 +// allows calling any std function as if (e.g., with begin): +// using std::begin; begin(x); +// +// it allows using the detected idiom to retrieve the return type +// of such an expression +#define NLOHMANN_CAN_CALL_STD_FUNC_IMPL(std_name) \ + namespace detail { \ + using std::std_name; \ + \ + template \ + using result_of_##std_name = decltype(std_name(std::declval()...)); \ + } \ + \ + namespace detail2 { \ + struct std_name##_tag \ + { \ + }; \ + \ + template \ + std_name##_tag std_name(T&&...); \ + \ + template \ + using result_of_##std_name = decltype(std_name(std::declval()...)); \ + \ + template \ + struct would_call_std_##std_name \ + { \ + static constexpr auto const value = ::nlohmann::detail:: \ + is_detected_exact::value; \ + }; \ + } /* namespace detail2 */ \ + \ + template \ + struct would_call_std_##std_name : detail2::would_call_std_##std_name \ + { \ + } + +#ifndef JSON_USE_IMPLICIT_CONVERSIONS + #define JSON_USE_IMPLICIT_CONVERSIONS 1 +#endif + +#if JSON_USE_IMPLICIT_CONVERSIONS + #define JSON_EXPLICIT +#else + #define JSON_EXPLICIT explicit +#endif + +#ifndef JSON_DISABLE_ENUM_SERIALIZATION + #define JSON_DISABLE_ENUM_SERIALIZATION 0 +#endif + +#ifndef JSON_USE_GLOBAL_UDLS + #define JSON_USE_GLOBAL_UDLS 1 +#endif + +#if JSON_HAS_THREE_WAY_COMPARISON + #include // partial_ordering +#endif + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +/////////////////////////// +// JSON type enumeration // +/////////////////////////// + +/*! +@brief the JSON type enumeration + +This enumeration collects the different JSON types. It is internally used to +distinguish the stored values, and the functions @ref basic_json::is_null(), +@ref basic_json::is_object(), @ref basic_json::is_array(), +@ref basic_json::is_string(), @ref basic_json::is_boolean(), +@ref basic_json::is_number() (with @ref basic_json::is_number_integer(), +@ref basic_json::is_number_unsigned(), and @ref basic_json::is_number_float()), +@ref basic_json::is_discarded(), @ref basic_json::is_primitive(), and +@ref basic_json::is_structured() rely on it. + +@note There are three enumeration entries (number_integer, number_unsigned, and +number_float), because the library distinguishes these three types for numbers: +@ref basic_json::number_unsigned_t is used for unsigned integers, +@ref basic_json::number_integer_t is used for signed integers, and +@ref basic_json::number_float_t is used for floating-point numbers or to +approximate integers which do not fit in the limits of their respective type. + +@sa see @ref basic_json::basic_json(const value_t value_type) -- create a JSON +value with the default value for a given type + +@since version 1.0.0 +*/ +enum class value_t : std::uint8_t +{ + null, ///< null value + object, ///< object (unordered set of name/value pairs) + array, ///< array (ordered collection of values) + string, ///< string value + boolean, ///< boolean value + number_integer, ///< number value (signed integer) + number_unsigned, ///< number value (unsigned integer) + number_float, ///< number value (floating-point) + binary, ///< binary array (ordered collection of bytes) + discarded ///< discarded by the parser callback function +}; + +/*! +@brief comparison operator for JSON types + +Returns an ordering that is similar to Python: +- order: null < boolean < number < object < array < string < binary +- furthermore, each type is not smaller than itself +- discarded values are not comparable +- binary is represented as a b"" string in python and directly comparable to a + string; however, making a binary array directly comparable with a string would + be surprising behavior in a JSON file. + +@since version 1.0.0 +*/ +#if JSON_HAS_THREE_WAY_COMPARISON + inline std::partial_ordering operator<=>(const value_t lhs, const value_t rhs) noexcept // *NOPAD* +#else + inline bool operator<(const value_t lhs, const value_t rhs) noexcept +#endif +{ + static constexpr std::array order = {{ + 0 /* null */, 3 /* object */, 4 /* array */, 5 /* string */, + 1 /* boolean */, 2 /* integer */, 2 /* unsigned */, 2 /* float */, + 6 /* binary */ + } + }; + + const auto l_index = static_cast(lhs); + const auto r_index = static_cast(rhs); +#if JSON_HAS_THREE_WAY_COMPARISON + if (l_index < order.size() && r_index < order.size()) + { + return order[l_index] <=> order[r_index]; // *NOPAD* + } + return std::partial_ordering::unordered; +#else + return l_index < order.size() && r_index < order.size() && order[l_index] < order[r_index]; +#endif +} + +// GCC selects the built-in operator< over an operator rewritten from +// a user-defined spaceship operator +// Clang, MSVC, and ICC select the rewritten candidate +// (see GCC bug https://gcc.gnu.org/bugzilla/show_bug.cgi?id=105200) +#if JSON_HAS_THREE_WAY_COMPARISON && defined(__GNUC__) +inline bool operator<(const value_t lhs, const value_t rhs) noexcept +{ + return std::is_lt(lhs <=> rhs); // *NOPAD* +} +#endif + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +// #include + + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +/*! +@brief replace all occurrences of a substring by another string + +@param[in,out] s the string to manipulate; changed so that all + occurrences of @a f are replaced with @a t +@param[in] f the substring to replace with @a t +@param[in] t the string to replace @a f + +@pre The search string @a f must not be empty. **This precondition is +enforced with an assertion.** + +@since version 2.0.0 +*/ +template +inline void replace_substring(StringType& s, const StringType& f, + const StringType& t) +{ + JSON_ASSERT(!f.empty()); + for (auto pos = s.find(f); // find first occurrence of f + pos != StringType::npos; // make sure f was found + s.replace(pos, f.size(), t), // replace with t, and + pos = s.find(f, pos + t.size())) // find next occurrence of f + {} +} + +/*! + * @brief string escaping as described in RFC 6901 (Sect. 4) + * @param[in] s string to escape + * @return escaped string + * + * Note the order of escaping "~" to "~0" and "/" to "~1" is important. + */ +template +inline StringType escape(StringType s) +{ + replace_substring(s, StringType{"~"}, StringType{"~0"}); + replace_substring(s, StringType{"/"}, StringType{"~1"}); + return s; +} + +/*! + * @brief string unescaping as described in RFC 6901 (Sect. 4) + * @param[in] s string to unescape + * @return unescaped string + * + * Note the order of escaping "~1" to "/" and "~0" to "~" is important. + */ +template +static void unescape(StringType& s) +{ + replace_substring(s, StringType{"~1"}, StringType{"/"}); + replace_substring(s, StringType{"~0"}, StringType{"~"}); +} + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // size_t + +// #include + + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +/// struct to capture the start position of the current token +struct position_t +{ + /// the total number of characters read + std::size_t chars_read_total = 0; + /// the number of characters read in the current line + std::size_t chars_read_current_line = 0; + /// the number of lines read + std::size_t lines_read = 0; + + /// conversion to size_t to preserve SAX interface + constexpr operator size_t() const + { + return chars_read_total; + } +}; + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END + +// #include + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-FileCopyrightText: 2018 The Abseil Authors +// SPDX-License-Identifier: MIT + + + +#include // array +#include // size_t +#include // conditional, enable_if, false_type, integral_constant, is_constructible, is_integral, is_same, remove_cv, remove_reference, true_type +#include // index_sequence, make_index_sequence, index_sequence_for + +// #include + + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +template +using uncvref_t = typename std::remove_cv::type>::type; + +#ifdef JSON_HAS_CPP_14 + +// the following utilities are natively available in C++14 +using std::enable_if_t; +using std::index_sequence; +using std::make_index_sequence; +using std::index_sequence_for; + +#else + +// alias templates to reduce boilerplate +template +using enable_if_t = typename std::enable_if::type; + +// The following code is taken from https://github.com/abseil/abseil-cpp/blob/10cb35e459f5ecca5b2ff107635da0bfa41011b4/absl/utility/utility.h +// which is part of Google Abseil (https://github.com/abseil/abseil-cpp), licensed under the Apache License 2.0. + +//// START OF CODE FROM GOOGLE ABSEIL + +// integer_sequence +// +// Class template representing a compile-time integer sequence. An instantiation +// of `integer_sequence` has a sequence of integers encoded in its +// type through its template arguments (which is a common need when +// working with C++11 variadic templates). `absl::integer_sequence` is designed +// to be a drop-in replacement for C++14's `std::integer_sequence`. +// +// Example: +// +// template< class T, T... Ints > +// void user_function(integer_sequence); +// +// int main() +// { +// // user_function's `T` will be deduced to `int` and `Ints...` +// // will be deduced to `0, 1, 2, 3, 4`. +// user_function(make_integer_sequence()); +// } +template +struct integer_sequence +{ + using value_type = T; + static constexpr std::size_t size() noexcept + { + return sizeof...(Ints); + } +}; + +// index_sequence +// +// A helper template for an `integer_sequence` of `size_t`, +// `absl::index_sequence` is designed to be a drop-in replacement for C++14's +// `std::index_sequence`. +template +using index_sequence = integer_sequence; + +namespace utility_internal +{ + +template +struct Extend; + +// Note that SeqSize == sizeof...(Ints). It's passed explicitly for efficiency. +template +struct Extend, SeqSize, 0> +{ + using type = integer_sequence < T, Ints..., (Ints + SeqSize)... >; +}; + +template +struct Extend, SeqSize, 1> +{ + using type = integer_sequence < T, Ints..., (Ints + SeqSize)..., 2 * SeqSize >; +}; + +// Recursion helper for 'make_integer_sequence'. +// 'Gen::type' is an alias for 'integer_sequence'. +template +struct Gen +{ + using type = + typename Extend < typename Gen < T, N / 2 >::type, N / 2, N % 2 >::type; +}; + +template +struct Gen +{ + using type = integer_sequence; +}; + +} // namespace utility_internal + +// Compile-time sequences of integers + +// make_integer_sequence +// +// This template alias is equivalent to +// `integer_sequence`, and is designed to be a drop-in +// replacement for C++14's `std::make_integer_sequence`. +template +using make_integer_sequence = typename utility_internal::Gen::type; + +// make_index_sequence +// +// This template alias is equivalent to `index_sequence<0, 1, ..., N-1>`, +// and is designed to be a drop-in replacement for C++14's +// `std::make_index_sequence`. +template +using make_index_sequence = make_integer_sequence; + +// index_sequence_for +// +// Converts a typename pack into an index sequence of the same length, and +// is designed to be a drop-in replacement for C++14's +// `std::index_sequence_for()` +template +using index_sequence_for = make_index_sequence; + +//// END OF CODE FROM GOOGLE ABSEIL + +#endif + +// dispatch utility (taken from ranges-v3) +template struct priority_tag : priority_tag < N - 1 > {}; +template<> struct priority_tag<0> {}; + +// taken from ranges-v3 +template +struct static_const +{ + static JSON_INLINE_VARIABLE constexpr T value{}; +}; + +#ifndef JSON_HAS_CPP_17 + template + constexpr T static_const::value; +#endif + +template +constexpr std::array make_array(Args&& ... args) +{ + return std::array {{static_cast(std::forward(args))...}}; +} + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // numeric_limits +#include // char_traits +#include // tuple +#include // false_type, is_constructible, is_integral, is_same, true_type +#include // declval + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // random_access_iterator_tag + +// #include + +// #include + +// #include + + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +template +struct iterator_types {}; + +template +struct iterator_types < + It, + void_t> +{ + using difference_type = typename It::difference_type; + using value_type = typename It::value_type; + using pointer = typename It::pointer; + using reference = typename It::reference; + using iterator_category = typename It::iterator_category; +}; + +// This is required as some compilers implement std::iterator_traits in a way that +// doesn't work with SFINAE. See https://github.com/nlohmann/json/issues/1341. +template +struct iterator_traits +{ +}; + +template +struct iterator_traits < T, enable_if_t < !std::is_pointer::value >> + : iterator_types +{ +}; + +template +struct iterator_traits::value>> +{ + using iterator_category = std::random_access_iterator_tag; + using value_type = T; + using difference_type = ptrdiff_t; + using pointer = T*; + using reference = T&; +}; + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END + +// #include + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +// #include + + +NLOHMANN_JSON_NAMESPACE_BEGIN + +NLOHMANN_CAN_CALL_STD_FUNC_IMPL(begin); + +NLOHMANN_JSON_NAMESPACE_END + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +// #include + + +NLOHMANN_JSON_NAMESPACE_BEGIN + +NLOHMANN_CAN_CALL_STD_FUNC_IMPL(end); + +NLOHMANN_JSON_NAMESPACE_END + +// #include + +// #include + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + +#ifndef INCLUDE_NLOHMANN_JSON_FWD_HPP_ + #define INCLUDE_NLOHMANN_JSON_FWD_HPP_ + + #include // int64_t, uint64_t + #include // map + #include // allocator + #include // string + #include // vector + + // #include + + + /*! + @brief namespace for Niels Lohmann + @see https://github.com/nlohmann + @since version 1.0.0 + */ + NLOHMANN_JSON_NAMESPACE_BEGIN + + /*! + @brief default JSONSerializer template argument + + This serializer ignores the template arguments and uses ADL + ([argument-dependent lookup](https://en.cppreference.com/w/cpp/language/adl)) + for serialization. + */ + template + struct adl_serializer; + + /// a class to store JSON values + /// @sa https://json.nlohmann.me/api/basic_json/ + template class ObjectType = + std::map, + template class ArrayType = std::vector, + class StringType = std::string, class BooleanType = bool, + class NumberIntegerType = std::int64_t, + class NumberUnsignedType = std::uint64_t, + class NumberFloatType = double, + template class AllocatorType = std::allocator, + template class JSONSerializer = + adl_serializer, + class BinaryType = std::vector, // cppcheck-suppress syntaxError + class CustomBaseClass = void> + class basic_json; + + /// @brief JSON Pointer defines a string syntax for identifying a specific value within a JSON document + /// @sa https://json.nlohmann.me/api/json_pointer/ + template + class json_pointer; + + /*! + @brief default specialization + @sa https://json.nlohmann.me/api/json/ + */ + using json = basic_json<>; + + /// @brief a minimal map-like container that preserves insertion order + /// @sa https://json.nlohmann.me/api/ordered_map/ + template + struct ordered_map; + + /// @brief specialization that maintains the insertion order of object keys + /// @sa https://json.nlohmann.me/api/ordered_json/ + using ordered_json = basic_json; + + NLOHMANN_JSON_NAMESPACE_END + +#endif // INCLUDE_NLOHMANN_JSON_FWD_HPP_ + + +NLOHMANN_JSON_NAMESPACE_BEGIN +/*! +@brief detail namespace with internal helper functions + +This namespace collects functions that should not be exposed, +implementations of some @ref basic_json methods, and meta-programming helpers. + +@since version 2.1.0 +*/ +namespace detail +{ + +///////////// +// helpers // +///////////// + +// Note to maintainers: +// +// Every trait in this file expects a non CV-qualified type. +// The only exceptions are in the 'aliases for detected' section +// (i.e. those of the form: decltype(T::member_function(std::declval()))) +// +// In this case, T has to be properly CV-qualified to constraint the function arguments +// (e.g. to_json(BasicJsonType&, const T&)) + +template struct is_basic_json : std::false_type {}; + +NLOHMANN_BASIC_JSON_TPL_DECLARATION +struct is_basic_json : std::true_type {}; + +// used by exceptions create() member functions +// true_type for pointer to possibly cv-qualified basic_json or std::nullptr_t +// false_type otherwise +template +struct is_basic_json_context : + std::integral_constant < bool, + is_basic_json::type>::type>::value + || std::is_same::value > +{}; + +////////////////////// +// json_ref helpers // +////////////////////// + +template +class json_ref; + +template +struct is_json_ref : std::false_type {}; + +template +struct is_json_ref> : std::true_type {}; + +////////////////////////// +// aliases for detected // +////////////////////////// + +template +using mapped_type_t = typename T::mapped_type; + +template +using key_type_t = typename T::key_type; + +template +using value_type_t = typename T::value_type; + +template +using difference_type_t = typename T::difference_type; + +template +using pointer_t = typename T::pointer; + +template +using reference_t = typename T::reference; + +template +using iterator_category_t = typename T::iterator_category; + +template +using to_json_function = decltype(T::to_json(std::declval()...)); + +template +using from_json_function = decltype(T::from_json(std::declval()...)); + +template +using get_template_function = decltype(std::declval().template get()); + +// trait checking if JSONSerializer::from_json(json const&, udt&) exists +template +struct has_from_json : std::false_type {}; + +// trait checking if j.get is valid +// use this trait instead of std::is_constructible or std::is_convertible, +// both rely on, or make use of implicit conversions, and thus fail when T +// has several constructors/operator= (see https://github.com/nlohmann/json/issues/958) +template +struct is_getable +{ + static constexpr bool value = is_detected::value; +}; + +template +struct has_from_json < BasicJsonType, T, enable_if_t < !is_basic_json::value >> +{ + using serializer = typename BasicJsonType::template json_serializer; + + static constexpr bool value = + is_detected_exact::value; +}; + +// This trait checks if JSONSerializer::from_json(json const&) exists +// this overload is used for non-default-constructible user-defined-types +template +struct has_non_default_from_json : std::false_type {}; + +template +struct has_non_default_from_json < BasicJsonType, T, enable_if_t < !is_basic_json::value >> +{ + using serializer = typename BasicJsonType::template json_serializer; + + static constexpr bool value = + is_detected_exact::value; +}; + +// This trait checks if BasicJsonType::json_serializer::to_json exists +// Do not evaluate the trait when T is a basic_json type, to avoid template instantiation infinite recursion. +template +struct has_to_json : std::false_type {}; + +template +struct has_to_json < BasicJsonType, T, enable_if_t < !is_basic_json::value >> +{ + using serializer = typename BasicJsonType::template json_serializer; + + static constexpr bool value = + is_detected_exact::value; +}; + +template +using detect_key_compare = typename T::key_compare; + +template +struct has_key_compare : std::integral_constant::value> {}; + +// obtains the actual object key comparator +template +struct actual_object_comparator +{ + using object_t = typename BasicJsonType::object_t; + using object_comparator_t = typename BasicJsonType::default_object_comparator_t; + using type = typename std::conditional < has_key_compare::value, + typename object_t::key_compare, object_comparator_t>::type; +}; + +template +using actual_object_comparator_t = typename actual_object_comparator::type; + +///////////////// +// char_traits // +///////////////// + +// Primary template of char_traits calls std char_traits +template +struct char_traits : std::char_traits +{}; + +// Explicitly define char traits for unsigned char since it is not standard +template<> +struct char_traits : std::char_traits +{ + using char_type = unsigned char; + using int_type = uint64_t; + + // Redefine to_int_type function + static int_type to_int_type(char_type c) noexcept + { + return static_cast(c); + } + + static char_type to_char_type(int_type i) noexcept + { + return static_cast(i); + } + + static constexpr int_type eof() noexcept + { + return static_cast(std::char_traits::eof()); + } +}; + +// Explicitly define char traits for signed char since it is not standard +template<> +struct char_traits : std::char_traits +{ + using char_type = signed char; + using int_type = uint64_t; + + // Redefine to_int_type function + static int_type to_int_type(char_type c) noexcept + { + return static_cast(c); + } + + static char_type to_char_type(int_type i) noexcept + { + return static_cast(i); + } + + static constexpr int_type eof() noexcept + { + return static_cast(std::char_traits::eof()); + } +}; + +/////////////////// +// is_ functions // +/////////////////// + +// https://en.cppreference.com/w/cpp/types/conjunction +template struct conjunction : std::true_type { }; +template struct conjunction : B { }; +template +struct conjunction +: std::conditional(B::value), conjunction, B>::type {}; + +// https://en.cppreference.com/w/cpp/types/negation +template struct negation : std::integral_constant < bool, !B::value > { }; + +// Reimplementation of is_constructible and is_default_constructible, due to them being broken for +// std::pair and std::tuple until LWG 2367 fix (see https://cplusplus.github.io/LWG/lwg-defects.html#2367). +// This causes compile errors in e.g. clang 3.5 or gcc 4.9. +template +struct is_default_constructible : std::is_default_constructible {}; + +template +struct is_default_constructible> + : conjunction, is_default_constructible> {}; + +template +struct is_default_constructible> + : conjunction, is_default_constructible> {}; + +template +struct is_default_constructible> + : conjunction...> {}; + +template +struct is_default_constructible> + : conjunction...> {}; + +template +struct is_constructible : std::is_constructible {}; + +template +struct is_constructible> : is_default_constructible> {}; + +template +struct is_constructible> : is_default_constructible> {}; + +template +struct is_constructible> : is_default_constructible> {}; + +template +struct is_constructible> : is_default_constructible> {}; + +template +struct is_iterator_traits : std::false_type {}; + +template +struct is_iterator_traits> +{ + private: + using traits = iterator_traits; + + public: + static constexpr auto value = + is_detected::value && + is_detected::value && + is_detected::value && + is_detected::value && + is_detected::value; +}; + +template +struct is_range +{ + private: + using t_ref = typename std::add_lvalue_reference::type; + + using iterator = detected_t; + using sentinel = detected_t; + + // to be 100% correct, it should use https://en.cppreference.com/w/cpp/iterator/input_or_output_iterator + // and https://en.cppreference.com/w/cpp/iterator/sentinel_for + // but reimplementing these would be too much work, as a lot of other concepts are used underneath + static constexpr auto is_iterator_begin = + is_iterator_traits>::value; + + public: + static constexpr bool value = !std::is_same::value && !std::is_same::value && is_iterator_begin; +}; + +template +using iterator_t = enable_if_t::value, result_of_begin())>>; + +template +using range_value_t = value_type_t>>; + +// The following implementation of is_complete_type is taken from +// https://blogs.msdn.microsoft.com/vcblog/2015/12/02/partial-support-for-expression-sfinae-in-vs-2015-update-1/ +// and is written by Xiang Fan who agreed to using it in this library. + +template +struct is_complete_type : std::false_type {}; + +template +struct is_complete_type : std::true_type {}; + +template +struct is_compatible_object_type_impl : std::false_type {}; + +template +struct is_compatible_object_type_impl < + BasicJsonType, CompatibleObjectType, + enable_if_t < is_detected::value&& + is_detected::value >> +{ + using object_t = typename BasicJsonType::object_t; + + // macOS's is_constructible does not play well with nonesuch... + static constexpr bool value = + is_constructible::value && + is_constructible::value; +}; + +template +struct is_compatible_object_type + : is_compatible_object_type_impl {}; + +template +struct is_constructible_object_type_impl : std::false_type {}; + +template +struct is_constructible_object_type_impl < + BasicJsonType, ConstructibleObjectType, + enable_if_t < is_detected::value&& + is_detected::value >> +{ + using object_t = typename BasicJsonType::object_t; + + static constexpr bool value = + (is_default_constructible::value && + (std::is_move_assignable::value || + std::is_copy_assignable::value) && + (is_constructible::value && + std::is_same < + typename object_t::mapped_type, + typename ConstructibleObjectType::mapped_type >::value)) || + (has_from_json::value || + has_non_default_from_json < + BasicJsonType, + typename ConstructibleObjectType::mapped_type >::value); +}; + +template +struct is_constructible_object_type + : is_constructible_object_type_impl {}; + +template +struct is_compatible_string_type +{ + static constexpr auto value = + is_constructible::value; +}; + +template +struct is_constructible_string_type +{ + // launder type through decltype() to fix compilation failure on ICPC +#ifdef __INTEL_COMPILER + using laundered_type = decltype(std::declval()); +#else + using laundered_type = ConstructibleStringType; +#endif + + static constexpr auto value = + conjunction < + is_constructible, + is_detected_exact>::value; +}; + +template +struct is_compatible_array_type_impl : std::false_type {}; + +template +struct is_compatible_array_type_impl < + BasicJsonType, CompatibleArrayType, + enable_if_t < + is_detected::value&& + is_iterator_traits>>::value&& +// special case for types like std::filesystem::path whose iterator's value_type are themselves +// c.f. https://github.com/nlohmann/json/pull/3073 + !std::is_same>::value >> +{ + static constexpr bool value = + is_constructible>::value; +}; + +template +struct is_compatible_array_type + : is_compatible_array_type_impl {}; + +template +struct is_constructible_array_type_impl : std::false_type {}; + +template +struct is_constructible_array_type_impl < + BasicJsonType, ConstructibleArrayType, + enable_if_t::value >> + : std::true_type {}; + +template +struct is_constructible_array_type_impl < + BasicJsonType, ConstructibleArrayType, + enable_if_t < !std::is_same::value&& + !is_compatible_string_type::value&& + is_default_constructible::value&& +(std::is_move_assignable::value || + std::is_copy_assignable::value)&& +is_detected::value&& +is_iterator_traits>>::value&& +is_detected::value&& +// special case for types like std::filesystem::path whose iterator's value_type are themselves +// c.f. https://github.com/nlohmann/json/pull/3073 +!std::is_same>::value&& +is_complete_type < +detected_t>::value >> +{ + using value_type = range_value_t; + + static constexpr bool value = + std::is_same::value || + has_from_json::value || + has_non_default_from_json < + BasicJsonType, + value_type >::value; +}; + +template +struct is_constructible_array_type + : is_constructible_array_type_impl {}; + +template +struct is_compatible_integer_type_impl : std::false_type {}; + +template +struct is_compatible_integer_type_impl < + RealIntegerType, CompatibleNumberIntegerType, + enable_if_t < std::is_integral::value&& + std::is_integral::value&& + !std::is_same::value >> +{ + // is there an assert somewhere on overflows? + using RealLimits = std::numeric_limits; + using CompatibleLimits = std::numeric_limits; + + static constexpr auto value = + is_constructible::value && + CompatibleLimits::is_integer && + RealLimits::is_signed == CompatibleLimits::is_signed; +}; + +template +struct is_compatible_integer_type + : is_compatible_integer_type_impl {}; + +template +struct is_compatible_type_impl: std::false_type {}; + +template +struct is_compatible_type_impl < + BasicJsonType, CompatibleType, + enable_if_t::value >> +{ + static constexpr bool value = + has_to_json::value; +}; + +template +struct is_compatible_type + : is_compatible_type_impl {}; + +template +struct is_constructible_tuple : std::false_type {}; + +template +struct is_constructible_tuple> : conjunction...> {}; + +template +struct is_json_iterator_of : std::false_type {}; + +template +struct is_json_iterator_of : std::true_type {}; + +template +struct is_json_iterator_of : std::true_type +{}; + +// checks if a given type T is a template specialization of Primary +template