cli.py

"""
cli.py — Command-line interface for the Claude's Cycles system.

Usage:
    python -m claudecycles                   # demo all modes
    python -m claudecycles verify 3          # verify known m=3 solution
    python -m claudecycles verify 5          # verify known m=5 solution
    python -m claudecycles solve 7           # find+verify m=7
    python -m claudecycles solve 9           # find+verify m=9
    python -m claudecycles analyze 3         # deep analysis of m=3
    python -m claudecycles theorem           # verify all four theorems
    python -m claudecycles compare 3 5 7     # compare solutions across m

All results are auto-verified before printing.
"""

from __future__ import annotations
import sys
from typing import List

from .solutions import get_solution, get_solution_table, known_m_values, construct_for_odd_m
from .search import find_sigma, RandomSearch
from .analysis import SolutionAnalysis, compare_across_m
from .fiber import even_m_impossibility_check, analyze_Q_structure, compose_levels
from .analysis import extract_sigma_table
from .core import verify_sigma


# =========================================================================== #
# Commands
# =========================================================================== #

def cmd_verify(m: int):
    """Verify a known hardcoded solution."""
    sigma = get_solution(m)
    if sigma is None:
        print(f"No hardcoded solution for m={m}. Known: {known_m_values()}")
        print(f"Use 'solve {m}' to find one.")
        return
    print(f"\nVerifying hardcoded solution m={m}...")
    result = verify_sigma(sigma, m)
    print(result)
    if result.is_valid:
        table = get_solution_table(m)
        print(f"\nSigma table [s][j] → perm:")
        for s in range(m):
            print(f"  s={s}: {[table[s][j] for j in range(m)]}")


def cmd_solve(m: int, strategy: str = "auto", seed: int = 42,
              max_iter: int = 200_000):
    """Find and verify a solution for given m."""
    print(f"\nSolving m={m}  strategy={strategy}  seed={seed}...")
    sigma = find_sigma(m, strategy=strategy, seed=seed,
                       max_iter=max_iter, verbose=True)
    if sigma is None:
        print(f"❌ No solution found for m={m}")
        return
    result = verify_sigma(sigma, m)
    print(result)


def cmd_analyze(m: int):
    """Deep mathematical analysis of a solution."""
    sigma = get_solution(m)
    if sigma is None:
        print(f"No hardcoded solution for m={m}. Searching...")
        sigma = find_sigma(m, verbose=True)
    if sigma is None:
        print(f"Could not find solution for m={m}")
        return
    a = SolutionAnalysis(sigma, m).run()
    print(a.report(verbose=True))


