Atlas of Lie Groups and Representations

Documentation contents

atlas Library · Script File

bigMatrices.at

The purpose of this file is to do extended group computations working with
all parameters for the extended group, namely two elements for every
$\delta$-fixed parameter, and one element for every 2-element $\delta$ orbit
Source
atlas-scripts/bigMatrices.at (245 lines)
Definitions
20
Loads
Loaded by
extParamPol.at hodge_K_type_formula.at hodge_test.at

Definitions in source order

fixed_subset

L10fixed_subset ([Param] B,mat delta) = [Param]

indices_subset

L13indices_subset ([Param] subset, [Param] whole) = [int]

delta_orbit_reps

L21delta_orbit_reps ([Param] B,mat delta) = [int]
extract one index from each delta-orbit

complete_indices

L32complete_indices ([Param] B,mat delta) = [(int,int)]
complete_indices(B,delta)=[(0,1),(0,-1),...,(k,0),...]
B[i] delta-fixed contributes (i,1),(i,-1)
each non-fixed pair (i,j_ contributes (i,0))

my_extended_block

L45my_extended_block (Param p,mat delta) = ([Param],[int])
need to finalize extended_block(p,delta)
only need the result and index into block_of(p)
also, return right away if empty to avoid "delta not distinguished" bug
last argument: indices in block_of(p) of fixed entries

tabulate_indices

L70tabulate_indices ([Param] B,mat delta) = ([int],[int],[(int,int)], [int])
B=[p_0,...,p_n] array of parameters
B^delta=[p_{i_0},...,p_{i_m}]  delta-fixed parameters
I=[0,1,...,n], I^delta=[i_0,...,i_m] indices of delta-fixed parameters
f:I^delta->I: B[f[i]]=B^delta[i]
g:I -> I^delta\cup -1: B^delta[g[i]]=B[i] if i\in I^delta, or -1 otherwise
example:
 B=[p_0,...,p_5]
 suppose delta interchanges p_3<->p_4, fixes the rest
 B_delta=[p_0,p_1,p_2,p_5]
 I=[0,1,2,3,4,5]
 I^delta=[0,1,2,5]
 f=[0,1,2,5]         B[f[3]]=B^delta[3]=p_5
 g=[0,1,2,-1,-1,3]   B^delta[g[5]=B[3]=p_5
 complete_indices=[(0,1),(0,-1),(2,1),(2,-1),(3,1),(3,-1),(4,0),(5,1),(5,-1)]
 delta_action=[0,1,2,4,3,5]  so delta_action[i]=j means delta:B[i]=B[j]
 value: [I^delta,g,complete_indices,delta-action]
 tabulate_indices (B,delta)  (this is GL(3,C))
Value: ([0,1,2,5],[0,1,2,-1,-1,3],
  [(0,1),(0,-1),(1,1),(1,-1),(2,1),(2,-1),(3,0),(5,1),(5,-1)],[0,1,2,4,3,5])

poly_add

L84poly_add (i_poly f,i_poly g) = i_poly
some rebranding

poly_sub

L85poly_sub (i_poly f,i_poly g) = i_poly
Commented-out code, lines 87–119 (31 lines)
set big_KL_P_polynomials([Param] B,mat delta)=[[vec]]:
let (I_delta,g,complete_indices,delta_action)=tabulate_indices(B,delta) then
B_delta=for i in I_delta do B[i] od then
P=KL_P_polynomials(B) then
P_delta=KL_P_polynomials(B_delta,delta) in
let ()=prints("P_delta=",P_delta) in
if #P_delta=0 then prints("Note: block not delta-fixed");KL_P_polynomials(B) {block is not fixed by delta} else let
n=#complete_indices then
rv=zero_poly_matrix(n) in
for a:n do
   let (i,epsilon_i)=complete_indices[a] in
 for b:n-a from a do
   let (j,epsilon_j)=complete_indices[b] in
{    let ()=prints("a=",a," b=",b," i=",i," e_i=",epsilon_i," j=",j," e_j=",epsilon_j)  in }
    if a=b then  rv:=matrix_assign(rv,a,b,poly_1) {diagonal entries} else
    if (epsilon_i*epsilon_j=1) {both entries plus or both minus: P+P^delta} then
     let x=g[i] then
         y=g[j] in
{	 let ()=prints("P[i][j]=", P[i][j], " x=", x, " y=", y, " , Pdelta[x][y]=", P_delta[x][y]) in}
         rv:=matrix_assign(rv,a,b,divide_by(2,poly_add(P[i][j],P_delta[x][y])))
    elif (epsilon_i*epsilon_j=-1) then {(+,-) or (-,+): P-P^delta}
     let x=g[i] then
         y=g[j] in
         rv:=matrix_assign(rv,a,b,divide_by(2,poly_sub(P[i][j],P_delta[x][y])))
    elif abs(epsilon_i)=1 and epsilon_j=0 {(\pm,ind): P} then
      rv:=matrix_assign(rv,a,b,P[i][j])
    elif epsilon_i=0 and abs(epsilon_j)=1  {(ind,\pm): P} then
      rv:=matrix_assign(rv,a,b,P[i][j])
    elif epsilon_i=0 and epsilon_j=0 then {(ind,ind): P(gamma,mu)+P(gamma,mu^delta)}
      rv:=matrix_assign(rv,a,b,poly_add(P[i][j],P[i][delta_action[j]]))
    fi fi od od ;rv fi

big_KL_P_polynomials

L121big_KL_P_polynomials ([Param] B,mat delta) = i_poly_mat

big_KL_P_polynomials_at_minus_one

L158big_KL_P_polynomials_at_minus_one ([Param] B,mat delta) = mat

big_KL_P_signed_polynomials

L195big_KL_P_signed_polynomials ([Param] B,mat delta) = i_poly_mat

big_KL_P_signed_polynomials_at_minus_one

L212big_KL_P_signed_polynomials_at_minus_one ([Param] B,mat delta) = mat

is_non_negative 2 overloads

L215is_non_negative ([i_poly] polynomials) = bool
L218is_non_negative (i_poly_mat M) = bool

also defined in polynomial.at

big_KL_Q_polynomials

L221big_KL_Q_polynomials ([Param] B,mat delta) = i_poly_mat

done

L226done = [Param]

pointers

L227pointers = [int]
parallel to |done|, point to one of |P_matrices|

P_matrices

L228P_matrices = [i_poly_mat]

calculate_big_P_signed_polynomials

L231calculate_big_P_signed_polynomials ([Param] B, mat delta, int index) = i_poly_mat
compute matrix for block, but if |B[index]| is in |done| get stored matrix

calculate_big_P_signed_polynomials_at_minus_one

L243calculate_big_P_signed_polynomials_at_minus_one( [Param] B, mat delta, int index) = mat

Generated from atlas-scripts at commit 648506c (2026-10-13).