File size: 3,957 Bytes
848d4b7 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 | #!/usr/bin/env python3
"""
Validator for problem 105: Three Mutually Orthogonal Latin Squares of Order 10
Validates that three 10×10 Latin squares L1, L2, L3 are:
1. Each a valid Latin square (each row/column contains each symbol exactly once)
2. Mutually orthogonal (superimposing any two gives all n² ordered pairs)
Expected input format:
{"squares": [L1, L2, L3]} where each Li is a 10×10 matrix with entries 0-9
or [L1, L2, L3]
"""
import argparse
from typing import Any
import numpy as np
from . import ValidationResult, load_solution, output_result, success, failure
TARGET_ORDER = 10
NUM_SQUARES = 3
def is_latin_square(L: np.ndarray, n: int) -> tuple[bool, str]:
"""Check if L is a valid n×n Latin square."""
if L.shape != (n, n):
return False, f"Wrong shape: {L.shape}, expected ({n}, {n})"
# Check all entries are in valid range
if not np.all((L >= 0) & (L < n)):
return False, "Entries must be in range [0, n-1]"
# Check each row has all symbols
for i in range(n):
if len(set(L[i, :])) != n:
return False, f"Row {i} does not contain all symbols"
# Check each column has all symbols
for j in range(n):
if len(set(L[:, j])) != n:
return False, f"Column {j} does not contain all symbols"
return True, "Valid Latin square"
def are_orthogonal(L1: np.ndarray, L2: np.ndarray, n: int) -> tuple[bool, str]:
"""Check if two Latin squares are orthogonal."""
# Superimpose and check all n² ordered pairs appear
pairs = set()
for i in range(n):
for j in range(n):
pair = (int(L1[i, j]), int(L2[i, j]))
if pair in pairs:
return False, f"Duplicate pair {pair} found"
pairs.add(pair)
if len(pairs) != n * n:
return False, f"Expected {n*n} pairs, found {len(pairs)}"
return True, "Orthogonal"
def validate(solution: Any) -> ValidationResult:
"""
Validate three mutually orthogonal Latin squares of order 10.
Args:
solution: Dict with 'squares' key or list of 3 matrices
Returns:
ValidationResult with success/failure
"""
try:
if isinstance(solution, dict) and 'squares' in solution:
squares_data = solution['squares']
elif isinstance(solution, list) and len(solution) == NUM_SQUARES:
squares_data = solution
else:
return failure(f"Invalid format: expected dict with 'squares' or list of {NUM_SQUARES} matrices")
if len(squares_data) != NUM_SQUARES:
return failure(f"Expected {NUM_SQUARES} Latin squares, got {len(squares_data)}")
squares = [np.array(s, dtype=np.int64) for s in squares_data]
except (ValueError, TypeError) as e:
return failure(f"Failed to parse squares: {e}")
n = TARGET_ORDER
# Validate each is a Latin square
for i, L in enumerate(squares):
valid, msg = is_latin_square(L, n)
if not valid:
return failure(f"Square {i+1} is not a valid Latin square: {msg}")
# Check pairwise orthogonality
for i in range(NUM_SQUARES):
for j in range(i + 1, NUM_SQUARES):
orth, msg = are_orthogonal(squares[i], squares[j], n)
if not orth:
return failure(f"Squares {i+1} and {j+1} are not orthogonal: {msg}")
return success(
f"Verified: {NUM_SQUARES} mutually orthogonal Latin squares of order {n}",
order=n, num_squares=NUM_SQUARES
)
def main():
parser = argparse.ArgumentParser(description='Validate 3 MOLS of order 10')
parser.add_argument('solution', help='Solution as JSON string or path to JSON file')
parser.add_argument('--verbose', '-v', action='store_true', help='Verbose output')
args = parser.parse_args()
solution = load_solution(args.solution)
result = validate(solution)
output_result(result)
if __name__ == '__main__':
main()
|