def cmd_theorem():
    """Demonstrate and verify all four theorems."""
    print()
    print("=" * 64)
    print("CLAUDE'S CYCLES: FOUR THEOREMS")
    print("=" * 64)

    print("""
Theorem 1 — Twisted Translation Structure
  For any column-uniform sigma, the composed fiber permutation satisfies:
  Q_c(i,j) = (i + b_c(j),  j + r_c) mod m
""")
    for m in [3, 5]:
        table = get_solution_table(m)
        from .fiber import compose_levels, analyze_Q_structure
        Qs = compose_levels(table, m)
        qa = analyze_Q_structure(Qs, m)
        print(f"  m={m}: all_twisted={qa['all_twisted']}  r_values={qa.get('r_values','—')}")

    print("""
Theorem 2 — Single-Cycle Conditions
  Q_c is a Hamiltonian m²-cycle ⟺ gcd(r_c,m)=1  AND  gcd(Σb_c,m)=1
""")
    from .fiber import verify_single_cycle_conditions
    from math import gcd
    for m, b_vals, r_vals in [
        (3, [[1,2,2],[0,2,0],[1,0,1]], [1,1,1]),
        (5, None, None),
    ]:
        if b_vals is None:
            continue
        print(f"  m={m}:")
        for c in range(3):
            chk = verify_single_cycle_conditions(r_vals[c], b_vals[c], m)
            print(f"    Cycle {c}: r={r_vals[c]} b={b_vals[c]} "
                  f"cond_a={'✅' if chk['condition_a'] else '❌'} "
                  f"cond_b={'✅' if chk['condition_b'] else '❌'}")

    print("""
Theorem 3 — Existence for All Odd m > 2
  For odd m, valid (r₀,r₁,r₂) with each r_c coprime to m and Σr_c=m always exists.
  Example: (1, m-2, 1) works whenever m is odd and gcd(m-2,m)=gcd(2,m)=1
""")
    from math import gcd
    for m in [3, 5, 7, 9, 11, 13, 15]:
        r0, r1, r2 = 1, m-2, 1
        ok = gcd(r0,m)==1 and gcd(r1,m)==1 and gcd(r2,m)==1 and r0+r1+r2==m
        print(f"  m={m}: (1,{m-2},1) → gcd_ok={[gcd(r,m)==1 for r in [r0,r1,r2]]} "
              f"sum={r0+r1+r2} → valid={'✅' if ok else '❌'}")

    print("""
Theorem 4 — Impossibility for Even m
  For even m > 2: coprime-to-m elements are all odd.
  Sum of 3 odd numbers is ODD ≠ EVEN = m. Therefore no column-uniform
  fiber construction exists for even m.
""")
    for m in [4, 6, 8, 10, 12, 16]:
        result = even_m_impossibility_check(m)
        print(f"  m={m}: all_coprime_odd={result['all_coprime_are_odd']} "
              f"→ proved_impossible={result['impossibility_proved']} ✅")


def cmd_compare(m_values: List[int]):
    """Compare solutions across multiple m values."""
    analyses = {}
    for m in m_values:
        sigma = get_solution(m)
        if sigma is None:
            print(f"Searching for m={m}...")
            sigma = find_sigma(m, verbose=False)
        if sigma is None:
            print(f"  Could not find m={m}, skipping.")
            continue
        analyses[m] = SolutionAnalysis(sigma, m).run()
    print()
    print(compare_across_m(analyses))


def cmd_demo():
    """Full demo: verify known solutions, analyze, run theorems."""
    print("=" * 64)
    print("CLAUDE'S CYCLES — FULL SYSTEM DEMO")
    print("=" * 64)
    print("\n[1] Verifying known solutions...")
    for m in known_m_values():
        cmd_verify(m)
    print("\n[2] Deep analysis of m=3...")
    cmd_analyze(3)
    print("\n[3] Theorem verification...")
    cmd_theorem()
    print("\n[4] Finding m=7 (random search)...")
    cmd_solve(7)


# =========================================================================== #
# Entry point
# =========================================================================== #

def main(args: List[str] = None):
    if args is None:
        args = sys.argv[1:]

    if not args:
        cmd_demo()
        return

    cmd = args[0].lower()

    if cmd == "verify":
        for m_str in args[1:]:
            cmd_verify(int(m_str))
    elif cmd == "solve":
        strategy = "auto"
        seed = 42
        m_vals = []
        i = 1
        while i < len(args):
            if args[i] == "--strategy" and i+1 < len(args):
                strategy = args[i+1]; i += 2
            elif args[i] == "--seed" and i+1 < len(args):
                seed = int(args[i+1]); i += 2
            else:
                m_vals.append(int(args[i])); i += 1
        for m in m_vals:
            cmd_solve(m, strategy=strategy, seed=seed)
    elif cmd == "analyze":
        for m_str in args[1:]:
            cmd_analyze(int(m_str))
    elif cmd == "theorem":
        cmd_theorem()
    elif cmd == "compare":
        cmd_compare([int(x) for x in args[1:]])
    elif cmd == "demo":
        cmd_demo()
    else:
        print(f"Unknown command: {cmd!r}")
        print(__doc__)
        sys.exit(1)


if __name__ == "__main__":
    main()