slackbar.py

"""
slackbar.py -- the class step's slack: is c_inf one low-side test at
the one c below the overlap reader's c_ov, in q's?

QUESTION. classform.py reads c_inf at decide.py's 136 as the least c
with pinned moves at which every zero-reply piece passes: no closed end
in the hull, and some end E with G-range low > G_E + h- and high < G_E
+ h+. Below c_inf the failures sit on the low side (classform's
NOTICED), and at the 48 c_inf is c_ov or c_ov - 1 (keyweld.py's Q1),
c_ov the least c with m (P_(c+1) + P_(c+2)) <= P_2 at every phase,
P_k = |theta_(t+k) / theta_(t-1)|. (Q) At the 136, is c_inf decided by
one c, c_ov - 1, and the low side alone, and does that side read in
integers: the records n+-(L), the end's G and the floor -(a_(t+1) + 1)
(+ m q_c on the reduced flag), no kappa_t?

DERIVED BY HAND (before the engine). At phase t write a_k = a_(t+k),
q_k = U_k, P_k as above (P_(-1) = 1, P_0 = r_t, P_(k+1) = P_(k-1) -
a_(k+1) P_k), y(K_k) = (-1)^(k+1) P_k, Z(G, H) = G + kappa_t y (so
lambda_t = 1 - kappa_t r_t).
  THE FLOOR. Z_lo(t, F) = -Z(a_1 + 1, 1) = -(a_1 + 1) + kappa_t (P_0
  - P_1), as 1 - a_1 r_t = P_1; P_0 - P_1 is in (0, 1), so Z_lo(t, F)
  lies in (-(a_1 + 1), -a_1). The G-range low is floor(Z_lo - kappa_t
  y_b), y_b the piece's top, |y_b| < 1 and 0 < kappa_t < 1, so on the
  full flag it is -(a_1 + 1) + d, d in {-1, 0, 1}. On the reduced flag
  Z_lo gains m Z(K_c) = m q_c + m kappa_t (-1)^(c+1) P_c, whose second
  term can pass 1 (golden x9, c = 1: 9 kappa_t P_1 = 9 (0.447) (0.382) =
  1.54, a c without pinned moves there), so the crude floor -(a_1 + 1)
  + m q_c is off by at most 1 + ceil(m kappa_t P_c).
  THE ENDS. From E_b(e) = m K_O + e K_1, G_b = m q_O + e a_1; from
  E_a(e) = m K_E - K_2 + e K_1, G_a = m q_E - q_2 + e a_1; a clipped
  end is the window's key end (classform.py's win_keys). The low side
  passes at E_b iff n-(L) > G_b - G_lo and at E_a iff n+(L) > G_a -
  G_lo, L the clipped piece's length, n+- r_t's records
  (firstreturn.py's three_gap). G_E grows with e by a_1 while L is one
  length for every unclipped gap, so the last unclipped gap of a phase
  is the hardest; G_lo is lowest on the full flag.
  WHY ONE c. Gaps exist at c iff L(c, t) = m (P_(c+1) + P_(c+2)) - P_2
  > 0 at some phase (keyweld.c_ov tests L(c, t) / r_t at phase t + 1,
  as m (P_c + P_(c+1)) <= P_1 in its P[k + 1] = P_k); at c_ov none
  does, so the gap step closes and c_inf <= c_ov (keyweld.py: the gap
  step derived, the endpoint step and the reduced flag read, not
  derived). That c_inf >= c_ov - 1 is not derived:
  it is (P1)'s question, the TRANSPLANT from the 48. At c_ov - 1 the
  open L are the least positive ones, so the n+-(L) the largest.

DESIGN (frozen before the engine). Cells: decide.py's 136, keyed by
full name. Per cell: c_inf = induct.least(F, m, "pin"); c_ov =
keyweld.c_ov; at c = c_ov - 1 (pinned moves required, else the bar
reads c_ov), classform.pieces at every (t, f) with hull.py-free forms
(hullform.forms), and three tests per piece:
  FORM: classform.passes (both sides, closed ends), the reference;
  LOW: some end passes its low side, the high side and closed ends
      dropped, G_lo the float floor(Z_lo - kappa_t y_b), its parts exact;
  CRUDE: LOW with G_lo := -(a_1 + 1) on the full flag, -(a_1 + 1) + m
      q_c on the reduced: integers and records only.
Each bar reads c_ov - 1 when every piece at c_ov - 1 passes it, else
c_ov. Margins printed: per cell the least over pieces of the best end's
low margin G_lo - (G_E + h-), exact, and the crude one.
PREDICTIONS. (P1) c_inf is c_ov or c_ov - 1 at every one of the 136.
(P2) LOW's c = c_inf at all 136 (NOTICED: no high-side failure below
c_inf; the 15 closed-end-only failures may sit at a (cell, c) where a
low-side failure also sits, unread). (P3) CRUDE's c = c_inf at all
136: the margins at c_ov - 1 are tens or more, past the floor's error.
KILL: "c_inf outside {c_ov - 1, c_ov} at n of 136"; "LOW's c != c_inf
at n of 136"; "CRUDE's c != c_inf at n of 136"; each n > 0 kills its
prediction, counted over all 136 and printed apart over the arm where
c_inf = c_ov - 1 (the cells where the bar must pass every piece).
CONTROLS (read before the verdicts). (a) keyweld.py's six cells with
c_inf = c_ov - 1 at the 48 (golden x2 c_ov 4, silver x2 3, bronze x3
3, V1 x2 4, V1 x3 5, V2 x4 5) and golden x2 .. x9's c_ov [4, 5, 5, 6,
6, 7, 7, 7]: the engine's c_ov and c_inf printed beside them. (b)
FORM's c, read at c_ov - 1 and c_ov alone, must equal c_inf wherever
(P1) holds: the reference through this engine's plumbing. THE PLANTS,
one per test, each in the direction it pushes: (c) LOW with h- halved
(stricter): its c rises above c_inf at some cell of the arm, or the
arm's margins all exceed half; (d) CRUDE with the floor lowered by m
q_c on the reduced flag (the full floor on both): printed beside (P3),
read for whether the reduced flag ever binds.

FINDINGS (copied from the run's prints).
  CONTROLS. (a) the six read (c_inf, c_ov): golden x2 (3, 4), silver
      x2 (2, 3), bronze x3 (2, 3), V1 x2 (3, 4), V1 x3 (4, 5), V2 x4 (4,
      5); golden's c_ov [4, 5, 5, 6, 6, 7, 7, 7]: keyweld's. (b) FORM's
      c != c_inf at 0 of 136. (c) h- halved: LOW's c != c_inf at 7 of
      the arm's 17: LOW can fire. (d) the full floor on both flags:
      CRUDE's c != c_inf at 0 of 136: the + m q_c term is never needed
      at the 136 (not that the reduced flag can be dropped). CRUDE has
      no plant of its own firing; it fails some piece at every cell
      read off the arm.
  The bars can fire only where c_ov - 1 has pinned moves: 120 of 136
      (the margin rows printed), 17 on the arm and 103 off it; at the
      other 16 every bar reads c_ov by construction.
  P1, KILL MISSED. c_inf outside {c_ov - 1, c_ov} at 0 of 136; the arm
      c_inf = c_ov - 1 holds 17 cells: the six above, [4] x4, [5] x5,
      [1, 3] x3, [1, 5] x4, [2, 3] x2, [2, 4] x2 and x7, [2, 5] x2, [3,
      4] x3, [3, 5] x3, [4, 5] x4.
  P2, KILL MISSED. LOW's c != c_inf at 0 of 136, 0 of the arm's 17.
  P3, KILL MISSED. CRUDE's c != c_inf at 0 of 136, 0 of 17.
  MARGINS at c_ov - 1, the least over pieces of the best end's low
      margin: on the arm 3 (golden x2) to 1032 ([4, 5] x4), off it -5
      (golden x3, x7) to -1968 ([1, 5] x9); crude equals exact or
      exceeds it by 1 at every cell, never crossing 0. P3's premise
      (margins of tens) failed: 3 at golden x2, 5 at V1 x2, -5 at golden
      x3 and x7; the kill missed all the same.
  So at decide.py's 136, c_inf = c_ov - 1 if c_ov - 1 has pinned moves
  and every zero-reply piece there has an end with n-+(L) > G_E - G_lo,
  G_lo = -(a_(t+1) + 1) (+ m q_c reduced), else c_ov: one c, one side,
  integers and r_t's records, the verdict 3 or more from its bar.

RUN RECORD. 1.1 s. The engine was written whole after the freeze and
run once. On shipping, the verdicts were made the exit code: 0 iff
control (a)'s six cells and golden's c_ov list, (b) at 0, (c) at 7 of
the arm's 17, (d) at 0, the 120 cells with pinned moves at c_ov - 1,
and P1 to P3 at 0 of 136 and 0 of 17 hold as printed.

Usage: python slackbar.py
"""

