Initial release: GCC-InvoiceMath-Verified v1

CONTRACT.md

@@ -0,0 +1,18 @@
+# Invoice math contract v1.0
+
+This is an explicit software-testing contract, not a national tax rulebook.
+
+The input is only `invoice` plus this contract. Do not feed expected labels, family, mutation or provenance to a model being evaluated. A challenge file strips these fields. `country` is research metadata; currency precision determines calculation.
+
+1. Currency precision: SAR/AED/QAR two decimals; KWD/BHD/OMR three. Precision facts checked against SIX on 2026-09-30. These are the benchmark's arithmetic precision, not a statement that every e-invoice standard permits that precision in every field.
+2. All quantities/prices/allowances/charges/rates are nonnegative; quantity > 0. Rate is an explicitly supplied fraction from 0 to 1; no jurisdiction-specific tax rate is inferred. Negative line net is forbidden.
+3. Line net = round-half-up(quantity × unit_price − allowance + charge, currency precision).
+4. Line tax = round-half-up(line net × rate, currency precision). Tax is rounded per line, NOT on an invoice group or subtotal. This choice is part of the synthetic contract and may differ from a real tax standard.
+5. Net = sum(line net). Tax = sum(line tax). Gross = net + tax. Due = gross − prepaid. Prepaid must be an exact nonnegative currency amount no greater than gross.
+6. Credit notes contain positive line magnitudes and zero prepaid. Negate the final net/tax/gross/due for credit notes. This sign convention is explicitly synthetic.
+7. Output all four canonical ASCII decimal strings with exactly currency precision. `valid` means all claimed totals exactly equal these strings numerically. `error_fields` lists mismatched claimed fields in net,tax,gross,due order. A wrong net claim does not cascade into the expected gross: recompute each from original lines.
+8. Numeric styles are ASCII with dot decimal, Arabic-Indic digits with U+066B decimal, and either with three-digit grouping (comma or U+066C). In grouped style the leading group is one to three digits and later groups exactly three. Minus is ASCII U+002D. No mixed digit alphabets, whitespace, bidi controls, exponent notation, currency symbols, or NaN/Infinity. These excluded parser cases are tested by controls, not claimed as coverage families in the dataset.
+9. Ten designed families cover ties, per-line rounding, allowance, charge, prepayment, credit note, large precision stress, zero rate, mixed rates and zero due. Large-value stress is intentionally unrealistic to reveal binary floating-point errors. It is not an estimate of GCC invoice values.
+10. Every positive/negative pair differs in one claimed total by one minor unit. Keep pairs together in splits. There are five parameter variations per currency/family, not 600 independent business processes. No dialect or natural-language authenticity claim.
+
+The benchmark excludes XML/UBL schemas, signing, QR codes, identification, real tax semantics, regulatory certification, OCR, exchange rates, and payment reconciliation.

HUMAN_REVIEW.md

