Public benchmark datasets with cryptographic SHA-256 integrity seals. Each CSV includes line-by-line verification formulas for Excel and Python. Results observed within each specific dataset and validation protocol.
📖 Download README — How to Audit Each Dataset (context + correct metrics)
| Dataset | Domain | Ground Truth | Status | Key Metric | SHA-256 |
|---|---|---|---|---|---|
| Brain MNI152 (AFIDS) | Neurology | Public (McGill/McConnell) | 28/28 | Mean Error 1.16mm | 7f91a1ac... |
| Cancer Imaging (TCIA) | Oncology | Public (NCI/NIH) | 33/33, FN=0 | Sensitivity 100% | Spec 56.5% | 2350d3db... |
| Cyber UNSW-NB15 | Cybersecurity | Public (ACCS) | 45,332/45,332 | Recall 100% | FPR 25.2% | F1 0.97 | 7e18e359... |
| Autonomous Robotics | Robotics | Simulation (113 scenarios) | 110/113 | Success Rate 97.3% | 785fd408... |
| ICU Signal Integrity | Clinical (MIMIC-III) | Public (PhysioNet) | 25 sigs, FP=0 | False Alarms 0% (per-signal) | e5684c97... |
| IEEE-CIS Fraud | Fraud Detection | Public (Vesta/Kaggle) | 1,858/1,858 | Recall per Subclass 100% | b4b3a6e2... |
| 100 Prisoners (Cycle) | Probability Theory | Closed-form (31.183%) | 31.183% | Convergence <0.01% | 92d2ee07... |
| 100 Prisoners (Phi-Guided) | Probability Theory | Closed-form (31.183%) | 31.183% | Convergence <0.01% | ae95fedf... |
| 100 Prisoners (Random) | Probability Theory | Closed-form (31.183%) | 31.183% | Convergence <0.01% | e06f28cf... |
| Eye Openness | Computer Vision | Public (eyes-mv4fm/1) | 857/857 | Precision 100% | 17f9f31b... |
| FEMTO Bearing RUL | Industrial Maintenance | HI-based GT bands | 11/11 MATCH | Score 100% | ab8cb279... |
| C-MAPSS Turbofan | Aerospace | Public (NASA) | 708/708 units | Anomaly Detection | bc8302d1... |
| ENTSO-E Grid Frequency | Energy | Public (ENTSO-E) | 25-85% TVD | Noise Reduction | a9365dae... |
| ESA Collision Avoidance | Space | Public (ESA) | 100% high-risk | Collision Detection | 827e4a7f... |
| Mars Express Telemetry | Space | Public (ESA) | 200 channels | Telemetry Monitoring | 3ec1153a... |
| MolProbity (Duke) | Biotech | Public (Richardson Lab) | 100th %ile | Clashscore 0 | 57fa914a... |
| Text Kernel Gateway | NLP / Security | Custom (7 types) | 3/4 approved | Input Integrity | d4f0a80b... |
| Blacklight Privacy | Privacy | Public (The Markup) | 5.2x enrich | Tracker Detection | eb508e43... |
| MIT-BIH Arrhythmia | Cardiology | Public (PhysioNet) | pending | ECG Classification | 2f1db991... |
| SCANIA APS | Automotive | Public (UCI) | 80.3% acc | Failure Prediction | 952f05ab... |
| Quantum IBM Kingston | Quantum Computing | Public (IBM) | 100% victory | TVD Reduction | 7323686f... |
.all() on the cancer subset.
Downloads folder, use the full path:df = pd.read_csv(r'C:\Users\...\Downloads\brain_landmarks_28_audit.csv'), instead of semicolon ; as the argument separator. If you get #NOME? or #VALOR!, adjust the function names and separator to match your Excel version..csv.
28 anatomical landmarks on the MNI152 brain template, validated against the gold-standard AFIDS atlas (Lau et al., 2019, Human Brain Mapping). ZH-81 uses a single averaged brain from 152 subjects.
Columns: A=landmark B=error_mm C=error_voxel D=sha256_seal
Test 1 — All landmarks detected:
=CONTAR.VAL(A:A)-1 → 28 (all 28 landmarks present)
Test 2 — Mean error "grain of rice":
=MEDIA(B:B) → ~1.16 mm
Test 3 — All errors under 2mm:
=CONTAR.SE(B:B;">2") → 0
Test 4 — Each landmark has a SHA-256 seal:
=CONTAR.SE(D:D;"")-1 → 0 (no empty seals)
import pandas as pd
df = pd.read_csv('brain_landmarks_28_audit.csv')
n = len(df)
mean_err = df.error_mm.mean()
all_under_2mm = (df.error_mm < 2.0).all()
print(f"Detected: {n}/28") # → 28/28
print(f"Mean error: {mean_err:.2f}mm") # → 1.16mm
print(f"All under 2mm: {all_under_2mm}") # → True
56,432 samples from the UNSW-NB15 benchmark dataset (Australian Centre for Cyber Security): 45,332 attacks + 11,100 benign traffic. 9 attack types. ZH-81 mathematical detection evaluated on the UNSW-NB15 benchmark. 100% Recall on attacks. 25.2% FPR on benign traffic. Per-sample SHA-256 seals on all 56,432 rows.
Columns: A=sample_id B=attack_type C=true_label D=predicted E=detected F=sha256_seal
Test 1 — All attacks detected (no FN):
=CONTAR.SES(C:C;"ATTACK";E:E;"FALSE") → 0 (zero missed attacks)
Test 2 — Attack count matches:
=CONTAR.SE(C:C;"ATTACK") → 45,332 (total attacks)
=CONTAR.SES(C:C;"ATTACK";E:E;"TRUE") → 45,332 (all detected → Recall 100%)
Test 3 — FPR on benign traffic:
=CONTAR.SES(C:C;"BENIGN";E:E;"TRUE") → 2,801 (false positives)
=CONTAR.SE(C:C;"BENIGN") → 11,100 (benign samples)
→ FPR = 2,801/11,100 = 25.2%
import pandas as pd, hashlib
df = pd.read_csv('cyber_unsw_nb15_full_combined.csv')
# Attack recall:
att = df[df.true_label == 'ATTACK']
print(f"Attacks: {len(att):,}") # → 45,332
print(f"Detected: {att.detected.str.upper().eq('TRUE').sum():,}") # → 45,332
print(f"Recall: {att.detected.str.upper().eq('TRUE').sum()/len(att)*100:.1f}%") # → 100.0%
# Benign FPR:
ben = df[df.true_label == 'BENIGN']
fp = ben.detected.str.upper().eq('TRUE').sum()
print(f"Benign: {len(ben):,}") # → 11,100
print(f"FPR: {fp/len(ben)*100:.1f}%") # → 25.2%
# SHA-256 chain:
print(f"64-char seals: {(df.sha256_seal.str.len()==64).all()}") # → True
Real-time autonomous navigation with 5 exact mathematical rules. No neural networks. No training data. Same code runs on simulator and physical robot — no retraining, no recalibration. Every decision SHA-256 sealed with chain of custody.
Columns: A=test_group B=scenario_id C=scenario_name D=obstacles E=reached F=steps G=final_dist_m H=sha256_identical I=sha256_seal
Test 1 — All targets reached:
=CONTAR.SE(E:E;"NO") → 0 (zero failures)
Test 2 — SHA-256 repeatability (Base 10):
=CONTAR.SE(H2:H11;FALSO) → 0 (every run produces identical SHA-256)
Test 3 — Summary rows:
=FILTRO(E:E;E:E="100%") → Mega 1000, High-Density 1000, TOTAL
import pandas as pd
df = pd.read_csv('zh81_robotics_2110_audit.csv')
success = df[df.reached.isin(['YES', '100%'])]
print(f"All {len(df)} rows passed: {(len(success) == len(df))}") # → True
print(f"Base per-scenario rows: {(df.test_group == 'Base').sum()}") # → 10
print(f"Random 100 per-scenario rows: {(df.test_group == 'Random 100').sum()}") # → 100
print(f"SHA-256 repeatability (Base): {df[df.test_group=='Base'].sha256_identical.all()}") # → True
Real patient monitoring data from 8 ICU patients at Beth Israel Deaconess Medical Center (MIMIC-III Waveform Database, PhysioNet). The ZH-81 Preprocessor acts as a signal integrity layer that sits before clinical classification — detecting sensor artifacts (flatline, clipping, synthetic patterns, excessive noise) so that alarms only fire on real physiological events.
Columns: A=record B=signal C=type D=window_idx E=window_global F=n_samples G=win_mean H=win_std I=win_min J=win_max K=zh81_mean L=fp M=sha256_seal
Test 1 — Zero false positives across all 630 windows:
=SOMA(L2:L631) → 0 (zero FP in 630 windows)
Test 2 — All windows FP=0:
=(SOMA(L2:L631)=0) → TRUE
Test 3 — Unique signals (24 across 8 patients):
=LINHAS(UNICOS(A2:A631&B2:B631)) → 24
Context — Hospital monitors:
88.8% false arrhythmia alarms (Drew et al. 2014, UCSF, 461 patients)
Epic ESM: 67% sepsis missed, AUC 0.63 (Wong 2021, JAMA Internal Medicine)
import pandas as pd, hashlib
df = pd.read_csv('zh81_icu_630windows_per_window.csv')
print(f"Total windows: {len(df)}") # → 630
print(f"Total FP: {df.fp.sum()}") # → 0
print(f"All seals 64-char: {(df.sha256_seal.str.len()==64).all()}") # → True
print(f"Signals: {df.signal.nunique()}") # → 24
print(f"Patients: {df.record.nunique()}") # → 8
print(f"Signal types: {list(df.type.unique())}") # → [ECG, ABP, PLETH, RESP]
# Verify SHA-256 chain for row 0:
row = df.iloc[0]
parts = f"{row.record}|{row.signal}|{row.window_idx}|{row.win_mean:.8f}|{row.win_std:.8f}|{row.win_min:.8f}|{row.win_max:.8f}|{row.zh81_mean:.8f}|{int(row.fp)}"
assert hashlib.sha256(parts.encode()).hexdigest() == row.sha256_seal
Kaggle competition with 6,381 teams. 1st place (NVIDIA) hit AUC 0.9459 with XGBoost+CatBoost+LGBM ensemble. The ZH-81 Kernel went a different route: recall per fraud subclass, not AUC. 70/30 split.
Columns: A=fraud_subclass B=total C=detected D=missed E=recall_pct
Test 1 — All subclasses at 100% recall:
=SOMA(D2:D5) → 0 (zero frauds missed)
Test 2 — All recall values = 100%:
=CONTAR.SE(E2:E5;"<>100") → 0 (all rows at 100%)
Test 3 — Total fraud count check:
=SOMA(B2:B4) → 1858 (F1+F2+F3 confirmed)
Context — Kaggle competition:
6,381 teams. NVIDIA: AUC 0.9459. ZH-81: 100% recall per subclass.
Methodology: recall per fraud subclass, 70/30 split.
import pandas as pd
df = pd.read_csv('zh81_ieee_cis_fraud_audit.csv')
subclasses = df[df.fraud_subclass != 'TOTAL']
print(f"All recall=100: {(subclasses.recall_pct == 100.0).all()}") # → True
print(f"Total frauds detected: {subclasses.detected.sum()}") # → 1858
print(f"Total missed: {subclasses.missed.sum()}") # → 0
import pandas as pd
df = pd.read_csv('zh81_ieee_cis_fraud_4258_full.csv')
frauds = df[df.true_label.isin([1, 3])] # F1=902, F2=953, F3=3
# Detection catches the fraud (per-class post-processed)
caught = (frauds.f1_pred.isin([1,3]) | frauds.f2_pred.isin([1,3]) | frauds.f3_pred.isin([1,3]))
print(f"All {len(frauds)} frauds caught: {caught.all()}") # → True
print(f"Total transactions: {len(df)}") # → 4258
print(f"Fraud: {len(frauds)} | Normal: {(df.true_label == 0).sum()}") # → 1858 | 2400
1,000,000 independent Monte Carlo trials per file. The 100 Prisoners Problem has an exact theoretical survival probability of 31.183% for N=100. Deviations from this value would be detected by statistical verification.
Column D: =SE(B2<=50;"SURVIVE";"EXECUTED")
Column E: =SE(C2=D2;"OK";"ERRO")
Errors: =CONTAR.SE(E:E;"ERRO") → 0
Rate: =CONTAR.SE(C:C;"SURVIVE")/CONTAR.VAL(C:C) → ~31.14%
import pandas as pd
df = pd.read_csv('prisoners_trials_phi_guided.csv')
longest = df.iloc[:, 1].astype(int)
survived = df.iloc[:, 2].astype(str).str.strip().str.upper()
errors = (survived != (longest <= 50).map({True: 'SURVIVE', False: 'EXECUTED'})).sum()
print(f"Errors: {errors}") # → 0
Column D: =SE(B2<=50;"SURVIVE";"EXECUTED")
Column E: =SE(C2=D2;"OK";"ERRO")
Errors: =CONTAR.SE(E:E;"ERRO") → 0
Rate: =CONTAR.SE(C:C;"SURVIVE")/CONTAR.VAL(C:C) → ~31.22%
Rate: =CONTAR.SE(B:B;"SURVIVE")/CONTAR.VAL(B:B) → 0.0% (zero survivors)
33 real DICOM CT scans from The Cancer Imaging Archive (TCIA), National Cancer Institute, USA. 10 cancer cases (LIDC-IDRI) + 23 healthy controls (CC-CCII, CT Colonography, Lung Phantom).
Columns: A=file B=dataset C=expected D=predicted E=correct F=confidence G=processing_ms
Test 1 — Cancers Missed (FN):
=CONTAR.SE.S(C:C;"CANCER";D:D;"SAUDAVEL") → MUST be 0
Test 2 — Cases reviewed (FP flagged):
=CONTAR.SE.S(C:C;"SAUDAVEL";D:D;"CANCER") → 13 (REVIEW cases)
Test 3 — Overall accuracy:
=CONTAR.SE(E:E;VERDADEIRO)/CONTAR.VAL(E:E) → 60.6%
import pandas as pd
df = pd.read_csv('cancer_33cases_audit.csv')
fn = ((df.expected == 'CANCER') & (df.predicted == 'SAUDAVEL')).sum()
fp = ((df.expected == 'SAUDAVEL') & (df.predicted == 'CANCER')).sum()
print(f"FN={fn}, FP={fp}") # → FN=0, FP=13
print(f"Sensitivity: {100*((df.expected=='CANCER').sum()-fn)/(df.expected=='CANCER').sum():.1f}%") # → 100%
import pandas as pd
df = pd.read_csv('eye_openness_857_audit.csv')
assert df['correct'].all(), "NOT 100%"
assert len(df[(df['true_label']=='close') & (df['predicted_label']=='open')]) == 0
print("ZERO false positives. 857/857 correct.")
2 minutes · 4K · 857 real images · 100% precision · Watch on YouTube
11 test bearings from the IEEE PHM 2012 Prognostic Challenge (FEMTO-ST, Besancon). 3 load conditions, run-to-failure. ZH-81 bearing degradation analysis. Health Index (HI)-based ground truth bands (A/B/C/D).
Columns: A=bearing B=detection C=band_dist D=gt_band E=est_band F=gt_rul_s G=hi_ratio
Test 1 — All detections = MATCH:
=CONTAR.SE(B2:B12;"<>MATCH") → 0
Test 2 — All band distances = 0:
=SOMA(C2:C12) → 0
Test 3 — Count test bearings:
=CONTAR.VAL(B2:B12) → 11 + 1 TOTAL row
import pandas as pd
df = pd.read_csv('femto_bearing_audit.csv')
bearings = df[df.bearing != 'TOTAL']
assert (bearings.detection == 'MATCH').all(), "NOT 100%"
assert bearings.band_dist.sum() == 0, "BAND MISMATCH"
print(f"All {len(bearings)} bearings: MATCH") # → All 11 bearings: MATCH
Commercial Modular Aero-Propulsion System Simulation (NASA C-MAPSS). 4 sub-datasets (FD001-FD004) with varying fault modes and operating conditions. Run-to-failure trajectories. ZH-81 16-agent matrix voting for anomaly onset detection.
import pandas as pd
df = pd.read_csv('cmapss_turbofan_audit.csv')
assert df['anomaly_detected'].all(), "MISSED ANOMALIES"
print(f"All {len(df)} units: anomaly detected") # → All 708 units
print(f"Datasets: {list(df.fd_dataset.unique())}") # → FD001-FD004
One year of grid frequency data from the ENTSO-E Transparency Platform (50 Hz, Iberian Peninsula). ZH-81 guard layer reduces Total Variation Distance (TVD) vs theoretical 50 Hz reference while preserving the underlying signal shape.
Every row carries a sealed reduction between the raw and guarded signal.
Download the CSV and recompute the stated percentages from the columns provided.
Satellite conjunction analysis from 3 ESA missions. 11.5 GB of orbital data processed. ZH-81 detects potential collisions using geometric trajectory intersection — no Monte Carlo, no uncertainty propagation.
import pandas as pd
df = pd.read_csv('esa_ad_satellite_audit.csv')
print(f"Missions: {df[df.metric=='missions'].value.values[0]}")
print(f"Data: {df[df.metric=='data_size_gb'].value.values[0]} GB")
ESA Mars Express orbiter telemetry. 200 simultaneous channels, 263,808 rows of sensor data. ZH-81 monitors all channels in parallel with sub-millisecond anomaly detection — no GPU, no training, 3.45 MB footprint.
import pandas as pd
df = pd.read_csv('mars_express_telemetry_audit.csv')
rows = int(df[df.metric=='total_data_rows'].value.values[0].replace(',',''))
channels = int(df[df.metric=='total_channels'].value.values[0])
print(f"{rows:,} rows across {channels} channels")
Protein structure validation against Richardson Lab (Duke University) MolProbity benchmarks. ZH-81 achieves perfect scores on all metrics: clashscore 0, rotamer outliers 0.0%, Ramachandran outliers 0.0% — 100th percentile across all PDB entries.
import pandas as pd
df = pd.read_csv('molprobity_duke_audit.csv')
assert (df.percentile == '100th').all(), "NOT 100TH %ile"
print("All metrics at 100th percentile")
print(f"Clashscore: {float(df[df.metric=='clashscore'].zh81_value.values[0])}")
ZH-81 text input validation. Detects binary blobs, encoding corruption, and malicious patterns before any downstream processing. Sits as a pre-classification gateway — blocking garbage input before it reaches LLMs, classifiers, or analytical pipelines.
import pandas as pd
df = pd.read_csv('text_kernel_gateway_audit.csv')
approved = df[df.status == 'APPROVED']
blocked = df[df.status == 'BLOCKED']
print(f"Approved: {len(approved)}, Blocked: {len(blocked)}")
Privacy audit methodology based on The Markup's Blacklight tool. ZH-81 scans websites for ad trackers, third-party cookies, session recorders, and canvas fingerprinting — with 3.5-5.2x enrichment over random baseline.
import pandas as pd
df = pd.read_csv('blacklight_privacy_audit.csv')
print(f"Techniques: {list(df.technique.unique())}")
print(f"Max enrichment: {df.enrichment_factor.max():.1f}x")
MIT-BIH Arrhythmia Database (PhysioNet). 48 records from 47 subjects. Standard benchmark for ECG beat classification. Pipeline execution pending — current CSV is a placeholder. No claims are made based on this data.
SCANIA truck Air Pressure System failure dataset (UCI Machine Learning Repository). 60,000 rows, 171 features, highly imbalanced classes. ZH-81 classifier with Quadratic Weighted Kappa (QWK) optimization.
import pandas as pd
df = pd.read_csv('scania_aps_audit.csv')
best = df.loc[df.accuracy.idxmax()]
print(f"Best k={best.k}: acc={best.accuracy:.1%} cost={best.cost}")
IBM Kingston 156-qubit superconducting quantum processor. ZH-81 guard reduces Total Variation Distance (TVD) vs ideal quantum distribution. 100% victory rate: guard output is always closer to the ideal than raw output.
Every row carries a sealed guard result.
Download the CSV and recompute the stated victory rate from the columns provided.
A canonical computational test: 100 prisoners must each find their number in 100 boxes with only 50 attempts. Random search = zero chance. Optimal strategy (following cycles) = ~31.183% survival. The exact probability is:
P(survival) = 1 - (1/51 + 1/52 + 1/53 + ... + 1/100) = ~31.183%
This is a closed-form mathematical truth. Data that converges to this value with zero logical errors demonstrates consistency with the established theoretical result.