types.myr

   1 use std
   2
   3 use t
   4 use yakmo
   5
   6 use "zzz"
   7
   8 pkg =
   9         type KC_type = union
  10                 `A int
  11                 `B int
  12                 `C int
  13                 `D int
  14                 `E6
  15                 `E7
  16                 `E8
  17                 `F4
  18                 `G2
  19         ;;
  20
  21         /* This is an i, representing some s_i. i starts at 1. */
  22         type weyl_reflection = int
  23         impl disposable weyl_reflection[:]
  24         impl disposable (weyl_reflection, weyl_reflection)[:]
  25
  26         /*
  27            There's some sort of dependence on ⟨ σ_G ⟩ in the formula.
  28            This is either trivial or Z/2Z. Since I suspect there may be
  29            a more elegant (if more complicated) description of the
  30            property later, describe this with an opaque object.
  31          */
  32         type Dynkin_automorphism_class = union
  33                 `trivial_class_for_trivial_sigmaG
  34                 `trivial_class_for_nontrivial_sigmaG
  35                 `nontrivial_class_for_nontrivial_sigmaG
  36         ;;
  37         impl disposable Dynkin_automorphism_class
  38
  39         /*
  40            A vector, with entries the coefficients of e_{i-1}; so e_1 is
  41            given by c = [ 1, 0, 0, ..., 0][:]
  42
  43            Roots are special vectors (so vectors), coroots are vectors
  44            in a dual space that have special relations to roots (so are
  45            also vectors), and fundamental weights are integral
  46            combinations of simple roots (also vectors).
  47          */
  48         type vector = struct
  49                 c : yakmo.Q#[:]
  50         ;;
  51         impl disposable vector#
  52         impl disposable vector#[:]
  53         impl t.dupable vector#
  54
  55         /*
  56            A chamber weight is q word (a sequence of weyl reflections)
  57            and a fundamental weight. We represent the fundamental weight
  58            only by its index, ditto for the weyl reflections. The
  59            indices are 1-based: e.g. "s_2 s_1 s_2 ω_2" makes sense for
  60            C_2.
  61
  62            The words are not inverted. No reduction is performed. These
  63            are all equivalent to some γ_k, but we don't proactively find
  64            that k.
  65          */
  66         type chamber_weight = struct
  67                 word : weyl_reflection[:]
  68                 fweight : int
  69         ;;
  70
  71         /*
  72            Factorization coordinates for elements that admit a Gaussian
  73            decomposition. `H (i, v) are generators of the maximal torus
  74            / Cartan subgroup, `X (i, v) are generators of the maximal
  75            unipotent subgroup, and `Y (i, v) are generators of the
  76            opposite unipotent subgroup.
  77
  78            i is the index for the generator (1-based), and v is the
  79            coordinate value.
  80
  81            Certainly any element in the maximal torus can be described
  82            by r `H (i, v)s, one each for i = 1, 2, ..., r. The promise
  83            of factorization coordinates is that any representation of
  84            w_0, the maximal word in the Weyl group, as { i1, ..., in },
  85            the maximal unipotent subgroup can be described by
  86            coordinates `X (ij, v). That is, any g in N can be written as
  87
  88                g = `X(i1, v1) `X(i2, v2) ... `X(in, vn)
  89
  90            Actually finding those may be difficult, however.
  91          */
  92         /* This has to be in this file, for some reason */
  93         impl disposable yakmo.ratfunc#[:]
  94         impl disposable yakmo.ratfunc#[:][:]
  95
  96         /*
  97            See below: factorization `H(j, rf) does not (necessarily)
  98            correspond to minor [ .k = j, rf ]. Rather,
  99
 100                `H(coxeter[j], rf) =~= [ .k = j, rf ]
 101          */
 102         type factorization_coordinate = union
 103                 `H (weyl_reflection, yakmo.ratfunc#)
 104                 `X (weyl_reflection, yakmo.ratfunc#)
 105                 `Y (weyl_reflection, yakmo.ratfunc#)
 106         ;;
 107         impl disposable factorization_coordinate
 108         impl disposable factorization_coordinate[:]
 109         impl t.dupable factorization_coordinate
 110
 111         /*
 112            k is the index of which simple root c is associated to, based
 113            on the ordering given by the Coxeter element. That means that
 114            minor_coordinates' k and factorization_coordinates' indices
 115            are different units.
 116          */
 117         type minor_coordinate = struct
 118                 k : int
 119                 c : yakmo.ratfunc#
 120         ;;
 121         impl disposable minor_coordinate
 122         impl disposable minor_coordinate[:]
 123         impl t.dupable minor_coordinate
 124
 125         /*
 126            This is the decomposition, with
 127
 128              (g0 N, g1 N, g2 N )
 129
 130            in canonical form as
 131
 132              (N, wo h1 N, u wo h1 wo^-1 h2 wo^2 N)
 133
 134            such that [ wo^-1 u ]_{0} = (wo h3 h1 wo^-1 h2)^-1.
 135
 136            The ordering should be by the Coxeter element: we should have
 137            h1[k] = χ_{ω_{i_k}}(h1); u[k] = χ_{ω_{i_k}}([w_k^-1 u]_0).
 138            This is 1-based, so to actually apply the coxeter element
 139            you'll need to use c[foo.k - 1].
 140
 141            Also, u[k] should be Δ^{γ_k}(u). This means k should ALWAYS
 142            start at 1.
 143          */
 144         type conf_3_star = struct
 145                 h1 : minor_coordinate[:]
 146                 h2 : minor_coordinate[:]
 147                 h3 : minor_coordinate[:]
 148                 u : minor_coordinate[:]
 149         ;;
 150         impl disposable conf_3_star#
 151
 152         /*
 153            Canonical form of α = (g₀N, g₁N, g₂N, g₃N) as
 154
 155              (N, w₀(h₀₂) w₀(h₁₂)⁻¹ u⁻¹ N, w₀ h₀₂ N, Φ⁻¹(v) w₀ h₀₃ N)
 156
 157            The ordering should be by the Coxeter element, as in conf_3_star
 158
 159            This construction is biased towards psi_02: u is the element
 160            of N_{-} used in the 012 part, and v in the 023 part (there
 161            may be some rotations involved).
 162          */
 163         type conf_4_star = struct
 164                 h01 : minor_coordinate[:]
 165                 h12 : minor_coordinate[:]
 166                 h02 : minor_coordinate[:]
 167                 h23 : minor_coordinate[:]
 168                 h03 : minor_coordinate[:]
 169                 u : minor_coordinate[:]
 170                 v : minor_coordinate[:]
 171         ;;
 172
 173         /*
 174            The indices into T_Q are by simple reflections.
 175
 176                A[2] = A-coordinate of vertex "A2"
 177
 178                A[0] is dummy
 179
 180                v[2][4] = A-coordinate of vertex "v2;4"
 181
 182                v[0][1], v[0][2], and so on are all dummy
 183
 184                v[1][0], v[2][0], and so on are all dummy
 185          */
 186         type T_Q = struct
 187                 A : yakmo.ratfunc#[:]
 188                 B : yakmo.ratfunc#[:]
 189                 C : yakmo.ratfunc#[:]
 190                 v : yakmo.ratfunc#[:][:]
 191         ;;
 192         impl disposable T_Q
 193         impl disposable T_Q#
 194         impl t.dupable T_Q#
 195
 196         /*
 197            Just two copies of T_Q, and we make sure that they agree on
 198            the joined edge.
 199          */
 200         type T_Q02 = struct
 201                 D : yakmo.ratfunc#[:]
 202                 E : yakmo.ratfunc#[:]
 203                 F : yakmo.ratfunc#[:]
 204                 G : yakmo.ratfunc#[:]
 205                 w : yakmo.ratfunc#[:][:]
 206         ;;
 207
 208         /*
 209            Exactly the same as TQ02, but called something different for
 210            type-checking.
 211          */
 212         type T_Q13 = struct
 213                 D : yakmo.ratfunc#[:]
 214                 E : yakmo.ratfunc#[:]
 215                 F : yakmo.ratfunc#[:]
 216                 G : yakmo.ratfunc#[:]
 217                 w : yakmo.ratfunc#[:][:]
 218         ;;
 219 ;;
 220
 221 const __init__ = {
 222         var fc : factorization_coordinate
 223         fc = fc
 224         std.fmtinstall(std.typeof(fc), factorization_coordinatefmt)
 225 }
 226
 227 const factorization_coordinatefmt = {sb, ap, opts
 228         var fc = std.vanext(ap)
 229         match fc
 230         | `X(i, rf): std.sbfmt(sb, "X({}, {})", i, rf)
 231         | `Y(i, rf): std.sbfmt(sb, "Y({}, {})", i, rf)
 232         | `H(i, rf): std.sbfmt(sb, "H({}, {})", i, rf)
 233         ;;
 234 }
 235
 236 impl disposable weyl_reflection[:] =
 237         __dispose__ = {x; std.slfree(x)}
 238 ;;
 239
 240 impl disposable (weyl_reflection, weyl_reflection)[:] =
 241         __dispose__ = {x; std.slfree(x)}
 242 ;;
 243
 244 impl disposable Dynkin_automorphism_class =
 245         __dispose__ = {x; }
 246 ;;
 247
 248 impl disposable vector# =
 249         __dispose__ = {v
 250                 /* TODO: use t should make v.c __dispose__able, no? */
 251                 for var j = 0; j < v.c.len; ++j
 252                         __dispose__(v.c[j])
 253                 ;;
 254                 std.slfree(v.c)
 255                 /* TODO: std.free */
 256                 std.bytefree( (v : byte#), sizeof(vector))
 257         }
 258 ;;
 259
 260 impl disposable vector#[:] =
 261         __dispose__ = {vs
 262                 for v : vs
 263                         __dispose__(v)
 264                 ;;
 265                 std.slfree(vs)
 266         }
 267 ;;
 268
 269 impl t.dupable vector# =
 270         dup = {v
 271                 var cdup = std.slalloc(v.c.len)
 272                 for var j = 0; j < v.c.len; ++j
 273                         cdup[j] = t.dup(v.c[j])
 274                 ;;
 275                 var vbase = [ .c = cdup ]
 276                 -> std.mk(vbase)
 277         }
 278 ;;
 279
 280 impl disposable yakmo.ratfunc#[:] =
 281         __dispose__ = {l
 282                 for x : l
 283                         /* Dumb type workaround */
 284                         var xrf = (x : yakmo.ratfunc#)
 285                         __dispose__(xrf)
 286                 ;;
 287                 std.slfree(l)
 288         }
 289 ;;
 290
 291 impl disposable yakmo.ratfunc#[:][:] =
 292         __dispose__ = {l
 293                 for x : l
 294                         __dispose__((x : yakmo.ratfunc#[:]))
 295                 ;;
 296                 std.slfree(l)
 297         }
 298 ;;
 299
 300 impl disposable factorization_coordinate =
 301         __dispose__ = {fc
 302                 match fc
 303                 | `X (_, l): __dispose__(l)
 304                 | `Y (_, l): __dispose__(l)
 305                 | `H (_, l): __dispose__(l)
 306                 ;;
 307         }
 308 ;;
 309
 310 impl disposable factorization_coordinate[:] =
 311         __dispose__ = {v
 312                 for vv : v
 313                         __dispose__(vv)
 314                 ;;
 315                 std.slfree(v)
 316         }
 317 ;;
 318
 319 impl t.dupable factorization_coordinate =
 320         dup = {x
 321                 match x
 322                 | `H(i, z): -> `H(i, t.dup(z))
 323                 | `X(i, z): -> `X(i, t.dup(z))
 324                 | `Y(i, z): -> `Y(i, t.dup(z))
 325                 ;;
 326         }
 327 ;;
 328
 329 impl disposable minor_coordinate =
 330         __dispose__ = {mc
 331                 __dispose__(mc.c)
 332         }
 333 ;;
 334
 335 impl disposable minor_coordinate[:] =
 336         __dispose__ = {v
 337                 for vv : v
 338                         __dispose__(vv)
 339                 ;;
 340                 std.slfree(v)
 341         }
 342 ;;
 343
 344 impl t.dupable minor_coordinate =
 345         dup = {x
 346                 -> [ .k = x.k, .c = t.dup(x.c) ]
 347         }
 348 ;;
 349
 350 impl disposable conf_3_star# =
 351         __dispose__ = {alpha
 352                 __dispose__(alpha.h1)
 353                 __dispose__(alpha.h2)
 354                 __dispose__(alpha.h3)
 355                 __dispose__(alpha.u)
 356                 std.free(alpha)
 357         }
 358 ;;
 359
 360 impl disposable T_Q =
 361         __dispose__ = {t
 362                 __dispose__(t.A)
 363                 __dispose__(t.B)
 364                 __dispose__(t.C)
 365                 __dispose__(t.v)
 366         }
 367 ;;
 368
 369 impl disposable T_Q# =
 370         __dispose__ = {t
 371                 __dispose__(t#)
 372                 std.free(t)
 373         }
 374 ;;
 375
 376 impl t.dupable T_Q# =
 377         dup = {x
 378                 var xdup = [
 379                         .A = std.slalloc(x.A.len),
 380                         .B = std.slalloc(x.B.len),
 381                         .C = std.slalloc(x.C.len),
 382                         .v = std.slalloc(x.v.len),
 383                 ]
 384                 for var j = 0; j < x.A.len; ++j
 385                         xdup.A[j] = t.dup(x.A[j])
 386                 ;;
 387                 for var j = 0; j < x.B.len; ++j
 388                         xdup.B[j] = t.dup(x.B[j])
 389                 ;;
 390                 for var j = 0; j < x.C.len; ++j
 391                         xdup.C[j] = t.dup(x.C[j])
 392                 ;;
 393                 for var j = 0; j < x.v.len; ++j
 394                         xdup.v[j] = std.slalloc(x.v[j].len)
 395                         for var k = 0; k < xdup.v[j].len; ++k
 396                                 xdup.v[j][k] = t.dup(x.v[j][k])
 397                         ;;
 398                 ;;
 399
 400                 -> std.mk(xdup)
 401         }
 402 ;;