| |
| """ |
| Validator for problem 047a: Improve a 10D Lattice Packing (Λ10 Baseline) |
| |
| Input: {"basis": [[...],[...],...]} 10x10 matrix whose ROWS are basis vectors in R^10. |
| |
| The lattice is L = { z^T B : z in Z^10 }. |
| |
| We compute the shortest nonzero vector length via Schnorr-Euchner enumeration |
| on an LLL-reduced basis, then compute packing density: |
| |
| density = Vol(Ball_10(r)) / covolume |
| r = (shortest_vector_length)/2 |
| covolume = |det(B)| |
| |
| Metric key: "packing_density" (maximize). |
| """ |
|
|
| import argparse |
| import math |
| from typing import Any, Tuple, Optional |
|
|
| import numpy as np |
|
|
| from . import ValidationResult, load_solution, output_result, success, failure |
|
|
|
|
| DIMENSION = 10 |
| TOL_DET = 1e-12 |
| MAX_ABS_ENTRY = 1e3 |
| MAX_COND = 1e10 |
|
|
|
|
| def sphere_volume(r: float, n: int) -> float: |
| return (math.pi ** (n / 2.0)) * (r ** n) / math.gamma(n / 2.0 + 1.0) |
|
|
|
|
| def gram_schmidt_cols(B: np.ndarray) -> Tuple[np.ndarray, np.ndarray, np.ndarray]: |
| """ |
| Classical Gram-Schmidt on column basis. |
| |
| Args: |
| B: (m,n) with columns as basis vectors. |
| Returns: |
| Bstar: (m,n) orthogonalized columns |
| mu: (n,n) GS coefficients |
| bstar_norm2: (n,) squared norms of Bstar columns |
| """ |
| m, n = B.shape |
| Bstar = np.zeros((m, n), dtype=np.float64) |
| mu = np.zeros((n, n), dtype=np.float64) |
| bstar_norm2 = np.zeros(n, dtype=np.float64) |
|
|
| for i in range(n): |
| v = B[:, i].copy() |
| for j in range(i): |
| denom = bstar_norm2[j] |
| if denom <= 0: |
| mu[i, j] = 0.0 |
| continue |
| mu[i, j] = float(np.dot(B[:, i], Bstar[:, j]) / denom) |
| v -= mu[i, j] * Bstar[:, j] |
| Bstar[:, i] = v |
| bstar_norm2[i] = float(np.dot(v, v)) |
| if bstar_norm2[i] <= 0: |
| bstar_norm2[i] = 0.0 |
| return Bstar, mu, bstar_norm2 |
|
|
|
|
| def lll_reduce_cols(B: np.ndarray, delta: float = 0.99, max_iter: int = 5000) -> np.ndarray: |
| """ |
| Basic floating-point LLL reduction on column basis (10D only). |
| """ |
| B = B.copy().astype(np.float64) |
| n = B.shape[1] |
| it = 0 |
| k = 1 |
| Bstar, mu, bstar_norm2 = gram_schmidt_cols(B) |
|
|
| while k < n and it < max_iter: |
| it += 1 |
|
|
| |
| for j in range(k - 1, -1, -1): |
| q = int(np.round(mu[k, j])) |
| if q != 0: |
| B[:, k] -= q * B[:, j] |
|
|
| Bstar, mu, bstar_norm2 = gram_schmidt_cols(B) |
| if bstar_norm2[k] == 0 or bstar_norm2[k - 1] == 0: |
| return B |
|
|
| |
| if bstar_norm2[k] >= (delta - mu[k, k - 1] ** 2) * bstar_norm2[k - 1]: |
| k += 1 |
| else: |
| B[:, [k, k - 1]] = B[:, [k - 1, k]] |
| Bstar, mu, bstar_norm2 = gram_schmidt_cols(B) |
| k = max(k - 1, 1) |
|
|
| return B |
|
|
|
|
| def _enum_se( |
| R: np.ndarray, |
| target: np.ndarray, |
| best: float, |
| require_nonzero: bool = False |
| ) -> Tuple[float, Optional[np.ndarray]]: |
| """ |
| Schnorr-Euchner enumeration for CVP/SVP in upper-triangular coordinates. |
| |
| Minimizes ||R z - target||^2 over z in Z^n. |
| If require_nonzero=True, excludes z=0 (useful for SVP with target=0). |
| """ |
| n = R.shape[0] |
| z = np.zeros(n, dtype=np.int64) |
| best_z: Optional[np.ndarray] = None |
|
|
| def rec(k: int, dist2: float): |
| nonlocal best, best_z |
| if dist2 >= best: |
| return |
| if k < 0: |
| if require_nonzero and np.all(z == 0): |
| return |
| best = dist2 |
| best_z = z.copy() |
| return |
|
|
| s = float(target[k]) |
| if k + 1 < n: |
| s -= float(np.dot(R[k, k + 1 :], z[k + 1 :])) |
|
|
| Rkk = float(R[k, k]) |
| if abs(Rkk) < 1e-18: |
| rec(k - 1, dist2 + s * s) |
| return |
|
|
| c = s / Rkk |
| m = int(np.round(c)) |
|
|
| step = 0 |
| while True: |
| if step == 0: |
| candidates = [m] |
| d = abs(c - m) |
| if dist2 + (Rkk * d) ** 2 >= best: |
| break |
| else: |
| d_plus = abs(c - (m + step)) |
| d_minus = abs(c - (m - step)) |
| if dist2 + (Rkk * min(d_plus, d_minus)) ** 2 >= best: |
| break |
| candidates = [m + step, m - step] |
|
|
| for t in candidates: |
| z[k] = int(t) |
| diff = s - Rkk * float(t) |
| rec(k - 1, dist2 + diff * diff) |
|
|
| step += 1 |
|
|
| rec(n - 1, 0.0) |
| return best, best_z |
|
|
|
|
| def shortest_vector_length(B_cols: np.ndarray) -> float: |
| """ |
| Compute shortest nonzero vector length of lattice generated by columns of B_cols. |
| """ |
| B_red = lll_reduce_cols(B_cols) |
| Q, R = np.linalg.qr(B_red) |
|
|
| |
| col_norm2 = np.sum(B_red * B_red, axis=0) |
| best = float(np.min(col_norm2)) |
| if not np.isfinite(best) or best <= 0: |
| best = float("inf") |
|
|
| best, z_best = _enum_se(R, target=np.zeros(DIMENSION), best=best, require_nonzero=True) |
| if z_best is None or not np.isfinite(best) or best <= 0: |
| return float(np.sqrt(np.min(col_norm2))) |
|
|
| return float(np.sqrt(best)) |
|
|
|
|
| def validate(solution: Any) -> ValidationResult: |
| try: |
| if isinstance(solution, dict) and "basis" in solution: |
| basis_data = solution["basis"] |
| elif isinstance(solution, list): |
| basis_data = solution |
| else: |
| return failure("Invalid format: expected dict with 'basis' or 2D list") |
|
|
| B_rows = np.array(basis_data, dtype=np.float64) |
| except (ValueError, TypeError) as e: |
| return failure(f"Failed to parse basis: {e}") |
|
|
| if B_rows.shape != (DIMENSION, DIMENSION): |
| return failure(f"Basis must be {DIMENSION}x{DIMENSION}, got {B_rows.shape}") |
|
|
| if not np.all(np.isfinite(B_rows)): |
| return failure("Basis contains non-finite entries") |
| if float(np.max(np.abs(B_rows))) > MAX_ABS_ENTRY: |
| return failure(f"Basis entries too large (>|{MAX_ABS_ENTRY}|)") |
|
|
| |
| B_cols = B_rows.T.copy() |
|
|
| det = float(np.linalg.det(B_cols)) |
| if not np.isfinite(det) or abs(det) < TOL_DET: |
| return failure("Basis is singular (determinant ~ 0)") |
| covolume = abs(det) |
|
|
| cond = float(np.linalg.cond(B_cols)) |
| if not np.isfinite(cond) or cond > MAX_COND: |
| return failure(f"Basis is ill-conditioned (cond={cond:.3e} > {MAX_COND:g})") |
|
|
| min_len = shortest_vector_length(B_cols) |
| if not np.isfinite(min_len) or min_len <= 0: |
| return failure("Failed to compute a valid shortest vector length") |
|
|
| packing_radius = min_len / 2.0 |
| density = sphere_volume(packing_radius, DIMENSION) / covolume |
|
|
| return success( |
| f"Lattice in R^{DIMENSION}: shortest vector ~ {min_len:.8f}, packing density ~ {density:.12f}", |
| dimension=DIMENSION, |
| determinant=float(det), |
| covolume=float(covolume), |
| min_vector_length=float(min_len), |
| packing_radius=float(packing_radius), |
| packing_density=float(density), |
| metric_key="packing_density", |
| ) |
|
|
|
|
| def main(): |
| parser = argparse.ArgumentParser(description="Validate lattice sphere packing in dimension 10") |
| parser.add_argument("solution", help="Solution as JSON string or path to JSON file") |
| args = parser.parse_args() |
|
|
| sol = load_solution(args.solution) |
| result = validate(sol) |
| output_result(result) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