@@ -0,0 +1,243 @@
+# GCC-InvoiceMath-Verified ? Human Review
+
+20 records: one valid/invalid causal pair per scenario family.
+
+## credit_note ? VALID
+
+- ID: `49987f1529eeaa412c4bce17d4828418`
+- Country: `SA`
+- Currency: `SAR`
+- Numeric style: `grouped_ascii`
+- Document type: `credit_note`
+- Claimed totals: `{"due": "-12,705.82", "gross": "-12,705.82", "net": "-12,100.78", "tax": "-605.04"}`
+- Expected totals: `{"due": "-12705.82", "gross": "-12705.82", "net": "-12100.78", "tax": "-605.04"}`
+- Error fields: `[]`
+- Mutation: `None`
+
+## credit_note ? INVALID
+
+- ID: `0003524017ef7c5c80b41d416d2a10b7`
+- Country: `SA`
+- Currency: `SAR`
+- Numeric style: `grouped_ascii`
+- Document type: `credit_note`
+- Claimed totals: `{"due": "-12,705.82", "gross": "-12,705.83", "net": "-12,100.78", "tax": "-605.04"}`
+- Expected totals: `{"due": "-12705.82", "gross": "-12705.82", "net": "-12100.78", "tax": "-605.04"}`
+- Error fields: `['gross']`
+- Mutation: `{'delta': '-0.01', 'path': 'claimed_totals.gross', 'single_change': True}`
+
+## line_allowance ? VALID
+
+- ID: `004f85327f26174a16ff7dfedce2ff94`
+- Country: `BH`
+- Currency: `BHD`
+- Numeric style: `grouped_ascii`
+- Document type: `invoice`
+- Claimed totals: `{"due": "6,857.355", "gross": "6,857.355", "net": "6,530.814", "tax": "326.541"}`
+- Expected totals: `{"due": "6857.355", "gross": "6857.355", "net": "6530.814", "tax": "326.541"}`
+- Error fields: `[]`
+- Mutation: `None`
+
+## line_allowance ? INVALID
+
+- ID: `fd6cae9a38995dce4682dad331d1d4a5`
+- Country: `BH`
+- Currency: `BHD`
+- Numeric style: `grouped_ascii`
+- Document type: `invoice`
+- Claimed totals: `{"due": "6,857.355", "gross": "6,857.356", "net": "6,530.814", "tax": "326.541"}`
+- Expected totals: `{"due": "6857.355", "gross": "6857.355", "net": "6530.814", "tax": "326.541"}`
+- Error fields: `['gross']`
+- Mutation: `{'delta': '0.001', 'path': 'claimed_totals.gross', 'single_change': True}`
+
+## half_up_tie ? VALID
+
+- ID: `fe08cf71b7d524ff2abd95c666c0a083`
+- Country: `KW`
+- Currency: `KWD`
+- Numeric style: `arabic_indic`
+- Document type: `invoice`
+- Claimed totals: `{"due": "٥٧٫٢٤٩", "gross": "٥٧٫٢٤٩", "net": "٥٧٫٢٤٩", "tax": "٠٫٠٠٠"}`
+- Expected totals: `{"due": "57.249", "gross": "57.249", "net": "57.249", "tax": "0.000"}`
+- Error fields: `[]`
+- Mutation: `None`
+
+## half_up_tie ? INVALID
+
+- ID: `00c2e11379c8ad046c4794f9a1260624`
+- Country: `KW`
+- Currency: `KWD`
+- Numeric style: `arabic_indic`
+- Document type: `invoice`
+- Claimed totals: `{"due": "٥٧٫٢٤٩", "gross": "٥٧٫٢٥٠", "net": "٥٧٫٢٤٩", "tax": "٠٫٠٠٠"}`
+- Expected totals: `{"due": "57.249", "gross": "57.249", "net": "57.249", "tax": "0.000"}`
+- Error fields: `['gross']`
+- Mutation: `{'delta': '0.001', 'path': 'claimed_totals.gross', 'single_change': True}`
+
+## zero_rate ? VALID
+
+- ID: `2286aa7531e4e9a0bec94612f368f487`
+- Country: `OM`
+- Currency: `OMR`
+- Numeric style: `arabic_indic`
+- Document type: `invoice`
+- Claimed totals: `{"due": "٨٥٧٩٫٥٨٠", "gross": "٨٥٧٩٫٥٨٠", "net": "٨٥٧٩٫٥٨٠", "tax": "٠٫٠٠٠"}`
+- Expected totals: `{"due": "8579.580", "gross": "8579.580", "net": "8579.580", "tax": "0.000"}`
+- Error fields: `[]`
+- Mutation: `None`
+
+## zero_rate ? INVALID
+
+- ID: `00f69c4694801cfc80a130d7a425257d`
+- Country: `OM`
+- Currency: `OMR`
+- Numeric style: `arabic_indic`
+- Document type: `invoice`
+- Claimed totals: `{"due": "٨٥٧٩٫٥٨٠", "gross": "٨٥٧٩٫٥٨٠", "net": "٨٥٧٩٫٥٧٩", "tax": "٠٫٠٠٠"}`
+- Expected totals: `{"due": "8579.580", "gross": "8579.580", "net": "8579.580", "tax": "0.000"}`
+- Error fields: `['net']`
+- Mutation: `{'delta': '-0.001', 'path': 'claimed_totals.net', 'single_change': True}`
+
+## line_charge ? VALID
+
+- ID: `0130cb39479fd2ac755060cd1abc72c0`
+- Country: `BH`
+- Currency: `BHD`
+- Numeric style: `ascii`
+- Document type: `invoice`
+- Claimed totals: `{"due": "4745.728", "gross": "4745.728", "net": "4519.741", "tax": "225.987"}`
+- Expected totals: `{"due": "4745.728", "gross": "4745.728", "net": "4519.741", "tax": "225.987"}`
+- Error fields: `[]`
+- Mutation: `None`
+
+## line_charge ? INVALID
+
+- ID: `07ec5263854f8430ec3c811c5de72958`
+- Country: `BH`
+- Currency: `BHD`
+- Numeric style: `ascii`
+- Document type: `invoice`
+- Claimed totals: `{"due": "4745.728", "gross": "4745.728", "net": "4519.740", "tax": "225.987"}`
+- Expected totals: `{"due": "4745.728", "gross": "4745.728", "net": "4519.741", "tax": "225.987"}`
+- Error fields: `['net']`
+- Mutation: `{'delta': '-0.001', 'path': 'claimed_totals.net', 'single_change': True}`
+
+## prepayment ? VALID
+
+- ID: `ca193fc827f9a3eb5c35683778d28468`
+- Country: `KW`
+- Currency: `KWD`
+- Numeric style: `grouped_ascii`
+- Document type: `invoice`
+- Claimed totals: `{"due": "4,274.217", "gross": "6,411.325", "net": "6,106.024", "tax": "305.301"}`
+- Expected totals: `{"due": "4274.217", "gross": "6411.325", "net": "6106.024", "tax": "305.301"}`
+- Error fields: `[]`
+- Mutation: `None`
+
+## prepayment ? INVALID
+
+- ID: `022eefb2ca21eb4bbb483574e70cf5c4`
+- Country: `KW`
+- Currency: `KWD`
+- Numeric style: `grouped_ascii`
+- Document type: `invoice`
+- Claimed totals: `{"due": "4,274.216", "gross": "6,411.325", "net": "6,106.024", "tax": "305.301"}`
+- Expected totals: `{"due": "4274.217", "gross": "6411.325", "net": "6106.024", "tax": "305.301"}`
+- Error fields: `['due']`
+- Mutation: `{'delta': '-0.001', 'path': 'claimed_totals.due', 'single_change': True}`
+
+## large_amount_stress ? VALID
+
+- ID: `03e77757e020511ca9c512d1311cc1dc`
+- Country: `SA`
+- Currency: `SAR`
+- Numeric style: `grouped_arabic_indic`
+- Document type: `invoice`
+- Claimed totals: `{"due": "٣١٥٬٠٠٠٬٠٠٠٬٣٠٧٬٧٤٨٫٤٨", "gross": "٣١٥٬٠٠٠٬٠٠٠٬٣٠٧٬٧٤٨٫٤٨", "net": "٣٠٠٬٠٠٠٬٠٠٠٬٢٩٣٬٠٩٣٫٧٩", "tax": "١٥٬٠٠٠٬٠٠٠٬٠١٤٬٦٥٤٫٦٩"}`
+- Expected totals: `{"due": "315000000307748.48", "gross": "315000000307748.48", "net": "300000000293093.79", "tax": "15000000014654.69"}`
+- Error fields: `[]`
+- Mutation: `None`
+
+## large_amount_stress ? INVALID
+
+- ID: `24cf4d80fcb10e941f3c7d23b1912ed1`
+- Country: `SA`
+- Currency: `SAR`
+- Numeric style: `grouped_arabic_indic`
+- Document type: `invoice`
+- Claimed totals: `{"due": "٣١٥٬٠٠٠٬٠٠٠٬٣٠٧٬٧٤٨٫٤٧", "gross": "٣١٥٬٠٠٠٬٠٠٠٬٣٠٧٬٧٤٨٫٤٨", "net": "٣٠٠٬٠٠٠٬٠٠٠٬٢٩٣٬٠٩٣٫٧٩", "tax": "١٥٬٠٠٠٬٠٠٠٬٠١٤٬٦٥٤٫٦٩"}`
+- Expected totals: `{"due": "315000000307748.48", "gross": "315000000307748.48", "net": "300000000293093.79", "tax": "15000000014654.69"}`
+- Error fields: `['due']`
+- Mutation: `{'delta': '-0.01', 'path': 'claimed_totals.due', 'single_change': True}`
+
+## mixed_rates ? VALID
+
+- ID: `d25bf4a9c67725dc25ad673dec7f3232`
+- Country: `QA`
+- Currency: `QAR`
+- Numeric style: `grouped_arabic_indic`
+- Document type: `invoice`
+- Claimed totals: `{"due": "١٦٬٤٩١٫٧٩", "gross": "١٦٬٤٩١٫٧٩", "net": "١٥٬٤٥٢٫٥٠", "tax": "١٬٠٣٩٫٢٩"}`
+- Expected totals: `{"due": "16491.79", "gross": "16491.79", "net": "15452.50", "tax": "1039.29"}`
+- Error fields: `[]`
+- Mutation: `None`
+
+## mixed_rates ? INVALID
+
+- ID: `07dda1861f8819aee9f865f816cf32a6`
+- Country: `QA`
+- Currency: `QAR`
+- Numeric style: `grouped_arabic_indic`
+- Document type: `invoice`
+- Claimed totals: `{"due": "١٦٬٤٩١٫٧٩", "gross": "١٦٬٤٩١٫٧٩", "net": "١٥٬٤٥٢٫٥٠", "tax": "١٬٠٣٩٫٢٨"}`
+- Expected totals: `{"due": "16491.79", "gross": "16491.79", "net": "15452.50", "tax": "1039.29"}`
+- Error fields: `['tax']`
+- Mutation: `{'delta': '-0.01', 'path': 'claimed_totals.tax', 'single_change': True}`
+
+## line_vs_document_rounding ? VALID
+
+- ID: `12875e71d71f196da9074dd3e6008464`
+- Country: `AE`
+- Currency: `AED`
+- Numeric style: `grouped_arabic_indic`
+- Document type: `invoice`
+- Claimed totals: `{"due": "٧٣٧٫٩٠", "gross": "٧٣٧٫٩٠", "net": "٧٣٧٫٩٠", "tax": "٠٫٠٠"}`
+- Expected totals: `{"due": "737.90", "gross": "737.90", "net": "737.90", "tax": "0.00"}`
+- Error fields: `[]`
+- Mutation: `None`
+
+## line_vs_document_rounding ? INVALID
+
+- ID: `08d461285f815185f887e2f5cc88f70f`
+- Country: `AE`
+- Currency: `AED`
+- Numeric style: `grouped_arabic_indic`
+- Document type: `invoice`
+- Claimed totals: `{"due": "٧٣٧٫٩٠", "gross": "٧٣٧٫٨٩", "net": "٧٣٧٫٩٠", "tax": "٠٫٠٠"}`
+- Expected totals: `{"due": "737.90", "gross": "737.90", "net": "737.90", "tax": "0.00"}`
+- Error fields: `['gross']`
+- Mutation: `{'delta': '-0.01', 'path': 'claimed_totals.gross', 'single_change': True}`
+
+## zero_due ? VALID
+
+- ID: `60936a42fb6a223197e3845e1f77bdb1`
+- Country: `KW`
+- Currency: `KWD`
+- Numeric style: `grouped_ascii`
+- Document type: `invoice`
+- Claimed totals: `{"due": "0.000", "gross": "10,201.088", "net": "9,715.322", "tax": "485.766"}`
+- Expected totals: `{"due": "0.000", "gross": "10201.088", "net": "9715.322", "tax": "485.766"}`
+- Error fields: `[]`
+- Mutation: `None`
+
+## zero_due ? INVALID
+
+- ID: `1179c373a5da4964be96f9104923bf2f`
+- Country: `KW`
+- Currency: `KWD`
+- Numeric style: `grouped_ascii`
+- Document type: `invoice`
+- Claimed totals: `{"due": "0.001", "gross": "10,201.088", "net": "9,715.322", "tax": "485.766"}`
+- Expected totals: `{"due": "0.000", "gross": "10201.088", "net": "9715.322", "tax": "485.766"}`
+- Error fields: `['due']`
+- Mutation: `{'delta': '0.001', 'path': 'claimed_totals.due', 'single_change': True}`