import math
import os
import sys
import time

os.environ.setdefault("OPENBLAS_NUM_THREADS", "1")
from flush import PERIODIC  # noqa: E402
from decide import FRESH  # noqa: E402
from induct import Field, Window, least  # noqa: E402
from hull import Coords  # noqa: E402
from keyweld import c_ov, lt  # noqa: E402
from firstreturn import three_gap  # noqa: E402
from hullform import forms, uv  # noqa: E402
from classform import pieces, passes  # noqa: E402


def low_margin(F, co, t, m, c, f, pc, zlo, crude=False, half=False,
               plant_d=False):
    """The best end's low margin G_lo - (G_E + h-), or None for a piece
    with no interior."""
    ya, yb, _ca, _cb, Ea, Eb = pc
    if not lt(ya, yb):
        return None
    npl, nmi = three_gap(F, t, yb - ya)
    if half:
        npl, nmi = npl / 2, nmi / 2
    if crude:
        glo = -(F.a(t + 1) + 1)
        if not f and not plant_d:
            glo += m * uv(F, t, c)[0]
    else:
        glo = math.floor(zlo.f - co.kap[t].f * yb.f)
    return max(glo - (Ea[0] - npl), glo - (Eb[0] - nmi))


def read_c(F, m, c, cell):
    """At c: (pinned, form_ok, low_ok, crude_ok, half_ok, plantd_ok,
    least exact margin, least crude margin)."""
    win = Window(F, m, c)
    _st, miss = win.pin_starts()
    if miss:
        return None
    co = Coords(F, m, c)
    ok = {"form": True, "low": True, "crude": True, "half": True,
          "pd": True}
    mex = mcr = None
    for t in range(F.p):
        fm = forms(F, co, m, c, t)
        for f in (True, False):
            zlo, zhi = fm[(f, True)], fm[(f, False)]
            for pc in pieces(F, t, m, c, f):
                ok["form"] &= passes(F, co, t, pc, zlo, zhi)
                me = low_margin(F, co, t, m, c, f, pc, zlo)
                if me is None:
                    continue
                mc = low_margin(F, co, t, m, c, f, pc, zlo, crude=True)
                mh = low_margin(F, co, t, m, c, f, pc, zlo, half=True)
                md = low_margin(F, co, t, m, c, f, pc, zlo, crude=True,
                                plant_d=True)
                ok["low"] &= me > 0
                ok["crude"] &= mc > 0
                ok["half"] &= mh > 0
                ok["pd"] &= md > 0
                mex = me if mex is None else min(mex, me)
                mcr = mc if mcr is None else min(mcr, mc)
    return ok, mex, mcr


