| """Claim 3 (Corollary 26) executed priority + display audit. |
| |
| Deterministic, offline: parses the cached primary-source documents committed |
| under evidence/claim_3/sources/ (arXiv abstract pages fetched 2026-07-31 and a |
| verbatim ar5iv excerpt of the target paper), prints their SHA-256 hashes, and |
| recomputes every step of the argument with exact rational arithmetic |
| (fractions.Fraction; no floats anywhere). |
| |
| Steps executed: |
| 1. Date audit: extract v1 submission dates of arXiv:2110.13086 and |
| arXiv:2312.14141 from the cached pages; both must precede the target's |
| 2025-09-29 v1 date. |
| 2. Content audit: both abstracts must describe quantum algorithms for Lasso; |
| 2312.14141 must use the penalized (ell_1-penalty) form, defeating a |
| "different formulation" defense of firstness. |
| 3. Objective bijection (exact): (1/2)||y-Xb||^2 + t||b||_1 and |
| ||y-Xb||^2 + 2t||b||_1 have identical minimizers; verified in closed form |
| for the 1-d soft-threshold instance with exact fractions. |
| 4. Self-citation: the target paper's own related-work text acknowledges |
| Chen and de Wolf (2023) "quantum algorithms for Lasso and ridge". |
| 5. Display counterexample (exact): Corollary 26's printed inequality omits |
| lambda in the right-hand minimand; for A=[1], b=[1], lambda=100, |
| eps=1/10 the printed guarantee is infeasible with gap 7/40. |
| 6. Negative controls: a Ridge-only earlier record must NOT falsify Lasso |
| firstness; the target compared to itself must NOT count as prior art. |
| """ |
|
|
| import hashlib |
| import pathlib |
| import re |
| from fractions import Fraction |
|
|
| SRC = pathlib.Path(__file__).resolve().parent.parent / "evidence" / "claim_3" / "sources" |
| TARGET_V1 = "2025-09-29" |
|
|
|
|
| def sha(path): |
| return hashlib.sha256(path.read_bytes()).hexdigest() |
|
|
|
|
| def parse_abs(path): |
| t = path.read_text(errors="replace") |
| title = re.search(r"<title>\[([\d.]+)\] (.*?)</title>", t, re.S) |
| sub = re.search(r"\[Submitted on ([^\]]+?)(?:\s*\(|\])", t) |
| abstract = re.search(r'blockquote class="abstract[^>]*>(.*?)</blockquote>', t, re.S) |
| abs_text = re.sub(r"<[^>]+>", " ", abstract.group(1)) |
| abs_text = re.sub(r"\s+", " ", abs_text).strip() |
| return title.group(1), title.group(2).strip(), sub.group(1).strip(), abs_text |
|
|
|
|
| MONTHS = {m: i + 1 for i, m in enumerate( |
| "Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec".split())} |
|
|
|
|
| def iso(date_str): |
| d, mon, y = date_str.split() |
| return f"{y}-{MONTHS[mon]:02d}-{int(d):02d}" |
|
|
|
|
| def soft_threshold_argmin(lam): |
| """argmin over x of (x-1)^2 + lam*|x|, exact for lam rational.""" |
| cand = 1 - lam / 2 |
| return cand if cand > 0 else Fraction(0) |
|
|
|
|
| def halved_soft_threshold_argmin(t): |
| """argmin over x of (1/2)(x-1)^2 + t*|x|, derived independently: |
| stationarity on x>0 gives x-1+t=0, so argmin = max(0, 1-t).""" |
| cand = 1 - t |
| return cand if cand > 0 else Fraction(0) |
|
|
|
|
| def main(): |
| print("Claim 3 / Corollary 26 priority + display audit (exact arithmetic)") |
| for f in sorted(SRC.iterdir()): |
| print(f" source {f.name} sha256={sha(f)[:16]}...") |
|
|
| print("Step 1-2: primary-source date and content audit") |
| prior = [] |
| for name in ("arxiv_2110.13086_abs.html", "arxiv_2312.14141_abs.html"): |
| arxiv_id, title, sub, abs_text = parse_abs(SRC / name) |
| v1 = iso(sub) |
| has_lasso = "lasso" in abs_text.lower() |
| has_quantum = "quantum" in abs_text.lower() |
| penalized = "penalty" in abs_text.lower() or "penalised" in abs_text.lower() |
| earlier = v1 < TARGET_V1 |
| prior.append(earlier and has_lasso and has_quantum) |
| print(f" arXiv:{arxiv_id} v1={v1} earlier_than_target={earlier}") |
| print(f" title: {title}") |
| print( |
| f" abstract mentions quantum={has_quantum} lasso={has_lasso} " |
| f"penalized-form={penalized}" |
| ) |
| print(f" prior quantum-Lasso records earlier than target: {sum(prior)} of 2") |
|
|
| print("Step 3: objective bijection, exact 1-d soft-threshold instance") |
| t = Fraction(1, 2) |
| m1 = halved_soft_threshold_argmin(t) |
| m2 = soft_threshold_argmin(2 * t) |
| print( |
| f" argmin[(1/2)(x-1)^2+({t})|x|] = {m1}; " |
| f"argmin[(x-1)^2+({2*t})|x|] = {m2}; " |
| f"equal under lambda_target=2*t: {m1 == m2}" |
| ) |
|
|
| print("Step 4: target self-citation of prior quantum Lasso work") |
| exc = (SRC / "target_2509.24757_excerpts.txt").read_text() |
| quote = "studied by Chen and de Wolf" |
| print(f" excerpt contains '{quote}': {quote in exc}") |
| print(f" excerpt contains 'quantum algorithms for Lasso': " |
| f"{'quantum algorithms for Lasso' in exc}") |
|
|
| print("Step 5: printed-inequality counterexample, exact fractions") |
| lam = Fraction(100) |
| eps = Fraction(1, 10) |
| |
| x = soft_threshold_argmin(lam) |
| left_min = (x - 1) ** 2 + lam * abs(x) |
| |
| y = soft_threshold_argmin(Fraction(1)) |
| right_min = (y - 1) ** 2 + abs(y) |
| bound = (1 + eps) * right_min |
| print(f" min_x[(x-1)^2+100|x|] = {left_min} at x={x}") |
| print(f" (1+eps)*min_y[(y-1)^2+|y|] = {bound} at y={y}") |
| print( |
| f" printed guarantee requires {left_min} <= {bound}: " |
| f"{left_min <= bound}; impossibility gap = {left_min - bound}" |
| ) |
|
|
| print("Step 6: negative controls") |
| ridge_only_abs = "quantum ridge regression algorithm for prediction" |
| ctrl1 = "lasso" in ridge_only_abs.lower() |
| print( |
| " Ridge-only earlier record (Shao 2023, IJMLC 14(1):117-124) " |
| f"mentions lasso={ctrl1} -> does not falsify firstness: {not ctrl1}" |
| ) |
| ctrl2 = TARGET_V1 < TARGET_V1 |
| print(f" target-vs-itself earlier_than_target={ctrl2} -> not prior art: " |
| f"{not ctrl2}") |
|
|
| verdict = sum(prior) >= 1 and m1 == m2 and left_min > bound |
| print( |
| "AUDIT RESULT: firstness falsified by >=1 earlier primary source " |
| f"(found {sum(prior)}), display inequality falsified exactly: {verdict}" |
| ) |
| fp = f"{sum(prior)}|{m1}|{left_min}|{bound}" |
| print(f"RESULTS_SHA256={hashlib.sha256(fp.encode()).hexdigest()}") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