LICENSE

@@ -0,0 +1,17 @@
+MIT License
+Copyright (c) 2026 RegalFire
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software, dataset metadata, and associated documentation files (the
+"Software"), to deal in the Software without restriction, including without
+limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom
+the Software is furnished to do so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

QA_REPORT.md

@@ -0,0 +1,90 @@
+# GCC-InvoiceMath-Verified ? QA Report
+Release status
+PASS
+Summary
+Records: 600
+Pairs: 300
+Valid: 300
+Invalid: 300
+Independent validation result:
+600 / 600 PASS
+Coverage
+Countries:
+{
+  "SA": 100,
+  "AE": 100,
+  "BH": 100,
+  "KW": 100,
+  "OM": 100,
+  "QA": 100
+}
+Currencies:
+{
+  "SAR": 100,
+  "AED": 100,
+  "BHD": 100,
+  "KWD": 100,
+  "OMR": 100,
+  "QAR": 100
+}
+Families:
+{
+  "credit_note": 60,
+  "line_allowance": 60,
+  "half_up_tie": 60,
+  "zero_rate": 60,
+  "line_charge": 60,
+  "prepayment": 60,
+  "large_amount_stress": 60,
+  "mixed_rates": 60,
+  "line_vs_document_rounding": 60,
+  "zero_due": 60
+}
+Numeric styles:
+{
+  "grouped_ascii": 150,
+  "arabic_indic": 150,
+  "ascii": 150,
+  "grouped_arabic_indic": 150
+}
+Splits:
+{
+  "train": 360,
+  "validation": 120,
+  "test": 120
+}
+Error fields:
+{
+  "gross": 75,
+  "net": 75,
+  "tax": 76,
+  "due": 74
+}
+Oracle independence
+Generation:
+Python Decimal + ROUND_HALF_UP
+Validation:
+Python Fraction with independently implemented rational rounding
+The validator does not import the generator.
+Integrity checks
+PASS:
+- schema validation
+- unique record IDs
+- fingerprints
+- country/currency mapping
+- deterministic ground truth
+- pair integrity
+- split isolation
+- one valid + one invalid record per pair
+- one-field causal mutations
+- one-minor-unit mutation magnitude
+- semantic source duplicate detection
+- synthetic provenance
+Human review status
+Representative samples should be manually inspected before public release.
+Automated validation does not constitute regulatory, accounting, or tax certification.
+Classification
+Technical quality: STRONG
+Commercial demand: unconfirmed
+Recommended release purpose:
+public benchmark + lead generation for custom ERP/e-invoicing synthetic datasets.

