Skip to content

CartanMatrixPermanent ​

The permanent of the Cartan matrix: the sum over the ways to choose one entry from each row and column.

✓ checked against that system · ! checked, with disagreements (hover a chip)FindStatSt000960via CartanType✓
CartanMatrixPermanent(cartanType)The permanent of the Cartan matrix: the sum over the ways to choose one entry from each row and column.
Typed signatures
TypePackageApplies
(cartan_type) -> numbercombinatoricsalways

Domain: Cartan type statistics

Details
  • Defined over CartanType as an expression in _x, evaluated by compute-engine — the definition IS the implementation.
  • Takes a CartanType and nothing else — it reads values against their positions, or walks the orbits, so it needs the bijection. Applying it to a bare list is a type error, not a wrong answer.
  • The table has 2^n entries, so the build checks compiled code against the interpreter up to rank 7.

Definition

Epsil, as the implementation runs it.

on CartanType, over _x

Apply(
       (pa_init: list<integer>) => Fold((pa: list<integer>, pr) => Apply(
                                                                          (pa_next: list<integer>) => pa_next,
                                                                          Map(
                                                                               Function(Sum(Map(
                                                                                                 Function((2 if pr == pc else (-1 if Abs(pr - pc) ==
                                                                                                                                     1 else 0) if _x[1] == "A" else ((-2 if pr ==
                                                                                                                                                                           _x[2] - 1 &&
                                                                                                                                                                           pc == _x[2] else -1) if Abs(pr - pc) ==
                                                                                                                                                                                        1 else 0) if _x[1] == "B" else ((-2 if pr == _x[2] &&
                                                                                                                                                                                                                              pc ==
                                                                                                                                                                                                                              _x[2] - 1 else -1) if Abs(pr - pc) ==
                                                                                                                                                                                                                                           1 else 0) if _x[1] == "C" else (-1 if pr ==
                                                                                                                                                                                                                                                                                _x[2] - 2 &&
                                                                                                                                                                                                                                                                                pc == _x[2] ||
                                                                                                                                                                                                                                                                                pr == _x[2] &&
                                                                                                                                                                                                                                                                                pc ==
                                                                                                                                                                                                                                                                                _x[2] - 2 else -1 if Abs(pr - pc) ==
                                                                                                                                                                                                                                                                                            1 &&
                                                                                                                                                                                                                                                                                            pr < _x[2] &&
                                                                                                                                                                                                                                                                                            pc < _x[2] else 0) if _x[1] == "D" else (-1 if pr == 2 &&
                                                                                                                                                                                                                                                                                                                                 pc == 4 ||
                                                                                                                                                                                                                                                                                                                                 pr == 4 &&
                                                                                                                                                                                                                                                                                                                                 pc == 2 else -1 if pr == 1 &&
                                                                                                                                                                                                                                                                                                                                             pc == 3 ||
                                                                                                                                                                                                                                                                                                                                             pr == 3 &&
                                                                                                                                                                                                                                                                                                                                             pc == 1 else -1 if pr > 2 &&
                                                                                                                                                                                                                                                                                                                                                         pc > 2 &&
                                                                                                                                                                                                                                                                                                                                                         Abs(pr - pc) ==
                                                                                                                                                                                                                                                                                                                                                         1 else 0) if _x[1] == "E" else ((-2 if pr == 2 &&
                                                                                                                                                                                                                                                                                                                                                                                               pc == 3 else -1) if Abs(pr - pc) ==
                                                                                                                                                                                                                                                                                                                                                                                                            1 else 0) if _x[1] == "F" else (-3 if pr == 2 &&
                                                                                                                                                                                                                                                                                                                                                                                                                                                 pc == 1 else -1) if Abs(pr - pc) ==
                                                                                                                                                                                                                                                                                                                                                                                                                                                              1 else 0) *
                                                                                                          pa[pm -
                                                                                                             2 ^
                                                                                                             (pc - 1) +
                                                                                                             1], pc),
                                                                                                 Filter(
                                                                                                         Range(1, _x[2]),
                                                                                                         Function(pm %
                                                                                                                  2 ^ pc >=
                                                                                                                  2 ^
                                                                                                                  (pc - 1), pc),
                                                                                                       ),
                                                                                               )) if Max(Sum(Map(
                                                                                                                 Function(1 if pm %
                                                                                                                               2 ^ pc >=
                                                                                                                               2 ^
                                                                                                                               (pc - 1) else 0, pc),
                                                                                                                 Range(1, _x[2]),
                                                                                                               )), 0) ==
                                                                                                    pr else 0, pm),
                                                                               Range(0, 2 ^ _x[2] -
                                                                                        1, 1),
                                                                             ),
                                                                        ), pa_init, Range(1, _x[2])),
       Map(Function(1 if pz == 0 else 0, pz), Range(0, 2 ^ _x[2] - 1, 1)),
     )[2 ^ _x[2]]

Examples

Basic #

the type D5D_5

live ↗
InCartanMatrixPermanent(CartanType⁡((D,5)))\mathrm{CartanMatrixPermanent}(\operatorname{CartanType}((\text{D},5)))Out6868

the type E6E_6

live ↗
InCartanMatrixPermanent(CartanType⁡((E,6)))\mathrm{CartanMatrixPermanent}(\operatorname{CartanType}((\text{E},6)))Out165165
Properties #

FindStat's value for ['A',1]

live ↗
InCombinatorialStat(CartanType⁡(("A",1)),CartanMatrixPermanent)\mathrm{CombinatorialStat}(\operatorname{CartanType}(("A",1)), \text{CartanMatrixPermanent})Out22

Known value · FindStat St000960

FindStat's value for ['A',2]

live ↗
InCombinatorialStat(CartanType⁡(("A",2)),CartanMatrixPermanent)\mathrm{CombinatorialStat}(\operatorname{CartanType}(("A",2)), \text{CartanMatrixPermanent})Out55

Known value · FindStat St000960

FindStat's value for ['A',3]

live ↗
InCombinatorialStat(CartanType⁡(("A",3)),CartanMatrixPermanent)\mathrm{CombinatorialStat}(\operatorname{CartanType}(("A",3)), \text{CartanMatrixPermanent})Out1212

Known value · FindStat St000960

About
Examples5
CrosswalkFindStat