gap('LoadPackage("QPA");')

def NthRadical(M, n):
    if n == 0:
        f = gap.IdentityMapping(M)
    else:
        f = gap.RadicalOfModuleInclusion(M)
        N = gap.Source(f)
        for i in range(n-1):
            h = gap.RadicalOfModuleInclusion(N);
            N = gap.Source(h)
            f = h * f
    return f

def ARQuiverNak(A):
    injA = gap.IndecInjectiveModules(A)
    L = [gap.Source(NthRadical(inj, j))
         for inj in injA
         for j in range(gap.Dimension(inj).sage())]
    return L

def kupisch(D):
    """
    sage: [kupisch(D) for D in DyckWords(3)]
    [[2, 2, 2, 1], [2, 3, 2, 1], [3, 2, 2, 1], [3, 3, 2, 1], [4, 3, 2, 1]]

    sage: all(kupisch(D) == [a+2 for a in D.reverse().to_area_sequence()[::-1]] + [1] for D in DyckWords(5))
    """
    H = D.heights()
    return [1+H[i] for i, s in enumerate(D) if s == 0]+[1]

def statistic(D):
    D = DyckWord(D)
    K = kupisch(D)
    A = gap.NakayamaAlgebra(K, gap.GF(3))
    g = gap.GlobalDimensionOfAlgebra(A,30)
    L = ARQuiverNak(A)
    LL = [x for x in L
          if not gap.IsProjectiveModule(x) or not gap.IsInjectiveModule(x)]
    r = len(gap.SimpleModules(A)) - (len(L) - len(LL))
    S = [[LL[i-1] for i in s] for s in Subsets(len(LL), r)]
    return sum(1 for x in S
               if gap.N_RigidModule(gap.DirectSumOfQPAModules(x) , g))

# gap code

DeclareOperation("TiltingModules",[IsList]);

InstallMethod(TiltingModules, "for a representation of a quiver", [IsList],0,function(LIST)

local M, n, f, N, i, h;

u:=LIST[1];
A:=NakayamaAlgebra(GF(3),u);
g:=GlobalDimensionOfAlgebra(A,30);
L:=ARQuiver([A,1000])[2];
LL:=Filtered(L,x->(IsProjectiveModule(x)=false or IsInjectiveModule(x)=false));
r:=Size(SimpleModules(A))-(Size(L)-Size(LL));
subsets1:=Combinations([1..Length(LL)],r);subsets2:=List(subsets1,x->LL{x});
W:=Filtered(subsets2,x->N_RigidModule(DirectSumOfQPAModules(x),g)=true);




return([u,Size(W)]);

end);