Spaces:
Running
Running
| """Non-circular four-route audit of the paper's Figure 2 empirical claim.""" | |
| from __future__ import annotations | |
| import time | |
| import numpy as np | |
| def exact_discretization_audit() -> dict[str, object]: | |
| """Separate an Euler algebra identity from architecture-level evidence.""" | |
| a = np.array([0.7, -0.4]) | |
| c = np.array([0.2, 0.5]) | |
| grad_a = np.array([0.3, -0.2]) | |
| grad_c = np.array([0.1, 0.54]) | |
| symmetry_residual = float(np.dot(a, grad_a) - np.dot(c, grad_c)) | |
| taus = np.logspace(-6, -2, 9) | |
| invariant_drift = [] | |
| nonconserved_drift = [] | |
| h_minus = float(np.dot(a, a) - np.dot(c, c)) | |
| h_plus = float(np.dot(a, a) + np.dot(c, c)) | |
| for tau in taus: | |
| updated_a = a - tau * grad_a | |
| updated_c = c - tau * grad_c | |
| invariant_drift.append( | |
| abs(float(np.dot(updated_a, updated_a) - np.dot(updated_c, updated_c)) - h_minus) | |
| ) | |
| nonconserved_drift.append( | |
| abs(float(np.dot(updated_a, updated_a) + np.dot(updated_c, updated_c)) - h_plus) | |
| ) | |
| invariant_slope = float(np.polyfit(np.log(taus), np.log(invariant_drift), 1)[0]) | |
| nonconserved_slope = float( | |
| np.polyfit(np.log(taus), np.log(nonconserved_drift), 1)[0] | |
| ) | |
| passed = ( | |
| abs(symmetry_residual) < 1e-15 | |
| and abs(invariant_slope - 2.0) < 2e-4 | |
| and abs(nonconserved_slope - 1.0) < 2e-3 | |
| ) | |
| return { | |
| "interpretation": ( | |
| "For a quadratic invariant and one Euler/SGD step, cancellation " | |
| "of the linear term makes tau^2 scaling algebraic. It cannot by " | |
| "itself validate the architecture or the paper datasets." | |
| ), | |
| "taus": taus.tolist(), | |
| "symmetry_direction_residual": symmetry_residual, | |
| "quadratic_invariant_drifts": invariant_drift, | |
| "quadratic_invariant_loglog_slope": invariant_slope, | |
| "nonconserved_control_drifts": nonconserved_drift, | |
| "nonconserved_control_loglog_slope": nonconserved_slope, | |
| "passed": passed, | |
| } | |
| def paper_configuration_audit() -> dict[str, object]: | |
| return { | |
| "source_anchors": [ | |
| "https://ar5iv.labs.arxiv.org/html/2606.17816#S5.F2", | |
| "https://ar5iv.labs.arxiv.org/html/2606.17816#S6", | |
| "https://ar5iv.labs.arxiv.org/html/2606.17816#A4", | |
| ], | |
| "required_configurations": { | |
| "CIFAR-10": { | |
| "model": "ViT, 6 layers, d=256, MLP=1024, 4 heads", | |
| "training": "300 epochs, three learning rates, 10 seeds each", | |
| }, | |
| "ImageNet-1K": { | |
| "model": "ViT, 12 layers, d=192, MLP=768, 4 heads", | |
| "training": "5 epochs, three learning rates, 10 seeds each", | |
| }, | |
| "Penn Treebank": { | |
| "model": "12-layer Qwen-3-style LM, d=192, MLP=768, 3 heads, 4 experts", | |
| "training": "300 epochs, three learning rates, 10 seeds each", | |
| }, | |
| "WikiText-103": { | |
| "model": "12-layer Qwen-3-style LM, d=192, MLP=768, 3 heads, 4 experts", | |
| "training": "15,000 steps, batch 48, length 256, three rates, 10 seeds each", | |
| }, | |
| }, | |
| "paper_runtime": ( | |
| "PyTorch 2.9.1/CUDA 12.8, one H100 80GB, 12 data workers, " | |
| "less than four hours per individual configuration" | |
| ), | |
| "minimum_individual_runs": 4 * 3 * 10, | |
| "candidate_repository_has_training_implementation": False, | |
| "candidate_repository_has_named_datasets": False, | |
| "candidate_repository_has_paper_raw_logs": False, | |
| "route_result": "INCOMPLETE", | |
| } | |
| def cpu_resource_calibration() -> dict[str, object]: | |
| """Benchmark one required projection and form a deliberately weak lower bound.""" | |
| started = time.perf_counter() | |
| batch_tokens, d, intermediate, layers = 48 * 256, 192, 768, 12 | |
| rng = np.random.default_rng(52_001) | |
| x = rng.normal(size=(batch_tokens, d)).astype(np.float32) | |
| weight = rng.normal(size=(d, intermediate)).astype(np.float32) | |
| _ = x @ weight | |
| repeats = 3 | |
| benchmark_start = time.perf_counter() | |
| checksum = 0.0 | |
| for _ in range(repeats): | |
| output = x @ weight | |
| checksum += float(output[0, 0]) | |
| benchmark_seconds = time.perf_counter() - benchmark_start | |
| flops_per_projection = 2 * batch_tokens * d * intermediate | |
| measured_flops_per_second = repeats * flops_per_projection / benchmark_seconds | |
| wiki_steps = 15_000 * 3 * 10 | |
| wiki_token_positions = wiki_steps * batch_tokens | |
| lower_bound_flops = wiki_steps * layers * flops_per_projection | |
| projected_lower_seconds = lower_bound_flops / measured_flops_per_second | |
| return { | |
| "calibration": { | |
| "operation": "one 12288x192 by 192x768 float32 projection", | |
| "repeats": repeats, | |
| "seconds": benchmark_seconds, | |
| "measured_flops_per_second": measured_flops_per_second, | |
| "checksum": checksum, | |
| }, | |
| "wikitext_only_lower_bound": { | |
| "steps_across_three_rates_and_ten_seeds": wiki_steps, | |
| "token_positions": wiki_token_positions, | |
| "flops": lower_bound_flops, | |
| "projected_seconds_at_measured_projection_throughput": projected_lower_seconds, | |
| "omitted_work": ( | |
| "all other projections, attention, experts, backward pass, " | |
| "optimizer, data loading, evaluation, and three other datasets" | |
| ), | |
| }, | |
| "runtime_seconds": time.perf_counter() - started, | |
| "route_result": "CPU_FULL_REPRODUCTION_OUT_OF_SCOPE", | |
| } | |
| def mandatory_falsification_route() -> dict[str, object]: | |
| """Try, but do not overclaim, the exact normalized-sigmoid counterexample.""" | |
| taus = np.logspace(-8, -3, 8) | |
| derivative_gradient_flow = 9.0 / 250.0 | |
| sigmoid_drifts = derivative_gradient_flow * taus | |
| sigmoid_slope = float(np.polyfit(np.log(taus), np.log(sigmoid_drifts), 1)[0]) | |
| softmax_drifts = np.zeros_like(taus) | |
| return { | |
| "restated_target": ( | |
| "Figure 2/Section 6 reports O(tau^2*k) conservation-error behavior " | |
| "in named Qwen-3-style and ViT configurations on four datasets." | |
| ), | |
| "assumptions_checked": ( | |
| "The normalized-sigmoid construction satisfies the architecture, " | |
| "squared-loss, Euclidean-flow, and full-output-span assumptions." | |
| ), | |
| "counterexample_result": { | |
| "claimed_gate_row_sum_gradient_flow_derivative": derivative_gradient_flow, | |
| "one_step_drifts": sigmoid_drifts.tolist(), | |
| "loglog_slope": sigmoid_slope, | |
| "matched_softmax_drifts": softmax_drifts.tolist(), | |
| }, | |
| "falsification_succeeded": False, | |
| "reason": ( | |
| "The slope-one result falsifies the normalized-sigmoid conservation " | |
| "premise, but it is not one of the paper's named dataset training " | |
| "trajectories and therefore does not contradict the historical " | |
| "empirical observation itself." | |
| ), | |
| "negative_control_passed": bool(np.all(softmax_drifts == 0.0)), | |
| } | |
| def verify() -> dict[str, object]: | |
| route1 = exact_discretization_audit() | |
| route2 = paper_configuration_audit() | |
| route3 = cpu_resource_calibration() | |
| route4 = mandatory_falsification_route() | |
| protocol_complete = ( | |
| bool(route1["passed"]) | |
| and route2["route_result"] == "INCOMPLETE" | |
| and route3["route_result"] == "CPU_FULL_REPRODUCTION_OUT_OF_SCOPE" | |
| and bool(route4["negative_control_passed"]) | |
| and route4["falsification_succeeded"] is False | |
| ) | |
| return { | |
| "claim": "Figure 2 and Section 6 paper-scale empirical validation", | |
| "routes": { | |
| "1_exact_discretization_non_circularity": route1, | |
| "2_exact_paper_configuration_audit": route2, | |
| "3_independent_cpu_resource_calibration": route3, | |
| "4_mandatory_falsification_attempt": route4, | |
| }, | |
| "protocol_complete": protocol_complete, | |
| "all_checks_passed": protocol_complete, | |
| "verdict": "BLOCKED", | |
| "confidence": "LOW", | |
| "unblocker": ( | |
| "The paper's executable training code and raw trajectories, or " | |
| "authorization for the exact 120+-configuration H100 campaign; " | |
| "neither is compatible with this CPU-only reproduction." | |
| ), | |
| } | |