{{{id=2|
def YFLO( T1, T2 ): 
    """
    Returns true if T1 is strictly less than T2 in YFLO
    *Y*oung's *F*irst *L*etter *O*rder strictly less than

    EXAMPLES::

        sage: YFLO([[1,2,3]], [[1,2,3]])
        False
        sage: YFLO([[1,2],[3]], [[1,3],[2]]) # first place they differ is 2 is higher in T2
        False
        sage: YFLO([[1,2,3],[4,7,8],[5,9],[6]], [[1,2,3],[4,6,9],[5,8],[7]])
        True # example from the text!
    """
    T1 = StandardTableau(T1)
    T2 = StandardTableau(T2)
    for i in range(1,T1.size()+1):
        c1 = T1.cells_containing(i)[0]
        c2 = T2.cells_containing(i)[0]
        if c1!=c2:  # if the cells are not equal
            return c1[0]>c2[0] # then return True if c1 is higher than c2
    return False # if the tableaux are equal
///
}}}

{{{id=37|
def my_bubble_sort( L, cmp ):
    """
    Sort a list L using the comparison function cmp
    (this is built into sage, but I couldn't make theirs work)
    """
    for i in range(len(L)):
        for j in range(i+1, len(L)):
            if cmp(L[i], L[j]):
                t = L[i]
                L[i] = L[j]
                L[j] = t
    return L
///
}}}

{{{id=15|
def wedge_coordinates( T1, T2 ):
    """
    return the coordinates of the cells of the wedge of T1 and T2
    the wedge operation is described on page 2 of the notes

    It is the list consisting of the first coordinate of i in T1
    and the second coordinate of i in T2 for i in 1..n
    """
    T1 = Tableau(T1)
    T2 = Tableau(T2)
    return [(T1.cells_containing(i)[0][0], T2.cells_containing(i)[0][1]) for i in range(1,T1.size()+1)]
///
}}}

{{{id=64|
def test_good( T1, T2 ):
    """
    Return true if T1 wedge T2 is "good" and false otherwise
    a wedge is considered good if no two cells end up in the same spot
    """
    return len(Set(wedge_coordinates(T1,T2)))==Tableau(T1).size()
///
}}}

{{{id=66|
def action( sig, Tab ):
    """
    act by a permutation on the entries of the tableau Tab
    """
    return [[sig[v-1] for v in row] for row in Tab]
///
}}}

{{{id=65|
def Cee( T1, T2 ):
    """
    If T1^T2 is "good" return the sign of the permutation which permutes the
    entries of T1^T2 to the columns of T2
    This is Definition 1.1 of the notes
    """
    if test_good(T1, T2):
        count = 0
        wc = wedge_coordinates(T1, T2)
        entries=flatten(T2)
        for i in range(len(wc)):
            for j in range(i+1, len(wc)):
                if wc[entries[i]-1][1]==wc[entries[j]-1][1] and wc[entries[i]-1][0]>wc[entries[j]-1][0]:
                    count+=1
        return (-1)^count
    else:
        return 0

def CeeMat( la, sig ):
    """
    a matrix with entries Cee(S, T) where S and T run over all standard
    tableaux listed in YFLO

    Equation 1.4 of the notes
    """
    ST = my_bubble_sort(StandardTableaux(la).list(), YFLO)
    return matrix([[Cee(T1, action(sig, T2)) for T2 in ST] for T1 in ST])

def Amat( la, sig ):
    """
    CeeMat( la, identity )^(-1) * CeeMat( la, sig )

    Equation 1.5 of the notes
    To show: This is an irreducible representation of the symmetric group
    """
    return CeeMat( la, range(1,sum(la)+1)).inverse()*CeeMat(la, sig)
///
}}}

{{{id=29|
def Tabperm( T1, T2 ):
    """
    gives the permutation which when it acts on tableau T1
    converts it into tableau T2

    In the notes this is denoted \sigma_{ij}^\lambda when
    T1 = Tab(la, i) and T2 = Tab(la, j)
    """
    T1 = StandardTableau(T1)
    return Permutation([T2[i][j] for ii in range(1,T1.size()+1) for (i,j) in T1.cells_containing(ii)])
    
def Tab( la, i ):
    """
    returns the i^th standard tableau in the list of all 
    tableaux of shape la listed in YFLO
    """
    ST = my_bubble_sort(StandardTableaux(la).list(), YFLO)
    return ST[i]
///
}}}

{{{id=10|
def N_tab( T ):
    """
    the signed sum over the column stabilizer of T
    """
    T = Tableau(T)
    A = SymmetricGroupAlgebra(QQ, T.size())
    return sum(sig.sign()*A(Permutation(sig)) for sig in T.column_stabilizer())

def P_tab( T ):
    """
    the sum over the row stabilizer of T
    """
    T = Tableau(T)
    A = SymmetricGroupAlgebra(QQ, T.size())
    return sum(A(Permutation(sig)) for sig in T.row_stabilizer())

def gamma_i( la, i ):
    """
    These are elements of the symmetric group algebra appearing in equation 4.1
    of the notes
    """
    hla = mul(Partition(la).hooks())
    return N_tab(Tab(la,i))*P_tab(Tab(la,i))/hla

def e_ij_la( la, i, j ):
    """
    These are elements of the symmetric group algebra appearing in 4.2 of the notes

    They multiply by
    e_ij_la( la, i, j ) * e_ij_la( mu, r, s ) == e_ij_la( la, i, s )
    if j==r and la==mu
    and the product is 0 otherwise
    """
    A = SymmetricGroupAlgebra(QQ, sum(la))
    fla = StandardTableaux(la).cardinality()
    return gamma_i(la, i)*A(Tabperm( Tab(la, i), Tab(la, j) ))*mul( (A.one() - gamma_i(la, r)) for r in range(j+1,fla))
///
}}}

{{{id=67|

///
}}}