#!/usr/bin/env python3 """ Validator: Ramsey upper-bound certificate (split Theorem 13 validator), with arbitrary-degree polynomial corrections. Design: - For 0 < lambda <= LAMBDA_SPLIT, use the fixed analytic choices M(lambda) = lambda * exp(-lambda) Y(lambda) = exp(alpha_small) * (1 - X(lambda)) if X(lambda) <= 1/2 1 - X(lambda) * exp(-alpha_small) if X(lambda) > 1/2 with alpha_small = (0.17 - 0.033) * exp(-1). On this interval, admissibility (X(lambda), Y(lambda)) in R is taken from Lemma 14 / Theorem 1. The validator still checks F > 0, F' > 0, and the main inequality. - For LAMBDA_SPLIT <= lambda <= 1, the submission supplies piecewise-constant M and Y, and the validator checks condition (2) against the fixed inner approximation R_0. The polynomial correction is now p(lambda) = a1*lambda + a2*lambda^2 + ... + ad*lambda^d for any finite degree d >= 1, supplied as `polynomial_coeffs = [a1, ..., ad]`. For backward compatibility, `correction_coeffs` is also accepted and is treated as the same list. """ import argparse from typing import Any, Sequence import mpmath as mp from . import ValidationResult, load_solution, output_result, success, failure # --- Global constants --- LAMBDA_SPLIT = mp.mpf("1e-3") MAX_BREAKPOINTS = 500 BETA_R0 = mp.mpf("0.033") ALPHA_SMALL = (mp.mpf("0.17") - BETA_R0) / mp.e WORK_DPS = 100 mp.mp.dps = WORK_DPS mp.iv.dps = WORK_DPS iv = mp.iv LOG_SUBDIVS_SMALL = 120 LINEAR_SUBDIVS_LARGE = 32 # ---------- piecewise parsing ---------- def validate_piecewise(data: Any, name: str) -> tuple[list[mp.mpf], list[mp.mpf], str | None]: if not isinstance(data, dict): return [], [], f"{name}: expected dict with 'breakpoints' and 'values'" breakpoints = data.get("breakpoints") values = data.get("values") if breakpoints is None or values is None: return [], [], f"{name}: missing 'breakpoints' or 'values'" if not isinstance(breakpoints, list) or not isinstance(values, list): return [], [], f"{name}: 'breakpoints' and 'values' must be lists" if len(values) != len(breakpoints) + 1: return [], [], ( f"{name}: len(values) must be len(breakpoints)+1, " f"got {len(values)} vs {len(breakpoints)}" ) try: bp_all = [mp.mpf(str(b)) for b in breakpoints] val_all = [mp.mpf(str(v)) for v in values] except Exception as e: return [], [], f"{name}: invalid numeric value: {e}" # Discard breakpoints <= LAMBDA_SPLIT (and their preceding values). # If breakpoints[0..k-1] are all <= LAMBDA_SPLIT, the piecewise function # for lambda >= LAMBDA_SPLIT starts with values[k]. first_kept = 0 while first_kept < len(bp_all) and bp_all[first_kept] <= LAMBDA_SPLIT: first_kept += 1 bp_out = bp_all[first_kept:] val_out = [val_all[first_kept]] + val_all[first_kept + 1:] for i, b in enumerate(bp_out): if not mp.isfinite(b) or not (b < 1): return [], [], f"{name}: breakpoint {i} = {b} not in ({LAMBDA_SPLIT}, 1)" if len(bp_out) > MAX_BREAKPOINTS: return [], [], f"{name}: too many breakpoints ({len(bp_out)} > {MAX_BREAKPOINTS})" for i in range(len(bp_out) - 1): if not (bp_out[i] < bp_out[i + 1]): return [], [], ( f"{name}: breakpoints not strictly increasing at {i}: " f"{bp_out[i]} >= {bp_out[i + 1]}" ) for i, v in enumerate(val_out): if not mp.isfinite(v) or not (0 < v < 1): return [], [], f"{name}: value {i} = {v} not in (0,1)" return bp_out, val_out, None def eval_piecewise_scalar(breakpoints: list[mp.mpf], values: list[mp.mpf], lam: mp.mpf) -> mp.mpf: for i, b in enumerate(breakpoints): if lam < b: return values[i] return values[-1] # ---------- polynomial helpers ---------- def parse_polynomial_coeffs(solution: Any) -> tuple[list[mp.mpf], str | None]: raw = solution.get("polynomial_coeffs") legacy = solution.get("correction_coeffs") if raw is not None and legacy is not None: return [], "Provide only one of 'polynomial_coeffs' or 'correction_coeffs', not both" if raw is None: raw = legacy key = "correction_coeffs" else: key = "polynomial_coeffs" if not isinstance(raw, list) or len(raw) == 0: return [], f"'{key}' must be a nonempty list of numbers" try: coeffs = [mp.mpf(str(x)) for x in raw] except Exception as e: return [], f"Invalid polynomial coefficient: {e}" for i, c in enumerate(coeffs): if not mp.isfinite(c): return [], f"{key}[{i}] is not finite" return coeffs, None def horner_scalar(lam: mp.mpf, coeffs: Sequence[mp.mpf]) -> mp.mpf: """Evaluate p(lambda) = a1*lambda + ... + ad*lambda^d with Horner's rule.""" acc = mp.mpf("0") for a in reversed(coeffs): acc = (acc + a) * lam return acc def derivative_coeffs_scalar(coeffs: Sequence[mp.mpf]) -> list[mp.mpf]: return [mp.mpf(i + 1) * coeffs[i] for i in range(1, len(coeffs))] def horner_interval(lam, coeffs: Sequence[mp.mpf]): acc = iv.mpf(0) for a in reversed(coeffs): acc = (acc + iv.mpf(a)) * lam return acc def derivative_coeffs_interval(coeffs: Sequence[mp.mpf]): return [mp.mpf(i + 1) * coeffs[i] for i in range(1, len(coeffs))] # ---------- F and F' ---------- def p_scalar(lam: mp.mpf, coeffs: Sequence[mp.mpf]) -> mp.mpf: return horner_scalar(lam, coeffs) def dp_scalar(lam: mp.mpf, coeffs: Sequence[mp.mpf]) -> mp.mpf: dcoeffs = derivative_coeffs_scalar(coeffs) if not dcoeffs: return mp.mpf("0") return horner_scalar(lam, dcoeffs) def f_scalar(lam: mp.mpf, coeffs: Sequence[mp.mpf]) -> mp.mpf: base = (1 + lam) * mp.log(1 + lam) - lam * mp.log(lam) return base + p_scalar(lam, coeffs) * mp.e**(-lam) def fp_scalar(lam: mp.mpf, coeffs: Sequence[mp.mpf]) -> mp.mpf: p = p_scalar(lam, coeffs) dp = dp_scalar(lam, coeffs) + coeffs[0] # add constant term of p' return mp.log((1 + lam) / lam) + (dp - p) * mp.e**(-lam) def p_interval(lam, coeffs: Sequence[mp.mpf]): return horner_interval(lam, coeffs) def dp_interval(lam, coeffs: Sequence[mp.mpf]): dcoeffs = derivative_coeffs_interval(coeffs) if not dcoeffs: return iv.mpf(0) return horner_interval(lam, dcoeffs) def f_interval(lo: mp.mpf, hi: mp.mpf, coeffs: Sequence[mp.mpf]): lam = iv.mpf([lo, hi]) one = iv.mpf(1) base = (one + lam) * iv.log(one + lam) - lam * iv.log(lam) return base + p_interval(lam, coeffs) * iv.exp(-lam) def fp_interval(lo: mp.mpf, hi: mp.mpf, coeffs: Sequence[mp.mpf]): lam = iv.mpf([lo, hi]) one = iv.mpf(1) p = p_interval(lam, coeffs) dp = dp_interval(lam, coeffs) + iv.mpf(coeffs[0]) # add constant term of p' return iv.log((one + lam) / lam) + (dp - p) * iv.exp(-lam) # ---------- R_0 boundary function ---------- def U(mu: mp.mpf) -> mp.mpf: g = (-mp.mpf("0.25") * mu + BETA_R0 * mu**2 + mp.mpf("0.08") * mu**3) * mp.e**(-mu) return g + (1 + mu) * mp.log(1 + mu) - mu * mp.log(mu) def Up(mu: mp.mpf) -> mp.mpf: s = -mp.mpf("0.25") * mu + BETA_R0 * mu**2 + mp.mpf("0.08") * mu**3 sp = -mp.mpf("0.25") + 2 * BETA_R0 * mu + mp.mpf("0.24") * mu**2 return mp.log((1 + mu) / mu) + mp.e**(-mu) * (sp - s) U1 = U(mp.mpf(1)) UP1 = Up(mp.mpf(1)) A1 = U1 - UP1 def A_of_mu(mu: mp.mpf) -> mp.mpf: return U(mu) - mu * Up(mu) def _bracket_A(a: mp.mpf) -> tuple[mp.mpf, mp.mpf]: """Bisect to find mu* where A(mu*) = a. Returns bracket [lo, hi].""" lo = mp.mpf("1e-60") hi = mp.mpf(1) for _ in range(200): mid = (lo + hi) / 2 if A_of_mu(mid) < a: lo = mid else: hi = mid return lo, hi def _bracket_Up(a: mp.mpf) -> tuple[mp.mpf, mp.mpf]: """Bisect to find mu* where Up(mu*) = a. Returns bracket [lo, hi].""" lo = mp.mpf("1e-60") hi = mp.mpf(1) for _ in range(200): mid = (lo + hi) / 2 if Up(mid) > a: # Up is decreasing on (0,1] lo = mid else: hi = mid return lo, hi def _Up_interval(mu_lo: mp.mpf, mu_hi: mp.mpf) -> mp.mpf: """Rigorous upper bound on Up(mu) for mu in [mu_lo, mu_hi].""" mu = iv.mpf([mu_lo, mu_hi]) one = iv.mpf(1) s = -iv.mpf(mp.mpf("0.25")) * mu + iv.mpf(BETA_R0) * mu**2 + iv.mpf(mp.mpf("0.08")) * mu**3 sp = -iv.mpf(mp.mpf("0.25")) + iv.mpf(2 * BETA_R0) * mu + iv.mpf(mp.mpf("0.24")) * mu**2 result = iv.log((one + mu) / mu) + iv.exp(-mu) * (sp - s) return mp.mpf(result.b) # upper bound def _U_minus_mu_a_interval(mu_lo: mp.mpf, mu_hi: mp.mpf, a: mp.mpf) -> mp.mpf: """Rigorous upper bound on U(mu) - mu*a for mu in [mu_lo, mu_hi].""" mu = iv.mpf([mu_lo, mu_hi]) one = iv.mpf(1) g = (-iv.mpf(mp.mpf("0.25")) * mu + iv.mpf(BETA_R0) * mu**2 + iv.mpf(mp.mpf("0.08")) * mu**3) * iv.exp(-mu) u = g + (one + mu) * iv.log(one + mu) - mu * iv.log(mu) result = u - mu * iv.mpf(a) return mp.mpf(result.b) # upper bound def B_of_a(a: mp.mpf) -> mp.mpf: """Rigorous upper bound on the symmetric R_0 boundary threshold. If a = -log x and b = -log y, then the pair is accepted iff b >= B_of_a(a). This accounts for symmetry: either (x,y) in R_0 or (y,x) in R_0. Uses interval arithmetic over bisection brackets for rigorous bounds. """ if a >= U1: bu = mp.mpf(0) elif a > A1: bu = U1 - a else: lo, hi = _bracket_A(a) bu = _Up_interval(lo, hi) if a < UP1: bs = U1 - a else: lo, hi = _bracket_Up(a) bs = _U_minus_mu_a_interval(lo, hi, a) return max(mp.mpf(0), min(bu, bs)) # ---------- interval helpers ---------- def interval_lower(x) -> mp.mpf: return mp.mpf(x.a) def interval_upper(x) -> mp.mpf: return mp.mpf(x.b) def geometric_intervals(lo: mp.mpf, hi: mp.mpf, n: int) -> list[tuple[mp.mpf, mp.mpf]]: ratio = (hi / lo) ** (mp.mpf(1) / n) out: list[tuple[mp.mpf, mp.mpf]] = [] a = lo for _ in range(n): b = a * ratio out.append((a, b)) a = b out[-1] = (out[-1][0], hi) return out def linear_intervals(lo: mp.mpf, hi: mp.mpf, n: int) -> list[tuple[mp.mpf, mp.mpf]]: out: list[tuple[mp.mpf, mp.mpf]] = [] step = (hi - lo) / n a = lo for _ in range(n): b = a + step out.append((a, b)) a = b out[-1] = (out[-1][0], hi) return out # ---------- small-lambda proof machinery ---------- def polynomial_tail_bounds(coeffs: Sequence[mp.mpf], delta: mp.mpf) -> tuple[mp.mpf, mp.mpf]: """For 0 < lambda <= delta <= 1 and p(lambda)=sum_{i>=1} a_i lambda^i, use local small-regime bounds |p(lambda)| <= C0(delta) * lambda, |p'(lambda) - p(lambda)| <= C1(delta). Writing i = j+1 for coeffs[j] = a_i, we have |a_i lambda^i| <= |a_i| delta^(i-1) lambda, so C0(delta) = sum_{i>=1} |a_i| delta^(i-1). Also p'(lambda) - p(lambda) = sum_{i>=1} a_i lambda^(i-1) (i - lambda). For i=1, sup_{0=2 and delta <= 1, lambda^(i-1)(i-lambda) is increasing on (0,delta], so its supremum is delta^(i-1) (i-delta). Hence we may take C1(delta) = |a_1| + sum_{i>=2} |a_i| delta^(i-1) (i-delta). These are much sharper than the global (0,1] bounds and are sufficient because the analytic tail proof is only used on (0, lambda_tail] with lambda_tail <= delta. """ if not (0 < delta <= 1): raise ValueError(f"delta must satisfy 0 < delta <= 1, got {delta}") C0 = mp.mpf("0") C1 = mp.mpf("0") delta_pow = mp.mpf("1") # delta^(i-1) for j, a in enumerate(coeffs): i = j + 1 aa = abs(a) C0 += aa * delta_pow if i == 1: C1 += aa else: C1 += aa * delta_pow * (i - delta) delta_pow *= delta return C0, C1 def prove_small_tail_endpoint(coeffs: Sequence[mp.mpf]) -> mp.mpf: """Choose a tiny lambda_tail > 0 such that on (0, lambda_tail] the theorem conditions follow from simple analytic inequalities depending only on the submitted coefficients. """ C0, C1 = polynomial_tail_bounds(coeffs, LAMBDA_SPLIT) # If q = exp(-F'), M <= 1/4 and q <= 1/4, then # -log X <= M/(1-M) + q/((1-M)(1-q)) <= Acoef * lambda. logY_floor = mp.log(1 - mp.e**(-ALPHA_SMALL)) Acoef = mp.mpf("4") / 3 + (mp.mpf("16") / 9) * mp.e**(C1) candidates = [ LAMBDA_SPLIT, mp.mpf("0.25"), mp.e**(-(C1 + mp.log(4))), # ensures F' >= log 4, hence q <= 1/4 mp.e**(-(C0 + 1)), # ensures F > 0 from -lambda log lambda dominance mp.e**(-2 * (C0 + Acoef / 2 - logY_floor / 2 + 1)), ] return min(candidates) def validate_analytic_small_tail(coeffs: Sequence[mp.mpf]) -> tuple[bool, str, mp.mpf]: """Prove the theorem conditions on (0, lambda_tail] analytically.""" C0, C1 = polynomial_tail_bounds(coeffs, LAMBDA_SPLIT) logY_floor = mp.log(1 - mp.e**(-ALPHA_SMALL)) Acoef = mp.mpf("4") / 3 + (mp.mpf("16") / 9) * mp.e**(C1) lam = prove_small_tail_endpoint(coeffs) # F(lambda) >= -lambda log lambda - C0 lambda f_lb = -lam * mp.log(lam) - C0 * lam if f_lb <= 0: return False, f"analytic small-tail proof failed for F at lambda={lam}", lam # F'(lambda) >= -log lambda - C1 fp_lb = -mp.log(lam) - C1 if fp_lb <= mp.log(4): return False, f"analytic small-tail proof failed for F' at lambda={lam}", lam # With M=lambda e^{-lambda} and Y >= 1-exp(-alpha_small), # slack >= 1/2 lambda log(1/lambda) - O(lambda). slack_lb = ( -lam * mp.log(lam) - C0 * lam + mp.mpf("0.5") * (-Acoef * lam + lam * mp.log(lam) - lam**2 + lam * logY_floor) ) if slack_lb <= 0: return False, f"analytic small-tail proof failed for the main inequality at lambda={lam}", lam return True, "", lam def logX_interval_small(lo: mp.mpf, hi: mp.mpf, coeffs: Sequence[mp.mpf]): lam = iv.mpf([lo, hi]) one = iv.mpf(1) m_int = lam * iv.exp(-lam) fp_int = fp_interval(lo, hi, coeffs) return iv.log(one - m_int) + iv.log(one - iv.exp(-fp_int)) / (one - m_int) def small_branch_logY(logx_int): x_int = iv.exp(logx_int) half_log = mp.log(mp.mpf("0.5")) one = iv.mpf(1) # Entire interval in X > 1/2 branch. if interval_lower(logx_int) > half_log: return iv.log(one - x_int * mp.e**(-ALPHA_SMALL)), "upper" # Entire interval in X < 1/2 branch. if interval_upper(logx_int) < half_log: return ALPHA_SMALL + iv.log(one - x_int), "lower" return None, "split" def check_small_interval(lo: mp.mpf, hi: mp.mpf, coeffs: Sequence[mp.mpf], depth: int = 0) -> tuple[bool, str, mp.mpf]: if depth > 40: return False, f"small-lambda branch ambiguity persisted on [{lo}, {hi}]", mp.inf f_int = f_interval(lo, hi, coeffs) fp_int = fp_interval(lo, hi, coeffs) if interval_lower(f_int) <= 0: return False, f"F(lambda) <= 0 somewhere on [{lo}, {hi}]", interval_lower(f_int) if interval_lower(fp_int) <= 0: return False, f"F'(lambda) <= 0 somewhere on [{lo}, {hi}]", interval_lower(fp_int) lam = iv.mpf([lo, hi]) logx_int = logX_interval_small(lo, hi, coeffs) logy_int, branch = small_branch_logY(logx_int) if logy_int is None: mid = mp.sqrt(lo * hi) ok, msg, val = check_small_interval(lo, mid, coeffs, depth + 1) if not ok: return ok, msg, val return check_small_interval(mid, hi, coeffs, depth + 1) # The theorem requires Y in (0,1). In the lower branch Y = exp(alpha)*(1-X), # which can exceed 1 when X is very small. Reject if Y >= 1 anywhere. if interval_upper(logy_int) >= 0: return False, f"small-lambda Y(lambda) >= 1 somewhere on [{lo}, {hi}]", interval_upper(logy_int) half = iv.mpf(mp.mpf("0.5")) # Since M(lambda) = lambda e^{-lambda}, we have lambda log M = lambda(log lambda - lambda). slack_int = f_int + half * (logx_int + lam * (iv.log(lam) - lam) + lam * logy_int) if interval_lower(slack_int) <= 0: return False, f"main inequality failed somewhere on [{lo}, {hi}]", interval_lower(slack_int) return True, branch, interval_lower(slack_int) # ---------- large-lambda checks ---------- def check_large_interval(lo: mp.mpf, hi: mp.mpf, coeffs: Sequence[mp.mpf], m_const: mp.mpf, y_const: mp.mpf) -> tuple[bool, str, mp.mpf, mp.mpf]: f_int = f_interval(lo, hi, coeffs) fp_int = fp_interval(lo, hi, coeffs) if interval_lower(f_int) <= 0: return False, f"F(lambda) <= 0 somewhere on [{lo}, {hi}]", mp.inf, mp.inf if interval_lower(fp_int) <= 0: return False, f"F'(lambda) <= 0 somewhere on [{lo}, {hi}]", mp.inf, mp.inf lam = iv.mpf([lo, hi]) one = iv.mpf(1) m_iv = iv.mpf(m_const) # log X = log(1-M) + (1/(1-M)) log(1 - exp(-F')). logx_int = iv.log(one - m_iv) + iv.log(one - iv.exp(-fp_int)) / (one - m_iv) a_lo = -interval_upper(logx_int) # smallest possible a = -log X on this lambda-interval if a_lo <= 0: return False, f"X(lambda) >= 1 somewhere on [{lo}, {hi}]", mp.inf, mp.inf # Since B(a) is nonincreasing, b - B(a_lo) is a lower bound for the R_0 margin. # Use interval log for rigorous lower bound on b = -log(Y). b_const = -interval_upper(iv.log(iv.mpf(y_const))) r0_margin = b_const - B_of_a(a_lo) if r0_margin <= 0: return False, f"R_0 check failed somewhere on [{lo}, {hi}]", r0_margin, mp.inf half = iv.mpf(mp.mpf("0.5")) log_m_iv = iv.log(iv.mpf(m_const)) log_y_iv = iv.log(iv.mpf(y_const)) slack_int = f_int + half * (logx_int + lam * log_m_iv + lam * log_y_iv) if interval_lower(slack_int) <= 0: return False, f"main inequality failed somewhere on [{lo}, {hi}]", r0_margin, interval_lower(slack_int) return True, "", r0_margin, interval_lower(slack_int) # ---------- main validator ---------- def validate(solution: Any) -> ValidationResult: if not isinstance(solution, dict): return failure("Invalid format: expected dict") coeffs, err = parse_polynomial_coeffs(solution) if err: return failure(err) m_data = solution.get("M") if m_data is None: return failure("Missing 'M'") m_bp, m_vals, err = validate_piecewise(m_data, "M") if err: return failure(err) y_data = solution.get("Y") if y_data is None: return failure("Missing 'Y'") y_bp, y_vals, err = validate_piecewise(y_data, "Y") if err: return failure(err) # Small-lambda analytic tail near 0. ok, msg, tail = validate_analytic_small_tail(coeffs) if not ok: return failure(msg) worst_small_slack = mp.inf worst_large_r0_slack = mp.inf worst_large_main_slack = mp.inf # Interval proof on [tail, LAMBDA_SPLIT] using the fixed analytic small-lambda model. for lo, hi in geometric_intervals(tail, LAMBDA_SPLIT, LOG_SUBDIVS_SMALL): ok, msg, slack_lb = check_small_interval(lo, hi, coeffs) if not ok: return failure(msg) worst_small_slack = min(worst_small_slack, slack_lb) # Large-lambda partition: refine along the union of the M and Y breakpoints. large_edges = sorted(set(m_bp) | set(y_bp) | {mp.mpf(1)}) left = LAMBDA_SPLIT for right in large_edges: # No breakpoint lies inside (left, right), so M and Y are constant there. sample = mp.sqrt(left * right) if right / left > mp.mpf("1.2") else (left + right) / 2 m_const = eval_piecewise_scalar(m_bp, m_vals, sample) y_const = eval_piecewise_scalar(y_bp, y_vals, sample) for lo, hi in linear_intervals(left, right, LINEAR_SUBDIVS_LARGE): ok, msg, r0_lb, slack_lb = check_large_interval(lo, hi, coeffs, m_const, y_const) if not ok: return failure(msg) worst_large_r0_slack = min(worst_large_r0_slack, r0_lb) worst_large_main_slack = min(worst_large_main_slack, slack_lb) left = right f_at_1 = f_scalar(mp.mpf(1), coeffs) growth_base_c = mp.e**f_at_1 if not mp.isfinite(growth_base_c) or growth_base_c <= 0: return failure("Computed c is non-finite or non-positive") coeff_key = "polynomial_coeffs" if solution.get("polynomial_coeffs") is not None else "correction_coeffs" return success( f"Valid split certificate; c = e^{{F(1)}} = {mp.nstr(growth_base_c, 12)}; " f"{coeff_key} degree = {len(coeffs)}; " f"analytic tail endpoint = {mp.nstr(tail, 6)}; " f"worst small-lambda slack = {mp.nstr(worst_small_slack, 6)}; " f"worst large R_0 slack = {mp.nstr(worst_large_r0_slack, 6)}; " f"worst large main slack = {mp.nstr(worst_large_main_slack, 6)}", growth_base_c=float(growth_base_c), f_at_1=float(f_at_1), lambda_split=float(LAMBDA_SPLIT), polynomial_degree=len(coeffs), small_tail_endpoint=mp.nstr(tail, 20), worst_small_slack=mp.nstr(worst_small_slack, 20), worst_large_r0_slack=mp.nstr(worst_large_r0_slack, 20), worst_large_main_slack=mp.nstr(worst_large_main_slack, 20), ) def main(): parser = argparse.ArgumentParser( description="Validate Ramsey upper-bound certificate (split Theorem 13 validator; arbitrary polynomial degree)" ) parser.add_argument("solution", help="Solution as JSON string or path to JSON file") args = parser.parse_args() solution = load_solution(args.solution) result = validate(solution) output_result(result) if __name__ == "__main__": main()