something.myr

   1 use std
   2 use iter
   3
   4 use t
   5 use quiver
   6 use yakmo
   7
   8 use "expound"
   9 use "factorization-coords"
  10 use "kc"
  11 use "latex"
  12 use "M"
  13 use "mkQ"
  14 use "mutations"
  15 use "roots"
  16 use "types"
  17 use "util"
  18 use "verification"
  19
  20 const main = {args : byte[:][:]
  21         var dir = "wordtest"
  22         var input_kc = `C 2
  23         if args.len >= 2
  24                 dir = args[1]
  25         ;;
  26         if args.len >= 3
  27                 match parse_KC_type(args[2])
  28                 | `std.Ok k: input_kc = k
  29                 | `std.Err e: std.fatal("{}\n", e)
  30                 ;;
  31         ;;
  32
  33         if std.eq(dir, "forward")
  34                 var q = std.try(mk_Q(`F4))
  35                 std.get(quiver.find_vertex(q, "v1;1")).1.acoord = `std.Some std.try(yakmo.polynomialfromS("h31"))
  36                 std.get(quiver.find_vertex(q, "v2;1")).1.acoord = `std.Some std.try(yakmo.polynomialfromS("h31"))
  37                 std.get(quiver.find_vertex(q, "v3;1")).1.acoord = `std.Some std.try(yakmo.polynomialfromS("h31^2"))
  38                 std.get(quiver.find_vertex(q, "v4;1")).1.acoord = `std.Some std.try(yakmo.polynomialfromS("h31^2"))
  39
  40                 std.get(quiver.find_vertex(q, "v1;2")).1.acoord = `std.Some std.try(yakmo.polynomialfromS("h32"))
  41                 std.get(quiver.find_vertex(q, "v2;2")).1.acoord = `std.Some std.try(yakmo.polynomialfromS("h31 h32"))
  42                 std.get(quiver.find_vertex(q, "v3;2")).1.acoord = `std.Some std.try(yakmo.polynomialfromS("h31^2 h32^2"))
  43                 std.get(quiver.find_vertex(q, "v4;2")).1.acoord = `std.Some std.try(yakmo.polynomialfromS("h32^2"))
  44
  45                 std.get(quiver.find_vertex(q, "v1;3")).1.acoord = `std.Some std.try(yakmo.polynomialfromS("h31"))
  46                 std.get(quiver.find_vertex(q, "v2;3")).1.acoord = `std.Some std.try(yakmo.polynomialfromS("h31^2 h32"))
  47                 std.get(quiver.find_vertex(q, "v3;3")).1.acoord = `std.Some std.try(yakmo.polynomialfromS("h31^2 h32^2"))
  48                 std.get(quiver.find_vertex(q, "v4;3")).1.acoord = `std.Some std.try(yakmo.polynomialfromS("h31^2"))
  49
  50                 std.get(quiver.find_vertex(q, "v1;4")).1.acoord = `std.Some std.try(yakmo.polynomialfromS("h31 h32"))
  51                 std.get(quiver.find_vertex(q, "v2;4")).1.acoord = `std.Some std.try(yakmo.polynomialfromS("h31 h32"))
  52                 std.get(quiver.find_vertex(q, "v3;4")).1.acoord = `std.Some std.try(yakmo.polynomialfromS("h31^2 h32^2"))
  53                 std.get(quiver.find_vertex(q, "v4;4")).1.acoord = `std.Some std.try(yakmo.polynomialfromS("h31^2"))
  54
  55                 std.get(quiver.find_vertex(q, "v1;5")).1.acoord = `std.Some std.try(yakmo.polynomialfromS("h32"))
  56                 std.get(quiver.find_vertex(q, "v2;5")).1.acoord = `std.Some std.try(yakmo.polynomialfromS("h31 h32"))
  57                 std.get(quiver.find_vertex(q, "v3;5")).1.acoord = `std.Some std.try(yakmo.polynomialfromS("h32^2"))
  58                 std.get(quiver.find_vertex(q, "v4;5")).1.acoord = `std.Some std.try(yakmo.polynomialfromS("h33^2"))
  59                 std.put("--------\n")
  60
  61
  62                 for subseq : [
  63                                 [ ][:],
  64                                 [ "v1;1", "v2;1", "v3;1", "v4;1", ][:],
  65                                 [ "v1;2", "v2;2", "v3;2", "v4;2", ][:],
  66                                 [ "v1;1", "v2;1", "v3;1", "v4;1", ][:],
  67                                 [ "v1;3", "v2;3", "v3;3", "v4;3", ][:],
  68                                 [ "v1;2", "v2;2", "v3;2", "v4;2", ][:],
  69                                 [ "v1;1", "v2;1", "v3;1", "v4;1", ][:],
  70                                 [ "v1;4", "v2;4", "v3;4", "v4;4", ][:],
  71                                 [ "v1;3", "v2;3", "v3;3", "v4;3", ][:],
  72                                 [ "v1;2", "v2;2", "v3;2", "v4;2", ][:],
  73                                 [ "v1;1", "v2;1", "v3;1", "v4;1", ][:],
  74                                 [ "v1;5", "v2;5", "v3;5", "v4;5", ][:],
  75                                 [ "v1;4", "v2;4", "v3;4", "v4;4", ][:],
  76                                 [ "v1;3", "v2;3", "v3;3", "v4;3", ][:],
  77                                 [ "v1;2", "v2;2", "v3;2", "v4;2", ][:],
  78                                 [ "v1;1", "v2;1", "v3;1", "v4;1", ][:], ][:]
  79                         var untouched_q = auto t.dup(q)
  80
  81                         quiver.mutateseq_ip(q, subseq)
  82                 ;;
  83         elif std.eq(dir, "wordtest")
  84                 /* This is the one that gives you the weird numerator part of h1 */
  85                 var kc = `C 3
  86                 var rank = get_n(kc)
  87                 var w0 = get_w0(kc)
  88                 var h : factorization_coordinate[:] = [][:]
  89                 for var k = 1; k <= rank; ++k
  90                         std.slpush(&h, `H((k : weyl_reflection), std.try(yakmo.ratfuncfromS(std.fmt("a{}", k), "1"))))
  91                 ;;
  92
  93                 var wk_H_action_exps = get_wk_H_action_exps(kc)
  94
  95                 for x : [ 0, 1 ][:]
  96                         for var k = 1; k <= w0.len; ++k
  97                                 var hw = apply_wk(kc, k, h, x)
  98                                 std.put("w_{w=3,p= }(h) =      ", k)
  99                                 for q : std.try(hw)
 100                                         match q
 101                                         | `H(l, rf):
 102                                                 var col_start = ""
 103                                                 var col_end = ""
 104                                                 var extra = 0
 105                                                 if l == w0[k - 1]
 106                                                         col_start = "\u{001b}[48;2;55;55;55m"
 107                                                         col_end = "\u{001b}[0m"
 108                                                         extra = col_start.len + col_end.len - 2
 109                                                 ;;
 110                                                 var s = std.fmt("{} {} {}", col_start, rf, col_end)
 111                                                 std.put("{w=?}", s, 20 + extra)
 112                                                 std.slfree(s)
 113                                         | _:
 114                                         ;;
 115                                 ;;
 116                                 std.put("\n")
 117                         ;;
 118                         std.put("-------\n")
 119                 ;;
 120         elif std.eq(dir, "wordtest2")
 121                 /* This is for playing around with wordtest */
 122                 var kc = `A 5
 123                 var rank = get_n(kc)
 124                 var w0 = get_w0(kc)
 125                 var h : factorization_coordinate[:] = [][:]
 126                 for var k = 1; k <= rank; ++k
 127                         std.slpush(&h, `H((k : weyl_reflection), std.try(yakmo.ratfuncfromS(std.fmt("a{}", k), "1"))))
 128                 ;;
 129
 130                 var wk_H_action_exps = get_wk_H_action_exps(kc)
 131
 132                 for x : [ 0, -1, 1 ][:]
 133                         for var k = rank; k < w0.len; ++k
 134                                 var hw = apply_wk(kc, k, h, x)
 135                                 std.put("w_{w=3,p= }(h) =      ", k)
 136                                 for q : std.try(hw)
 137                                         match q
 138                                         | `H(l, rf):
 139                                                 var col_start = ""
 140                                                 var col_end = ""
 141                                                 var extra = 0
 142                                                 if k < w0.len && l == w0[k]
 143                                                         col_start = "\u{001b}[48;2;55;55;55m"
 144                                                         col_end = "\u{001b}[0m"
 145                                                         extra = col_start.len + col_end.len - 2
 146                                                 ;;
 147                                                 var s = std.fmt("{} {} {}", col_start, rf, col_end)
 148                                                 std.put("{w=?}", s, 20 + extra)
 149                                                 std.slfree(s)
 150                                         | _:
 151                                         ;;
 152                                 ;;
 153                                 std.put("\n")
 154                         ;;
 155                         std.put("-------\n")
 156                 ;;
 157         elif std.eq(dir, "seek-flip")
 158                 var kc = `C 2
 159                 var qdv = std.try(mk_Qdv(kc))
 160                 var qdh = std.try(mk_Qdh(kc))
 161
 162                 //quiver.mutateseq_ip(qdv, ["w1;1", "w2;1"][:])
 163                 //quiver.mutateseq_ip(qdv, ["w2;1", "w1;1"][:])
 164                 quiver.mutateseq_ip(qdv, [][:])
 165
 166                 //quiver.mutateseq_ip(qdv, ["w1;3", "w2;3"][:])
 167                 //quiver.mutateseq_ip(qdv, ["w2;3", "w1;3"][:])
 168                 quiver.mutateseq_ip(qdv, [][:])
 169
 170                 for (name, val) : [
 171                                         ("D1",   "1"), ("D2",   "1"),
 172                                         ("E1",   "1"), ("E2",   "1"),
 173                                         ("F1",   "1"), ("F2",   "1"),
 174                                         ("G1",   "1"), ("G2",   "1"),
 175                                         ("w1;1", "1"), ("w2;1", "1"),
 176                                         ("w1;2", "1"), ("w2;2", "1"),
 177                                         ("w1;3", "1"), ("w2;3", "1"),
 178                                 ][:]
 179                         match quiver.find_vertex(qdv, name)
 180                         | `std.Some (_, vv):
 181                                 vv.acoord = `std.Some std.try(yakmo.polynomialfromS(val))
 182                         | `std.None:
 183                         ;;
 184                 ;;
 185
 186                 var sought = [
 187                         std.try(yakmo.polynomialfromS("12")),
 188                         std.try(yakmo.polynomialfromS("36")),
 189
 190                         std.try(yakmo.polynomialfromS("15")),
 191                         std.try(yakmo.polynomialfromS("18")),
 192                         std.try(yakmo.polynomialfromS("24")),
 193                         std.try(yakmo.polynomialfromS("2")),
 194                 ][:]
 195
 196                 for var j = 0; j < qdv.v.len; ++j
 197                         std.put(" > {w=8}   {}\n", qdv.v[j].name, qdv.v[j].acoord)
 198                 ;;
 199
 200                 for var depth = 2; depth < 20; ++depth
 201                         std.put("searching at depth = {}\n", depth)
 202                         exorcise(qdv, [][:], sought, depth, 0, 0)
 203                 ;;
 204         elif std.eq(dir, "uinv-test")
 205                 var kc = `C 2
 206                 var rank = get_n(kc)
 207                 var fc : factorization_coordinate[:] = [][:]
 208                 var i = get_w0(kc)
 209
 210                 /* first w0 */
 211                 for var k = 0; k < i.len; ++k
 212                         std.slpush(&fc, `X(i[k], std.try(yakmo.ratfuncfromS("-1", "1"))))
 213                         std.slpush(&fc, `Y(i[k], std.try(yakmo.ratfuncfromS(" 1", "1"))))
 214                         std.slpush(&fc, `X(i[k], std.try(yakmo.ratfuncfromS("-1", "1"))))
 215                 ;;
 216                 /* now u */
 217                 var j = 1
 218                 for ii : i
 219                         std.slpush(&fc, `Y(ii, std.try(yakmo.ratfuncfromS(std.fmt("t{}", j++), "1"))))
 220                 ;;
 221
 222                 ///* now w0^-1 */
 223                 //for var k = i.len - 1; k >= 0; --k
 224                 //        std.slpush(&fc, `X(i[k], std.try(yakmo.ratfuncfromS(" 1", "1"))))
 225                 //        std.slpush(&fc, `Y(i[k], std.try(yakmo.ratfuncfromS("-1", "1"))))
 226                 //        std.slpush(&fc, `X(i[k], std.try(yakmo.ratfuncfromS(" 1", "1"))))
 227                 //;;
 228
 229                 /* So what is it? */
 230                 match canonicalize_factorization_coords(kc, &fc, `Ordering_YHX)
 231                 | `std.Err e: std.fatal(e)
 232                 | `std.Ok void:
 233                 ;;
 234
 235                 for var j = 0; j < fc.len; ++j
 236                         match fc[j]
 237                         | `X(ii, rf): std.put("X({w=2,p= },   {})\n", ii, rf)
 238                         | `H(ii, rf): std.put("H({w=2,p= },   {})\n", ii, rf)
 239                         | `Y(ii, rf): std.put("Y({w=2,p= },   {})\n", ii, rf)
 240                         ;;
 241                 ;;
 242         elif std.eq(dir, "lusztigtest")
 243                 var kc = `C 5
 244                 var fc = std.sldup([
 245                         `Y (2, std.try(yakmo.ratfuncfromS(" t", "1"))),
 246
 247                         `X (2, std.try(yakmo.ratfuncfromS("-1", "1"))),
 248                         `Y (2, std.try(yakmo.ratfuncfromS(" 1", "1"))),
 249                         `X (2, std.try(yakmo.ratfuncfromS("-1", "1"))),
 250                 ][:])
 251                 std.put("{}      =       ", fc)
 252                 match canonicalize_factorization_coords(kc, &fc, `Ordering_XYH)
 253                 | `std.Err e: std.fatal("\ncanonicalize_factorization_coords({}, {}): {}", kc, fc, e)
 254                 | `std.Ok void:
 255                         for var j = 0; j < fc.len; ++j
 256                                 match fc[j]
 257                                 | `H(_, rf): yakmo.reduceratfunc(rf)
 258                                 | `X(_, rf): yakmo.reduceratfunc(rf)
 259                                 | `Y(_, rf): yakmo.reduceratfunc(rf)
 260                                 ;;
 261                         ;;
 262                         std.put("{}\n", fc)
 263                 ;;
 264         elif std.eq(dir, "applyw0test")
 265                 var kc = `C 2
 266                 var fc = std.sldup([
 267                         `H (1, std.try(yakmo.ratfuncfromS("s", "1"))),
 268                         `H (2, std.try(yakmo.ratfuncfromS("t", "1"))),
 269                 ][:])
 270                 std.put("w₀( {} )     =       ", fc)
 271                 match apply_wk(kc, 1, fc, 0)
 272                 | `std.Err e: std.fatal("{}\n", e)
 273                 | `std.Ok wkfc: std.put("{}\n", wkfc)
 274                 ;;
 275         elif std.eq(dir, "phiinvtest")
 276                 var kc = `C 2
 277                 var mc = std.sldup([
 278                         [ .k = 1, .c = std.try(yakmo.ratfuncfromS("13", "1")) ],
 279                         [ .k = 2, .c = std.try(yakmo.ratfuncfromS("29", "1")) ],
 280                         [ .k = 3, .c = std.try(yakmo.ratfuncfromS("101", "1")) ],
 281                         [ .k = 4, .c = std.try(yakmo.ratfuncfromS("41", "1")) ],
 282                 ][:])
 283                 var fc
 284                 match interior_fc_from_mc_and_undo_psi_phi_psi(kc, mc)
 285                 | `std.Err e: std.fatal("interior_fc_from_mc_and_undo_psi_phi_psi: {}\n", e)
 286                 | `std.Ok fc_: fc = fc_
 287                 ;;
 288                 std.put("mc = {}\n", mc)
 289                 std.put("fc = {}\n", fc)
 290         elif std.eq(dir, "psiphitest")
 291                 var kc = input_kc
 292                 var w0 = get_w0(kc)
 293                 var mc = [][:]
 294                 for var j = 0; j < w0.len; ++j
 295                         std.slpush(&mc, [ .k = j + 1, .c = std.try(yakmo.ratfuncfromS(a_from_k(j), "1")) ])
 296                 ;;
 297
 298                 var fc
 299                 match interior_fc_from_mc(kc, mc)
 300                 | `std.Err e: std.fatal("interior_fc_from_mc: {}\n", e)
 301                 | `std.Ok fc_: fc = fc_
 302                 ;;
 303                 std.put(".")
 304
 305                 var phi_fc
 306                 match phi(kc, fc)
 307                 | `std.Err e: std.fatal("phi: {}\n", e)
 308                 | `std.Ok fc_: phi_fc = fc_
 309                 ;;
 310                 std.put(".")
 311
 312                 var psi_phi_fc
 313                 match psi(kc, phi_fc)
 314                 | `std.Err e: std.fatal("psi: {}\n", e)
 315                 | `std.Ok fc_: psi_phi_fc = fc_
 316                 ;;
 317                 std.put(".")
 318
 319                 var phi_psi_mc
 320                 match interior_mc_from_fc(kc, psi_phi_fc)
 321                 | `std.Err e: std.fatal("interior_mc_from_fc: {}\n", e)
 322                 | `std.Ok mc_: phi_psi_mc = mc_
 323                 ;;
 324                 std.put(".\n")
 325
 326                 for var j = 0; j < mc.len; ++j
 327                         std.put("{}        ->             {}\n", mc[j], phi_psi_mc[j])
 328                 ;;
 329         elif std.eq(dir, "psiphipsiphitest")
 330                 var kc = `C 2
 331                 var mc = std.sldup([
 332                         [ .k = 1, .c = std.try(yakmo.ratfuncfromS("a", "1")) ],
 333                         [ .k = 2, .c = std.try(yakmo.ratfuncfromS("b", "1")) ],
 334                         [ .k = 3, .c = std.try(yakmo.ratfuncfromS("c", "1")) ],
 335                         [ .k = 4, .c = std.try(yakmo.ratfuncfromS("d", "1")) ],
 336                 ][:])
 337                 var fc
 338                 match interior_fc_from_mc(kc, mc)
 339                 | `std.Err e: std.fatal("interior_fc_from_mc: {}\n", e)
 340                 | `std.Ok fc_: fc = fc_
 341                 ;;
 342                 std.put(".")
 343
 344                 var phi_fc
 345                 match phi(kc, fc)
 346                 | `std.Err e: std.fatal("phi: {}\n", e)
 347                 | `std.Ok fc_: phi_fc = fc_
 348                 ;;
 349                 std.put(".")
 350
 351                 var psi_phi_fc
 352                 match psi(kc, phi_fc)
 353                 | `std.Err e: std.fatal("psi: {}\n", e)
 354                 | `std.Ok fc_: psi_phi_fc = fc_
 355                 ;;
 356                 std.put(".")
 357
 358                 var phi_psi_phi_fc
 359                 match phi(kc, psi_phi_fc)
 360                 | `std.Err e: std.fatal("phi: {}\n", e)
 361                 | `std.Ok fc_: phi_psi_phi_fc = fc_
 362                 ;;
 363                 std.put(".")
 364
 365                 var psi_phi_psi_phi_fc
 366                 match phi(kc, phi_psi_phi_fc)
 367                 | `std.Err e: std.fatal("psi: {}\n", e)
 368                 | `std.Ok fc_: psi_phi_psi_phi_fc = fc_
 369                 ;;
 370                 std.put(".")
 371
 372                 var phi_psi_phi_psi_mc
 373                 match interior_mc_from_fc(kc, psi_phi_psi_phi_fc)
 374                 | `std.Err e: std.fatal("interior_mc_from_fc: {}\n", e)
 375                 | `std.Ok mc_: phi_psi_phi_psi_mc = mc_
 376                 ;;
 377                 std.put(".\n")
 378
 379                 for var j = 0; j < mc.len; ++j
 380                         std.put("{}        ->             {}\n", mc[j], phi_psi_phi_psi_mc[j])
 381                 ;;
 382         elif std.eq(dir, "rottest")
 383                 var kc = `C 2
 384                 var h1 : minor_coordinate[:] = [
 385                         [ .k = 1, .c = std.try(yakmo.ratfuncfromS("1", "1")) ],
 386                         [ .k = 2, .c = std.try(yakmo.ratfuncfromS("1", "1")) ],
 387                 ][:]
 388                 var h2 : minor_coordinate[:] = [
 389                         [ .k = 1, .c = std.try(yakmo.ratfuncfromS("1", "1")) ],
 390                         [ .k = 2, .c = std.try(yakmo.ratfuncfromS("1", "1")) ],
 391                 ][:]
 392                 var h3 : minor_coordinate[:] = [
 393                         [ .k = 1, .c = std.try(yakmo.ratfuncfromS("1", "1")) ],
 394                         [ .k = 2, .c = std.try(yakmo.ratfuncfromS("1", "1")) ],
 395                 ][:]
 396                 var u : minor_coordinate[:] = [
 397                         [ .k = 3, .c = std.try(yakmo.ratfuncfromS("1", "1")) ],
 398                         [ .k = 4, .c = std.try(yakmo.ratfuncfromS("1", "1")) ],
 399                 ][:]
 400
 401                 var alpha : conf_3_star = [ .h1 = t.dup(h1), .h2 = t.dup(h2), .h3 = t.dup(h3), .u = t.dup(u) ]
 402                 var a012 : conf_3_star# = std.mk(alpha)
 403                 match fill_in_alpha(kc, a012)
 404                 | `std.Err e: std.fatal("fill_in_alpha: {}\n", e)
 405                 | `std.Ok void:
 406                         match rotate(kc, a012)
 407                         | `std.Err e: std.fatal("rotate: {}\n", e)
 408                         | `std.Ok a201:
 409                                 match rotate(kc, a201)
 410                                 | `std.Err e: std.fatal("rotate: {}\n", e)
 411                                 | `std.Ok a120:
 412                                         std.put("a012:\n")
 413                                         std.put("  h1 : {}\n", a012.h1)
 414                                         std.put("  h2 : {}\n", a012.h2)
 415                                         std.put("  h3 : {}\n", a012.h3)
 416                                         std.put("   u : {}\n", a012.u)
 417                                         std.put("-----------------\n")
 418                                         std.put("a201:\n")
 419                                         std.put("  h1 : {}\n", a201.h1)
 420                                         std.put("  h2 : {}\n", a201.h2)
 421                                         std.put("  h3 : {}\n", a201.h3)
 422                                         std.put("   u : {}\n", a201.u)
 423                                         std.put("-----------------\n")
 424                                         std.put("a120:\n")
 425                                         std.put("  h1 : {}\n", a120.h1)
 426                                         std.put("  h2 : {}\n", a120.h2)
 427                                         std.put("  h3 : {}\n", a120.h3)
 428                                         std.put("   u : {}\n", a120.u)
 429                                 ;;
 430                         ;;
 431                 ;;
 432         ;;
 433
 434         -> void
 435 }
 436
 437 const leftpad = {s, w
 438         var needed_len = w - s.len
 439         var sb : std.strbuf# = std.mksb()
 440         for var j = 0; j < needed_len; ++j
 441                 std.sbputb(sb, (' ' : byte))
 442         ;;
 443         std.sbputs(sb, s)
 444
 445         -> std.sbfin(sb)
 446 }
 447
 448 generic sameopts = {a : std.option(@t), b : std.option(@t)
 449         match (a, b)
 450         | (`std.None, `std.None): -> true
 451         | (`std.Some _, `std.None): -> false
 452         | (`std.None, `std.Some _): -> false
 453         | (`std.Some aa, `std.Some bb): -> std.eq(aa, bb)
 454         ;;
 455 }
 456
 457 const exorcise = {q : quiver.quiver#, history : std.size[:], targets : yakmo.polynomial#[:], depth : int, wildcat : int, last_num_good : int
 458         if depth < 0
 459                 -> void
 460         ;;
 461
 462         /* Are all of our A-coordinates correct? */
 463 var w12_good = true
 464 var w22_good = true
 465         var num_good : int = 0
 466         for var j = 0; j < q.v.len; ++j
 467                 var v : quiver.vertex# = &q.v[j]
 468                 if v.name[0] != ('w' : byte) && v.name[0] != ('v' : byte)
 469                        continue
 470                 ;;
 471 /* SPECIFIC */
 472                 if std.eq(v.name, "w1;2") && !sameopts(v.acoord, `std.Some targets[0])
 473                         w12_good = false
 474                         continue
 475                 ;;
 476                 if std.eq(v.name, "w2;2") && !sameopts(v.acoord, `std.Some targets[1])
 477                         w22_good = false
 478                         continue
 479                 ;;
 480 /* SPECIFIC */
 481                 for qt : targets
 482                         if sameopts(v.acoord, `std.Some qt)
 483                                 num_good++
 484                                 break
 485                         ;;
 486                 ;;
 487         ;;
 488
 489         if num_good > 4 && w12_good && w22_good
 490                 std.put("Potential : [")
 491                 for var j = 0; j < history.len; ++j
 492                         std.put(" {}", q.v[history[j]].name)
 493                 ;;
 494                 std.put(" ] : ")
 495 /* SPECIFIC */
 496                 match quiver.find_vertex(q, "w1;1")
 497                 | `std.Some (_, vv): std.put("w1;1 = {}   ", vv.acoord)
 498                 | `std.None:
 499                 ;;
 500                 match quiver.find_vertex(q, "w2;1")
 501                 | `std.Some (_, vv): std.put("w2;1 = {}   ", vv.acoord)
 502                 | `std.None:
 503                 ;;
 504                 match quiver.find_vertex(q, "w1;2")
 505                 | `std.Some (_, vv): std.put("w1;2 = {}   ", vv.acoord)
 506                 | `std.None:
 507                 ;;
 508                 match quiver.find_vertex(q, "w2;2")
 509                 | `std.Some (_, vv): std.put("w2;2 = {}   ", vv.acoord)
 510                 | `std.None:
 511                 ;;
 512                 match quiver.find_vertex(q, "w1;3")
 513                 | `std.Some (_, vv): std.put("w1;3 = {}   ", vv.acoord)
 514                 | `std.None:
 515                 ;;
 516                 match quiver.find_vertex(q, "w2;3")
 517                 | `std.Some (_, vv): std.put("w2;3 = {}   ", vv.acoord)
 518                 | `std.None:
 519                 ;;
 520 /* SPECIFIC */
 521                 std.put("\n")
 522                 -> void
 523         elif num_good > 9 && num_good > last_num_good
 524                 std.put("{}  : [", num_good)
 525                 for var j = 0; j < history.len; ++j
 526                         std.put(" {}", q.v[history[j]].name)
 527                 ;;
 528                 std.put(" ]\n")
 529         ;;
 530
 531         /*
 532            We're not all good. Mutate somewhere. I don't have a clue
 533            what's "normal", so wildcat doesn't mean anything.
 534          */
 535         var candidates : (std.size, int)[:] = [][:]
 536         var zero : yakmo.Q# = yakmo.gid()
 537         auto zero
 538         for var j = 0; j < q.v.len; ++j
 539                 if q.v[j].name[0] != ('w' : byte) && q.v[j].name[0] != ('v' : byte)
 540                         continue
 541                 ;;
 542                 if history.len >= 1
 543                         var l = history[history.len - 1]
 544                         if j == l
 545                                 continue
 546                         elif j < l && std.eq(q.epsilon[j][l], zero)
 547                                 /*
 548                                    Mutating here and at the last
 549                                    position commute, so we only need one
 550                                    ordering.
 551                                  */
 552                                 continue
 553                         ;;
 554                 ;;
 555
 556 /* SPECIFIC */
 557                 if 1 == 2
 558                         continue
 559                 elif j == 1 && !yakmo.eq_gid(q.epsilon[1][2])
 560                         continue
 561                 elif j == 2 && (!yakmo.eq_gid(q.epsilon[1][2]) || !yakmo.eq_gid(q.epsilon[2][8]))
 562                         continue
 563                 elif j == 3 && (!yakmo.eq_gid(q.epsilon[3][6]) || !yakmo.eq_gid(q.epsilon[3][12]))
 564                         continue
 565                 elif j == 6 && !yakmo.eq_gid(q.epsilon[6][3])
 566                         continue
 567                 elif j == 8 && !yakmo.eq_gid(q.epsilon[2][8])
 568                         continue
 569         elif j == 12 && !yakmo.eq_gid(q.epsilon[3][12])
 570                 continue
 571         ;;
 572 /* SPECIFIC */
 573
 574         std.slpush(&candidates, (j, wildcat))
 575 ;;
 576
 577 var new_history : std.size[:] = std.sldup(history)
 578 std.slpush(&new_history, -1)
 579 for var k = 0; k < candidates.len; ++k
 580         /* Forwards */
 581         match quiver.mutate_ip_i(q, candidates[k].0)
 582         | `std.Err e: std.fatal(e)
 583         | _:
 584         ;;
 585
 586         /* Explore */
 587         new_history[new_history.len - 1] = candidates[k].0
 588         exorcise(q, new_history, targets, depth - 1, candidates[k].1, num_good)
 589
 590                 /* Backwards */
 591                 match quiver.mutate_ip_i(q, candidates[k].0)
 592                 | `std.Err e: std.fatal(e)
 593                 | _:
 594                 ;;
 595         ;;
 596
 597         std.slfree(new_history)
 598         std.slfree(candidates)
 599 }
 600
 601 const a_from_k = {k
 602         var p = [][:]
 603         var ls = [ "a", "b", "c", "d", "e", "f", "g", "h", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z" ][:]
 604         while k >= ls.len
 605                 var rem = k % ls.len
 606                 std.slpush(&p, ls[rem])
 607                 k = k / ls.len
 608         ;;
 609         std.slpush(&p, ls[k])
 610
 611         var sb = std.mksb();
 612         for var k = p.len - 1; k >= 0; --k
 613                 std.sbputs(sb, p[k])
 614         ;;
 615
 616         -> std.sbfin(sb)
 617 }