LoadPackage("qpa");

statistics := function(z)
    local R, RR, W, i, T, TT, nn, WW, l;
    R := BuildSequences(z);
    R := reduce(R);
    RR := Filtered(R, x -> gldim(x) < 33 and Minimum(x) >= z);
    W := [];
    for i in RR do 
        Append(W,[translatesinceretodyck([z,i])]);
    od;
    T := BuildSequences(z);
    T := reduce(T);
    TT := Filtered(T, x -> gldim(x) < 33 and Minimum(x) >= z);
    nn := Size(TT);
    WW := [];
    for l in [1..nn] do
        Append(WW, [[W[l],
                     GorensteinDimensionOfstableAusalgnak([NakayamaAlgebra(TT[l], GF(3))])/2]]);
    od;
    return WW;
end;

BuildSequences := function(n)
    local all, range, len, new, seq, i, sel;
    all := [[]];  # start with empty
    range := [2 .. 2*n];  # valid entries
    for len in [1 .. n - 1] do  # build sequences in increasing length
        new := [];
        for seq in all do
            # extend with all possible values based on condition
            if len = 1 then
                sel := [2 .. n + 1];  # otherwise last entry is too large
            else
                sel := Filtered(range, x -> x >= seq[len - 1] - 1
                                       and x >= seq[1]
                                       and x <= seq[1] + n - len + 1);
            fi;
            for i in sel do
                Add(new, Concatenation(seq, [i]));
            od;
        od;
        all := new;
    od;
    # Can we add the last entry while remaining valid?
    return List(all, x -> Concatenation(x, [x[1] + 1]));
end;

rot := function(x)
    local n, a;
    a := x[1];
    n := Length(x);
    x := x{[2 .. n]};
    Add(x, a);
    return x;
end;

canon := function(x)
    local x0, x_min;
    x0 := ShallowCopy(x);
    x_min := ShallowCopy(x);
    while true do
        x := rot(x);
        if x = x0 then
            break;
        fi;
        if x < x_min then
            x_min := ShallowCopy(x);
        fi;
    od;
    return x_min;
end;

reduce := L -> Set(List(L, canon));

DeclareOperation("gldim", [IsList]);

InstallMethod(gldim,
              "for a representation of a quiver",
              [IsList],
              0,
              function(L)
                  local list, n, i, j, f, temp, temp2, temp3, u;

                  list := L;
                  n := Size(L);
                  f := function(x, y)
                      local c, z;
                      c := (x + y) mod n;
                      if c = 0 then
                          c := n;
                      fi;
                      z := (x + 1) mod n;
                      if z = 0 then
                          z := n;
                      fi;
                      return([c, list[z] - y]);
                  end;
                  temp2 := [];
                  for i in [0 .. n - 1] do
                      Append(temp2, [[i, 1]]);
                  od;
                  temp := [];
                  for i in [0 .. n - 1] do
                      u := temp2[i + 1];
                      Append(temp, [[u]]);
                  od;
                  for i in [0 .. n - 1] do
                      j := 1;
                      while j < 2*n + 3 do
                          Append(temp[i + 1],
                                 [f(temp[i + 1][j][1], temp[i + 1][j][2])]);
                          j := j + 1;
                      od;
                  od;
                  temp3 := [];
                  for i in [1 .. n] do
                      temp2 := [];
                      for j in [1 .. (2*n + 3)] do
                          if temp[i][j][2] = 0 then
                              Append(temp2, [j]);
                          fi;
                      od;
                      if Size(temp2) > 0 then
                          u := Minimum(temp2);
                          Append(temp3, [u]);
                      else
                          temp3 := "inf";
                          break;
                      fi;
                  od;
                  if IsString(temp3) = false then
                      temp3 := (Maximum(temp3)) - 2;
                  fi;
                  return(temp3);
              end);

DeclareOperation("translatesinceretodyck", [IsList]);