def main():
    t0 = time.time()
    rows = []
    for name, per in list(PERIODIC) + list(FRESH):
        F = Field(per)
        for m in range(2, 10):
            cinf = least(F, m, "pin")
            cov = c_ov(F, m)
            r = read_c(F, m, cov - 1, name) if cov >= 1 else None
            bars = {}
            for k in ("form", "low", "crude", "half", "pd"):
                bars[k] = cov - 1 if (r is not None and r[0][k]) else cov
            rows.append((name, m, cinf, cov, bars,
                         r[1] if r else None, r[2] if r else None,
                         r is not None))
    n = len(rows)
    arm = [x for x in rows if x[2] == x[3] - 1]
    print("== CONTROLS")
    six = [("golden [1]", 2), ("silver [2]", 2), ("bronze [3]", 3),
           ("V1 [1, 1, 1, 2]", 2), ("V1 [1, 1, 1, 2]", 3),
           ("V2 [2, 1, 3, 1]", 4)]
    print("  (a) the six (alpha, m, c_inf, c_ov):",
          [(x[0].split()[0], x[1], x[2], x[3]) for x in rows
           if (x[0], x[1]) in six])
    print("      golden c_ov, m = 2 .. 9:",
          [x[3] for x in rows if x[0] == "golden [1]"])
    p1 = [x for x in rows if x[2] not in (x[3] - 1, x[3])]
    fb = [x for x in rows if x not in p1 and x[4]["form"] != x[2]]
    print(f"  (b) FORM's c != c_inf where P1 holds: {len(fb)} of "
          f"{n - len(p1)}; first: {[(x[0], x[1]) for x in fb[:6]]}")
    hb = [x for x in arm if x[4]["half"] != x[2]]
    print(f"  (c) THE PLANT h- halved: LOW's c != c_inf at {len(hb)} of "
          f"{len(arm)} on the arm, {sum(x[4]['half'] != x[2] for x in rows)}"
          f" of {n} in all")
    db = [x for x in rows if x[4]["pd"] != x[2]]
    print(f"  (d) THE PLANT full floor on both flags: CRUDE's c != c_inf "
          f"at {len(db)} of {n}")
    print("== MARGINS at c_ov - 1 (least over pieces of the best end's "
          "low margin; exact, crude)")
    for x in rows:
        if x[7]:
            print(f"    {x[0]:18s} x{x[1]} c_inf {x[2]} c_ov {x[3]} "
                  f"exact {x[5]} crude {x[6]}")
    print("== P1")
    print(f"  apart: {[(x[0], x[1], x[2], x[3]) for x in p1[:10]]}")
    print(f"  KILL: c_inf outside {{c_ov - 1, c_ov}} at {len(p1)} of {n}")
    kills = []
    for k, lab in (("low", "P2 LOW"), ("crude", "P3 CRUDE")):
        bad = [x for x in rows if x[4][k] != x[2]]
        kills.append((len(bad), sum(x in bad for x in arm)))
        print(f"== {lab}")
        print(f"  arm (c_inf = c_ov - 1): {kills[-1][1]} of "
              f"{len(arm)}; apart: {[(x[0], x[1], x[2], x[4][k]) for x in bad[:8]]}")
        print(f"  KILL: {k.upper()}'s c != c_inf at {len(bad)} of {n}")
    checks = [
        [(x[0].split()[0], x[1], x[2], x[3]) for x in rows
         if (x[0], x[1]) in six] == [
            ("golden", 2, 3, 4), ("silver", 2, 2, 3), ("bronze", 3, 2, 3),
            ("V1", 2, 3, 4), ("V1", 3, 4, 5), ("V2", 4, 4, 5)],
        [x[3] for x in rows if x[0] == "golden [1]"]
        == [4, 5, 5, 6, 6, 7, 7, 7],
        (n, len(arm), len(fb), len(hb), len(db)) == (136, 17, 0, 7, 0),
        sum(x[7] for x in rows) == 120,
        (len(p1), kills) == (0, [(0, 0), (0, 0)]),
    ]
    print(f"  {sum(checks)}/{len(checks)} checks as recorded, "
          f"{time.time() - t0:.1f} s")
    sys.exit(0 if all(checks) else 1)


if __name__ == "__main__":
    main()