README.md

@@ -0,0 +1,199 @@
+---
+license: mit
+task_categories:
+- tabular-classification
+tags:
+- synthetic-data
+- gcc
+- invoices
+- ecommerce
+- erp
+- fintech
+- testing
+- data-quality
+- arabic
+- benchmark
+pretty_name: GCC-InvoiceMath-Verified
+size_categories:
+- n<1K
+---
+
+# GCC-InvoiceMath-Verified
+
+A deterministic synthetic benchmark for testing invoice arithmetic, numeric parsing, rounding, and claimed-total validation across six GCC currencies.
+
+## Overview
+
+GCC-InvoiceMath-Verified contains **600 records / 300 causal pairs**.
+
+Each pair contains:
+
+- one mathematically correct invoice
+- one counterfactual invoice where exactly one claimed total differs by one minor currency unit
+
+The dataset is intended for:
+
+- ERP QA
+- e-invoicing integration testing
+- financial software regression testing
+- structured-output validation
+- numerical reasoning evaluation
+- synthetic data benchmarking
+
+This benchmark is **not a tax-law compliance benchmark**.
+
+It does not certify compliance with ZATCA, UAE e-invoicing rules, PINT, UBL, or any national tax regulation.
+
+## Countries and currencies
+
+| Country | Currency | Records |
+|---|---|---:|
+| Saudi Arabia | SAR | 100 |
+| United Arab Emirates | AED | 100 |
+| Qatar | QAR | 100 |
+| Kuwait | KWD | 100 |
+| Bahrain | BHD | 100 |
+| Oman | OMR | 100 |
+
+SAR, AED and QAR use two benchmark fractional digits.
+
+KWD, BHD and OMR use three benchmark fractional digits.
+
+## Scenario families
+
+The benchmark contains 10 deterministic scenario families:
+
+1. `half_up_tie`
+2. `line_vs_document_rounding`
+3. `line_allowance`
+4. `line_charge`
+5. `prepayment`
+6. `credit_note`
+7. `large_amount_stress`
+8. `zero_rate`
+9. `mixed_rates`
+10. `zero_due`
+
+Each family contains **60 records**.
+
+## Numeric rendering
+
+Four rendering styles are equally represented:
+
+- ASCII
+- grouped ASCII
+- Arabic-Indic digits
+- grouped Arabic-Indic digits
+
+Each style contains **150 records**.
+
+This makes it possible to test parsers handling both Western and Arabic-Indic numeric representations.
+
+## Dataset structure
+
+Important fields include:
+
+```json
+{
+  "id": "...",
+  "pair_id": "...",
+  "split": "train",
+  "country": "SA",
+  "family": "half_up_tie",
+  "contract_id": "gcc-invoice-math-1.0",
+  "invoice": {
+    "currency": "SAR",
+    "document_type": "invoice",
+    "numeric_style": "arabic_indic",
+    "lines": [],
+    "prepaid": "...",
+    "claimed_totals": {}
+  },
+  "expected": {
+    "valid": true,
+    "totals": {},
+    "error_fields": []
+  },
+  "mutation": null,
+  "fingerprint_sha256": "..."
+}
+Ground truth
+Ground truth is generated procedurally using Python Decimal arithmetic with explicit ROUND_HALF_UP behavior.
+Validation is performed independently using fractions.Fraction.
+The validator does not import generator code.
+This provides two different arithmetic implementations:
+- generator oracle: Decimal
+- validation oracle: rational arithmetic
+Validation results
+- Records generated: 600
+- Records validated: 600
+- Pass rate: 100%
+- Valid examples: 300
+- Invalid examples: 300
+- Unique causal pairs: 300
+The release also checks:
+- JSON Schema compliance
+- unique IDs
+- unique semantic source invoices
+- fingerprints
+- country/currency consistency
+- pair integrity
+- train/validation/test pair isolation
+- exactly one causal mutation per invalid record
+- exactly one minor-unit difference
+- generator/validator oracle agreement
+Splits
+- train: 360
+- validation: 120
+- test: 120
+Positive and negative members of a causal pair are always kept in the same split.
+Synthetic provenance
+All records are procedurally generated.
+- no real invoices
+- no PII
+- no copied commercial records
+- no real tax identifiers
+- no customer transaction data
+External sources were used only for background research and currency-precision verification.
+Important limitations
+This dataset does not cover:
+- XML / UBL validation
+- digital signatures
+- QR codes
+- live tax submission
+- regulatory certification
+- real tax IDs
+- OCR images
+- exchange rates
+- payment reconciliation
+- jurisdiction-specific VAT interpretation
+Tax rates used in the benchmark are synthetic testing parameters.
+Intended use
+Recommended uses:
+- unit tests
+- regression tests
+- ERP adapter QA
+- invoice parser evaluation
+- financial-agent evaluation
+- data-quality pipelines
+- numeric-reasoning benchmarks
+Commercial customization
+Need a private benchmark matching your ERP, invoice schema, accounting rules, API, or failure modes?
+Custom synthetic datasets can be generated with:
+- client-specific field mappings
+- custom currencies
+- custom rounding behavior
+- additional failure modes
+- private held-out regression suites
+- custom JSON / CSV / Parquet / SQL formats
+- validation scripts
+- QA reports
+The commercial value is in adapting the benchmark to a real system, not simply generating more generic rows.
+Reproducibility
+The generator is deterministic and seed-based.
+Default seed:
+20260930
+See generator.py and validator.py.
+License
+MIT License for the original benchmark code and synthetic fixtures.
+See LICENSE.

RELEASE_CHECKLIST.md

@@ -0,0 +1,18 @@
+# Release Checklist
+- [x] 600 records generated
+- [x] 600/600 independent validation PASS
+- [x] 300 causal pairs
+- [x] pair-safe splits
+- [x] unique IDs
+- [x] fingerprints verified
+- [x] schema validation
+- [x] provenance documented
+- [x] no PII
+- [x] no copied external records
+- [x] generator included
+- [x] validator included
+- [x] contract included
+- [x] stats included
+- [x] representative sample manually reviewed
+- [ ] Hugging Face repository published
+  

generator.py

@@ -0,0 +1,118 @@
+"""Original procedural invoice arithmetic fixtures. Python >=3.11, standard library."""
+from __future__ import annotations
+import argparse, copy, hashlib, json, random
+from decimal import Decimal, ROUND_HALF_UP, localcontext
+from pathlib import Path
+
+PROFILES = [('SA','SAR',2),('AE','AED',2),('QA','QAR',2),('KW','KWD',3),('BH','BHD',3),('OM','OMR',3)]
+FAMILIES = ['half_up_tie','line_vs_document_rounding','line_allowance','line_charge','prepayment','credit_note','large_amount_stress','zero_rate','mixed_rates','zero_due']
+STYLES = ['ascii','arabic_indic','grouped_ascii','grouped_arabic_indic']
+SOURCES = ['https://zatca.gov.sa/en/E-Invoicing/Introduction/LawsAndRegulations/Pages/default.aspx','https://mof.gov.ae/en/about-us/initiatives/einvoicing/','https://www.six-group.com/en/products-services/financial-information/market-reference-data/data-standards.html','https://arxiv.org/abs/2602.18776']
+
+def canonical(x): return json.dumps(x,sort_keys=True,separators=(',',':'),ensure_ascii=False)
+def digest(x): return hashlib.sha256(canonical(x).encode()).hexdigest()
+def fmt(x,scale): return format(x,f'.{scale}f')
+def render(s,style):
+    sign = ''
+    if s.startswith('-'):
+        sign = '-'
+        s = s[1:]
+
+    if 'grouped' in style:
+        whole, sep, frac = s.partition('.')
+        whole = f'{int(whole):,}'
+        s = whole + (sep + frac if sep else '')
+
+    s = sign + s
+
+    if 'arabic' in style:
+        trans = str.maketrans({
+            '0': chr(0x0660), '1': chr(0x0661), '2': chr(0x0662),
+            '3': chr(0x0663), '4': chr(0x0664), '5': chr(0x0665),
+            '6': chr(0x0666), '7': chr(0x0667), '8': chr(0x0668),
+            '9': chr(0x0669), '.': chr(0x066B), ',': chr(0x066C)
+        })
+        s = s.translate(trans)
+
+    return s
+
+
+def calculate(lines,prepaid,scale,credit=False):
+    """Generator oracle uses Decimal; validator must not import this function."""
+    step=Decimal(1).scaleb(-scale)
+    nets=[(l['quantity']*l['unit_price']-l['allowance']+l['charge']).quantize(step,rounding=ROUND_HALF_UP) for l in lines]
+    taxes=[(n*l['rate']).quantize(step,rounding=ROUND_HALF_UP) for n,l in zip(nets,lines)]
+    net=sum(nets,Decimal(0)); tax=sum(taxes,Decimal(0)); gross=net+tax
+    sign=-1 if credit else 1
+    return {k:fmt(v*sign,scale) for k,v in dict(net=net,tax=tax,gross=gross,due=gross-prepaid).items()}
+
+def make_pair(currency_index,family_index,variation,seed):
+    country,currency,scale=PROFILES[currency_index]
+    family=FAMILIES[family_index]
+    unit=Decimal(1).scaleb(-scale)
+    local_seed=seed+currency_index*100000+family_index*1000+variation
+    rng=random.Random(local_seed)
+    lines=[dict(quantity=Decimal(rng.randint(1,9)),unit_price=Decimal(rng.randint(100000,900000))/1000,allowance=Decimal(0),charge=Decimal(0),rate=Decimal('0.05')) for _ in range(rng.randint(2,5))]
+    if family in ('half_up_tie','line_vs_document_rounding'):
+        # Even minor-unit base distinguishes half-up from ties-to-even.
+        lines=[dict(quantity=Decimal(1),unit_price=Decimal(rng.randrange(10000,90000,2))*unit+unit/2,allowance=Decimal(0),charge=Decimal(0),rate=Decimal(0)) for _ in range(2 if family=='line_vs_document_rounding' else 1)]
+    if family=='line_allowance':
+        for l in lines: l['allowance']=Decimal(rng.randint(1,900))*unit
+    if family=='line_charge':
+        for l in lines: l['charge']=Decimal(rng.randint(1,900))*unit
+    if family=='large_amount_stress':
+        lines[0]['unit_price']=Decimal(10**14+rng.randint(100,99999))+Decimal(7)*unit
+    if family=='zero_rate':
+        for l in lines: l['rate']=Decimal(0)
+    if family=='mixed_rates':
+        for i,l in enumerate(lines): l['rate']=[Decimal(0),Decimal('.05'),Decimal('.15')][i%3]
+    prepaid=Decimal(0)
+    totals=calculate(lines,prepaid,scale,False)
+    if family=='prepayment': prepaid=(Decimal(totals['gross'])/3).quantize(unit,rounding=ROUND_HALF_UP)
+    if family=='zero_due': prepaid=Decimal(totals['gross'])
+    totals=calculate(lines,prepaid,scale,family=='credit_note')
+    style=STYLES[(currency_index*50+family_index*5+variation)%4]
+    invoice=dict(currency=currency,document_type='credit_note' if family=='credit_note' else 'invoice',numeric_style=style,
+        lines=[{k:render(fmt(v,scale+3 if k=='unit_price' else scale if k in ('allowance','charge') else 2),style) for k,v in l.items()} for l in lines],
+        prepaid=render(fmt(prepaid,scale),style))
+    pair_id=digest(invoice)[:24]
+    split='train' if variation<3 else 'validation' if variation==3 else 'test'
+    field=['net','tax','gross','due'][(currency_index+family_index+variation)%4]
+    # Signed, one-minor-unit mutation. Both directions occur within each slice.
+    bad=copy.deepcopy(totals)
+    delta=unit * (-1 if (currency_index+variation)%2 else 1)
+    bad[field]=fmt(Decimal(bad[field])+delta,scale)
+    pair=[]
+    for claimed,valid in [(totals,True),(bad,False)]:
+        candidate=copy.deepcopy(invoice)
+        candidate['claimed_totals']={k:render(v,style) for k,v in claimed.items()}
+        record=dict(id=digest(candidate)[:32],pair_id=pair_id,seed=local_seed,split=split,country=country,family=family,
+            contract_id='gcc-invoice-math-1.0',invoice=candidate,
+            expected=dict(valid=valid,totals=totals,error_fields=[] if valid else [field]),
+            provenance=dict(synthetic=True,external_sources_used_for_research=SOURCES,copied_records=0,generation_method='procedural Decimal oracle plus single claimed-total perturbation',license_reviewed=True,license_review_scope='Original code and fixtures; no external records/code reused. Not a legal opinion.',model=None),
+            mutation=None if valid else dict(
+                path='claimed_totals.'+field,
+                delta=fmt(
+                    Decimal(claimed[field]) - Decimal(totals[field]),
+                    scale
+                ),
+                single_change=True
+            ))
+        record['fingerprint_sha256']=digest(record)
+        pair.append(record)
+    return pair
+
+def generate(seed=20260930,variations=5):
+    if variations!=5: raise ValueError('v1 pilot is fixed at five parameter variants per currency/family; custom scaling requires new QA')
+    with localcontext() as ctx:
+        ctx.prec=50
+        rows=[r for c in range(6) for f in range(10) for v in range(variations) for r in make_pair(c,f,v,seed)]
+    return sorted(rows,key=lambda x:x['id'])
+
+def write_jsonl(path,rows):
+    Path(path).write_text(''.join(canonical(r)+'\n' for r in rows),encoding='utf-8',newline='\n')
+
+if __name__=='__main__':
+    p=argparse.ArgumentParser(); p.add_argument('--output',type=Path,required=True); p.add_argument('--seed',type=int,default=20260930)
+    a=p.parse_args(); a.output.parent.mkdir(parents=True,exist_ok=True); rows=generate(a.seed); write_jsonl(a.output,rows)
+    print(json.dumps(dict(records=len(rows),sha256=hashlib.sha256(a.output.read_bytes()).hexdigest())))

manifest.json

@@ -0,0 +1,50 @@
+{
+  "CONTRACT.md": {
+    "bytes": 2983,
+    "sha256": "24fc032fd1e662ac2ed0f9872c7db6b30eba395e683add1104f8fdaf6dfac0cc"
+  },
+  "gcc_invoice_math_verified.jsonl": {
+    "bytes": 985994,
+    "sha256": "c5fa3a9c0ccc1604660c30d3da81ca61594e338992e2a91edbad80a9593afdb9"
+  },
+  "generator.py": {
+    "bytes": 6911,
+    "sha256": "78f380e898ad65760f49f3a75eaa53dcd5837c7e429691f386a0fcf983d19456"
+  },
+  "HUMAN_REVIEW.md": {
+    "bytes": 9658,
+    "sha256": "d77b5600cd8869b1a25d4fccbc74a5dd6532bc1fc320c6d43dd21fbbca156692"
+  },
+  "LICENSE": {
+    "bytes": 1098,
+    "sha256": "689ec9660a76757dfac03df5b89e5ff8bd8251b484c30aafe9439e35b8211f07"
+  },
+  "QA_REPORT.md": {
+    "bytes": 1827,
+    "sha256": "49c012b6a98403a2b0c4587d087849e0f21e12f7f77abbb0d80f9728ff128cc2"
+  },
+  "README.md": {
+    "bytes": 5176,
+    "sha256": "27be7925d7b4e9401a150e149fde4c8f64e016f2e3dd0ab18e0b9ccf03857179"
+  },
+  "RELEASE_CHECKLIST.md": {
+    "bytes": 479,
+    "sha256": "eb2220a0ba284453264db4dafe86731c9bdc46c8064e5720f1aebb0c02d53d6a"
+  },
+  "sample.jsonl": {
+    "bytes": 207109,
+    "sha256": "8a8d20379bc4809d1ac5d7bdbc90c830b6593722ecd693b3db73387046a347e0"
+  },
+  "schema.json": {
+    "bytes": 3954,
+    "sha256": "1064be5d4d184f397fabc903f283419df521756627455205ee9d44ad1f3f6591"
+  },
+  "stats.json": {
+    "bytes": 924,
+    "sha256": "92740a0ab26ae3fb0c19163ccc3ba1aa55f50f7ae96cd59269d3b949a86e868a"
+  },
+  "validator.py": {
+    "bytes": 6733,
+    "sha256": "50f2b5b23f78cdc94b955871fda7f2c1c833b143907f208d5e3c77d6a6b6a38e"
+  }
+}

schema.json

@@ -0,0 +1,143 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "required": [
+    "id",
+    "pair_id",
+    "seed",
+    "split",
+    "country",
+    "family",
+    "contract_id",
+    "invoice",
+    "expected",
+    "provenance",
+    "mutation",
+    "fingerprint_sha256"
+  ],
+  "properties": {
+    "id": { "type": "string", "minLength": 32, "maxLength": 32 },
+    "pair_id": { "type": "string", "minLength": 24, "maxLength": 24 },
+    "seed": { "type": "integer" },
+    "split": { "enum": ["train", "validation", "test"] },
+    "country": { "enum": ["SA", "AE", "QA", "KW", "BH", "OM"] },
+    "family": {
+      "enum": [
+        "half_up_tie",
+        "line_vs_document_rounding",
+        "line_allowance",
+        "line_charge",
+        "prepayment",
+        "credit_note",
+        "large_amount_stress",
+        "zero_rate",
+        "mixed_rates",
+        "zero_due"
+      ]
+    },
+    "contract_id": { "const": "gcc-invoice-math-1.0" },
+    "invoice": {
+      "type": "object",
+      "required": [
+        "currency",
+        "document_type",
+        "numeric_style",
+        "lines",
+        "prepaid",
+        "claimed_totals"
+      ],
+      "properties": {
+        "currency": { "enum": ["SAR", "AED", "QAR", "KWD", "BHD", "OMR"] },
+        "document_type": { "enum": ["invoice", "credit_note"] },
+        "numeric_style": {
+          "enum": [
+            "ascii",
+            "arabic_indic",
+            "grouped_ascii",
+            "grouped_arabic_indic"
+          ]
+        },
+        "lines": {
+          "type": "array",
+          "minItems": 1,
+          "items": {
+            "type": "object",
+            "required": ["quantity", "unit_price", "allowance", "charge", "rate"],
+            "properties": {
+              "quantity": { "type": "string" },
+              "unit_price": { "type": "string" },
+              "allowance": { "type": "string" },
+              "charge": { "type": "string" },
+              "rate": { "type": "string" }
+            },
+            "additionalProperties": false
+          }
+        },
+        "prepaid": { "type": "string" },
+        "claimed_totals": {
+          "type": "object",
+          "required": ["net", "tax", "gross", "due"],
+          "properties": {
+            "net": { "type": "string" },
+            "tax": { "type": "string" },
+            "gross": { "type": "string" },
+            "due": { "type": "string" }
+          },
+          "additionalProperties": false
+        }
+      },
+      "additionalProperties": false
+    },
+    "expected": {
+      "type": "object",
+      "required": ["valid", "totals", "error_fields"],
+      "properties": {
+        "valid": { "type": "boolean" },
+        "totals": {
+          "type": "object",
+          "required": ["net", "tax", "gross", "due"],
+          "properties": {
+            "net": { "type": "string" },
+            "tax": { "type": "string" },
+            "gross": { "type": "string" },
+            "due": { "type": "string" }
+          },
+          "additionalProperties": false
+        },
+        "error_fields": {
+          "type": "array",
+          "items": { "enum": ["net", "tax", "gross", "due"] }
+        }
+      },
+      "additionalProperties": false
+    },
+    "provenance": {
+      "type": "object",
+      "required": [
+        "synthetic",
+        "external_sources_used_for_research",
+        "copied_records",
+        "generation_method",
+        "license_reviewed",
+        "license_review_scope",
+        "model"
+      ]
+    },
+    "mutation": {
+      "anyOf": [
+        { "type": "null" },
+        {
+          "type": "object",
+          "required": ["path", "delta", "single_change"],
+          "properties": {
+            "path": { "type": "string" },
+            "delta": { "type": "string" },
+            "single_change": { "const": true }
+          }
+        }
+      ]
+    },
+    "fingerprint_sha256": { "type": "string", "minLength": 64, "maxLength": 64 }
+  },
+  "additionalProperties": false
+}

stats.json

@@ -0,0 +1,51 @@
+{
+  "records": 600,
+  "pairs": 300,
+  "valid_records": 300,
+  "invalid_records": 300,
+  "countries": {
+    "SA": 100,
+    "AE": 100,
+    "BH": 100,
+    "KW": 100,
+    "OM": 100,
+    "QA": 100
+  },
+  "currencies": {
+    "SAR": 100,
+    "AED": 100,
+    "BHD": 100,
+    "KWD": 100,
+    "OMR": 100,
+    "QAR": 100
+  },
+  "families": {
+    "credit_note": 60,
+    "line_allowance": 60,
+    "half_up_tie": 60,
+    "zero_rate": 60,
+    "line_charge": 60,
+    "prepayment": 60,
+    "large_amount_stress": 60,
+    "mixed_rates": 60,
+    "line_vs_document_rounding": 60,
+    "zero_due": 60
+  },
+  "splits": {
+    "train": 360,
+    "validation": 120,
+    "test": 120
+  },
+  "numeric_styles": {
+    "grouped_ascii": 150,
+    "arabic_indic": 150,
+    "ascii": 150,
+    "grouped_arabic_indic": 150
+  },
+  "error_fields": {
+    "gross": 75,
+    "net": 75,
+    "tax": 76,
+    "due": 74
+  }
+}

validator.py

@@ -0,0 +1,112 @@
+"""Independent rational-arithmetic oracle. Never imports generator code."""
+from __future__ import annotations
+import argparse, hashlib, json, re
+from fractions import Fraction
+from pathlib import Path
+from collections import Counter, defaultdict
+from jsonschema import Draft202012Validator
+
+SCALES={'SAR':2,'AED':2,'QAR':2,'KWD':3,'BHD':3,'OMR':3}
+COUNTRIES={'SAR':'SA','AED':'AE','QAR':'QA','KWD':'KW','BHD':'BH','OMR':'OM'}
+FIELDS=('net','tax','gross','due')
+
+def parse(text,style):
+    """Reject mixed alphabets, malformed grouping, exponent notation and bidi controls."""
+    if not isinstance(text,str) or len(text)>80: raise ValueError('invalid number type/length')
+    arabic='arabic' in style
+    digits=''.join(chr(0x0660+i) for i in range(10)) if arabic else '0123456789'
+    dot=chr(0x066B) if arabic else '.'; group=chr(0x066C) if arabic else ','
+    integer=rf'[{digits}]{{1,3}}(?:{re.escape(group)}[{digits}]{{3}})*' if 'grouped' in style else rf'[{digits}]+'
+    pattern=rf'-?{integer}(?:{re.escape(dot)}[{digits}]+)?'
+    if re.fullmatch(pattern,text) is None: raise ValueError('number violates declared grammar')
+    # Decode each digit individually rather than sharing generator formatting helpers.
+    negative=text.startswith('-'); body=text[1:] if negative else text
+    sides=body.split(dot); whole=sides[0].replace(group,''); tail=sides[1] if len(sides)==2 else ''
+    n=0
+    for ch in whole+tail: n=n*10+digits.index(ch)
+    return Fraction(-n if negative else n,10**len(tail))
+
+def rounded_minor(value,scale):
+    scaled=value*10**scale
+    a,b=abs(scaled.numerator),scaled.denominator
+    q,r=divmod(a,b)
+    return (-1 if scaled<0 else 1)*(q+(2*r>=b))
+
+def money(n,scale):
+    sign='-' if n<0 else ''; n=abs(n); div=10**scale
+    return f'{sign}{n//div}.{n%div:0{scale}d}'
+
+def oracle(invoice):
+    scale=SCALES[invoice['currency']]; style=invoice['numeric_style']; unit=10**scale
+    nets=[]; taxes=[]
+    for line in invoice['lines']:
+        q,p,a,c,r=[parse(line[k],style) for k in ['quantity','unit_price','allowance','charge','rate']]
+        if q<=0 or any(x<0 for x in (p,a,c,r)) or r>1: raise ValueError('impossible source line')
+        raw=q*p-a+c
+        if raw<0: raise ValueError('negative line net')
+        net=rounded_minor(raw,scale); nets.append(net)
+        taxes.append(rounded_minor(Fraction(net,unit)*r,scale))
+    net=sum(nets); tax=sum(taxes); gross=net+tax
+    pre=parse(invoice['prepaid'],style)*unit
+    if pre.denominator!=1 or pre<0 or pre>gross: raise ValueError('invalid prepaid')
+    if invoice['document_type']=='credit_note' and pre: raise ValueError('credit prepayment forbidden in this contract')
+    sign=-1 if invoice['document_type']=='credit_note' else 1
+    amounts=dict(net=sign*net,tax=sign*tax,gross=sign*gross,due=sign*(gross-int(pre)))
+    expected={k:money(v,scale) for k,v in amounts.items()}
+    errors=[]
+    for k in FIELDS:
+        obs=parse(invoice['claimed_totals'][k],style)*unit
+        if obs.denominator!=1 or obs!=amounts[k]: errors.append(k)
+    return dict(valid=not errors,totals=expected,error_fields=errors)
+
+def canonical(x): return json.dumps(x,sort_keys=True,separators=(',',':'),ensure_ascii=False)
+def sha(x): return hashlib.sha256(canonical(x).encode()).hexdigest()
+
+def validate(rows,schema):
+    checker=Draft202012Validator(schema); ids=set(); content=set(); pairs=defaultdict(list); evidence=[]
+    for row in rows:
+        checker.validate(row)
+        if row['id'] in ids: raise ValueError('duplicate ID')
+        ids.add(row['id'])
+        d=sha(row['invoice'])
+        if d in content: raise ValueError('duplicate invoice')
+        content.add(d)
+        if row['id']!=d[:32]: raise ValueError('id mismatch')
+        body={k:v for k,v in row.items() if k!='fingerprint_sha256'}
+        if sha(body)!=row['fingerprint_sha256']: raise ValueError('fingerprint mismatch')
+        if row['country']!=COUNTRIES[row['invoice']['currency']]: raise ValueError('currency-country mismatch')
+        computed=oracle(row['invoice'])
+        if computed!=row['expected']: raise ValueError(f'oracle disagreement {row["id"]}')
+        if row['provenance']['copied_records']!=0 or not row['provenance']['synthetic']: raise ValueError('provenance mismatch')
+        pairs[row['pair_id']].append(row)
+        evidence.append(dict(id=row['id'],independent_oracle=computed,fingerprint_sha256=row['fingerprint_sha256'],pass_all=True))
+    # Validate pairing and leakage at semantic input level, beyond IDs.
+    base_hashes=set()
+    for pair_id,pair in pairs.items():
+        if len(pair)!=2 or sum(x['expected']['valid'] for x in pair)!=1: raise ValueError('pair label/count failure')
+        a,b=sorted(pair,key=lambda x:not x['expected']['valid'])
+        if a['split']!=b['split']: raise ValueError('split leakage')
+        src_a={k:v for k,v in a['invoice'].items() if k!='claimed_totals'}
+        src_b={k:v for k,v in b['invoice'].items() if k!='claimed_totals'}
+        if src_a!=src_b or sha(src_a)[:24]!=pair_id: raise ValueError('pair inputs differ')
+        changes=[k for k in FIELDS if a['invoice']['claimed_totals'][k]!=b['invoice']['claimed_totals'][k]]
+        if changes!=b['expected']['error_fields'] or len(changes)!=1: raise ValueError('not a causal single-field mutation')
+        field=changes[0]; style=a['invoice']['numeric_style']; scale=SCALES[a['invoice']['currency']]
+        delta=parse(b['invoice']['claimed_totals'][field],style)-parse(a['invoice']['claimed_totals'][field],style)
+        if abs(delta)!=Fraction(1,10**scale): raise ValueError('incorrect mutation delta')
+        if b['mutation']['path']!='claimed_totals.'+field or parse(b['mutation']['delta'],'ascii')!=delta: raise ValueError('mutation trace mismatch')
+        if a['mutation'] is not None: raise ValueError('valid record has mutation')
+        semantic=src_a.copy(); semantic.pop('numeric_style')
+        semantic['lines']=[{k:str(parse(v,style)) for k,v in l.items()} for l in semantic['lines']]
+        semantic['prepaid']=str(parse(semantic['prepaid'],style))
+        normalized=sha(semantic)
+        if normalized in base_hashes: raise ValueError('semantic duplicate source')
+        base_hashes.add(normalized)
+    return evidence
+
+if __name__=='__main__':
+    p=argparse.ArgumentParser(); p.add_argument('dataset',type=Path); p.add_argument('--schema',type=Path,required=True); p.add_argument('--log',type=Path)
+    a=p.parse_args(); rows=[json.loads(x) for x in a.dataset.read_text(encoding='utf-8').splitlines()]
+    log=validate(rows,json.loads(a.schema.read_text(encoding='utf-8')))
+    if a.log: a.log.write_text(''.join(canonical(r)+'\n' for r in log),encoding='utf-8')
+    print(json.dumps(dict(validated=len(log),status='PASS')))