InstallMethod(translatesinceretodyck,
              "for a representation of a quiver",
              [IsList],
              0,
              function(L)
                  local z, U, UU;

                  z := L[1];
                  U := L[2];
                  Remove(U, 1);
                  UU := U - (z - 1);
                  Append(UU, [1]);
                  return(UU);
              end);

DeclareOperation("injdimstablehomofnonprojindecnak", [IsList]);

InstallMethod(injdimstablehomofnonprojindecnak,
              "for a representation of a quiver",
              [IsList],
              0,
              function(LIST)
                  local A, M, n, P, N;

                  A := LIST[1];
                  M := LIST[2];
                  n := Size(SimpleModules(A));
                  P := Source(ProjectiveCover(M));
                  N := NthSyzygy(M, 1);
                  if InjDimensionOfModule(N, 2*n) <= Minimum(InjDimensionOfModule(M, 2*n),
                                                            InjDimensionOfModule(P, 2*n))
                  then return(3*InjDimensionOfModule(N, 2*n) - 1);
                  else if InjDimensionOfModule(P, 2*n) <= Minimum(InjDimensionOfModule(M, 2*n),
                                                                 InjDimensionOfModule(N, 2*n))
                       then return(3*InjDimensionOfModule(P, 2*n));
                       else return(3*InjDimensionOfModule(M, 2*n) + 1);
                       fi;
                  fi;
              end);

DeclareOperation("domdimstablehomofnonprojindecnak", [IsList]);

InstallMethod(domdimstablehomofnonprojindecnak,
              "for a representation of a quiver",
              [IsList],
              0,
              function(LIST)
                  local A, M, n, P, N;

                  A := LIST[1];
                  M := LIST[2];
                  n := Size(SimpleModules(A));
                  P := Source(ProjectiveCover(M));
                  N := NthSyzygy(M, 1);
                  if DominantDimensionOfModule(N, 2*n) <= Minimum(DominantDimensionOfModule(M, 2*n),
                                                                 DominantDimensionOfModule(P, 2*n))
                  then return(3*DominantDimensionOfModule(N, 2*n));
                  else if DominantDimensionOfModule(P, 2*n) <= Minimum(DominantDimensionOfModule(M, 2*n),
                                                                      DominantDimensionOfModule(N, 2*n))
                       then return(3*DominantDimensionOfModule(P, 2*n) + 1);
                       else return(3*DominantDimensionOfModule(M, 2*n) + 2);
                       fi;
                  fi;
              end);

DeclareOperation("NthRadical", [IsList]);

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

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

                  M := LIST[1];
                  n := LIST[2];

                  if n = 0 then
                      return(IdentityMapping(M));
                  else
                      f := RadicalOfModuleInclusion(M);
                      N := Source(f);

                      for i in [1 .. n - 1] do
                          h := RadicalOfModuleInclusion(N);
                          N := Source(h);
                          f := \*(h, f);
                      od;
                      return(f);
                  fi;
              end);

DeclareOperation("ARQuiverNak", [IsList]);

InstallMethod(ARQuiverNak,
              "for a representation of a quiver",
              [IsList],
              0,
              function(LIST)
                  local A, i, j, injA, UU;

                  A := LIST[1];
                  injA := IndecInjectiveModules(A);
                  UU := [];
                  for i in injA do
                      for j in [0 .. Dimension(i) - 1] do
                          Append(UU, [Source(NthRadical([i, j]))]);
                      od;
                  od;
                  return(UU);
              end);

DeclareOperation("GorensteinDimensionOfstableAusalgnak", [IsList]);

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

                  local A, LL, LL2, W, i;

                  A := LIST[1];
                  LL := ARQuiverNak([A]);
                  LL2 := Filtered(LL, x -> IsProjectiveModule(x) = false
                                      and DominantDimensionOfModule(DualOfModule(x), 33) = 0);
                  W := [];
                  for i in LL2 do
                      Append(W, [injdimstablehomofnonprojindecnak([A, i])]);
                  od;
                  return(Maximum(W));
              end);