#######################################################################
## FPL: Save this file as FPL. To use it, stay in the                 #
## same directory, get into Maple (by typing: maple <Enter> )         #
## and then type:  read FPL : <Enter>                                 #
## Then follow the instructions given there                           #
##                                                                    #
## Written by Doron Zeilberger, Rutgers University ,                  #
##  zeilberg at math dot rutgers dot  edu  .                          # 
#######################################################################

print( `This is FPL, Version of April 8, 2008`):
print(` Written by Doron Zeilberger, Rutgers University.`):
print(`It is one of two packages accompanying  Arvind Ayyer and Doron Zeilberger's article`):
print(`A Bijectional Atack on the Razumov-Stroganov Conjecture`):
print(`available from the authtors' websites and from arxiv.org `):
print(``):
print(`Please report bugs to  zeilberg at math dot rutgers dot  edu  .`):
print(`For a list of the procedures type: ezra();`):
print(`For help with a sepcific procedure, type: ezra(ProcedureName);`):
print(`For example, with help on procedure CheckRS, type: ezra(CheckRS);`):

ezra1:=proc()
if args=NULL then
 print(` The supporting procedures are: ASM , AtF, Conns, , eipi, FPLcAll`):
 print(`Mate, Milon`) :
else
  ezra(args):
fi:
end:

ezra:=proc()
if args=NULL then
print(`This is FPL, to study the Razumov-Stroganov conj. `):
 print(` The main procdures are:  CheckRS`):
print(` Conn, DrawFPL , DrawFPLs, FPL, FPLc, RS, Yafe`):

elif nargs=1 and args[1]=ASM then
 print(`ASM(n): the set of ASMs of size n`):

elif nargs=1 and args[1]=AtF then
print(`AtF(a): inputs an asm a, outputs an FPL as a set of edges`):
print(`in [0,k+1]^2`):

elif nargs=1 and args[1]=CheckRS then
print(`CheckRS(k): verifies the R-S conj. for fpl's of length k`):
print(`for example,try: CheckRS(3);`):

elif nargs=1 and args[1]=Conn then
print(`Conn(F,k): the connectivity of the FPL F of size k`):
print(`For example, try: Conn(FPL(3)[1],3);`):

elif nargs=1 and args[1]=Conns then
print(`Conns(k): all the connectivities of {1, ..., 2k}`):

elif nargs=1 and args[1]=DrawFPLno then
print(`DrawFPLno(gu,a,b): draws an fpl with origin at (a,b)`):
print(`For example DrawFPLno(AtF(ASM(2)[1]),0,0);`):

elif nargs=1 and args[1]=DrawFPL then
print(`DrawFPL(gu,a,b,k): draws an fpl with origin at (a,b)`):
print(`For example DrawFPL(FPL(3)[1],0,0,3);`):

elif nargs=1 and args[1]=DrawFPLs then
print(`DrawFPLs(S,k): draws a set of FPLs S of size k`):
print(`For example, try: DrawFPLs(FPL(3),3);`):


elif nargs=1 and args[1]=eipi then
print(`eipi(pi,i): applies e_i to connectivity pi`):
print(`For example, try:`):
print(`eipi({{1,2},{3,4}},2);`):




elif nargs=1 and args[1]=FPL then
print(`FPL(n): The set of fpls of size n`):

elif nargs=1 and args[1]=FPLc then
print(`FPLc(k,C): The set of fpls of size k with connectivity C`):
print(`Try: FPLc(3,Conns(3)[1]);`):

elif nargs=1 and args[1]=FPLcAll then
print(`FPLcAll(n): The table of fpls of size n according to connectivity`):
print(`followed by the set of connectivities`):

elif nargs=1 and args[1]=Mate then
print(`Mate(F,k,i): Given an FPL of size k and one of the starting`):
print(`vertices i, (1<=i<=2k) finds its mate`):
print(`For example, try:`):
print(`Mate(FPL(3)[1],3,1);`):

elif nargs=1 and args[1]=Milon then
print(`Milon(k): all the terminal vertices labelled 1,..., 2k`):
print(`in a size-k FPL, listed in order. Try: Milon(3);`):


elif nargs=1 and args[1]=pASM then
 print(`pASM(n): prints the set of ASMs of size n`):

elif nargs=1 and args[1]=RS then
print(`RS(pi): The set counted by the left hand side of the Razumov-Stroganov conjecture`):
print(`as reformulated in the Ayyer-Zeilberger paper`):
print(`for connectivity pi`):
print(`For example, try: RS(Conns(3)[1]);`):

elif nargs=1 and args[1]=Yafe then
print(`Yafe(k): makes gif files for all FPL's of size k`):
print(`according to the connectivity outputs .gif files`):
print(`names oka.gif where a ranges from 1 to the  Catalan(k)`):
print(`For example, try: Yafe(3);`):


else
print(`No ezra for`, args):
fi:
end:


#Tkn gives the set T_k(n;a), where a=[a_1, ..., a_k] defined in the
#proof of 1.2.1.1
 
Tkn:=proc(k,n,a)
local nakh,i1,b,i,gu,mu:
 
mu:=DECSEQ(k,n-1):
gu:={}:
 
for i from 1 to nops(mu) do
  b:=op(i,mu):
 
nakh:=1:
 
 
 
  for i1 from 1 to 1 do
    if not ( k-i1+1<=op(i1,b) and op(i1,b)<=op(i1,a) )
        then
            nakh:=0:
    fi:
 
  od:
 
  for i1 from 2 to k do
    if not ( k-i1+1<=op(i1,b) and op(i1,b)<=min( op(i1,a),op(i1-1,a)-1 )   )
        then
            nakh:=0:
    fi:
 
  od:
 
 
if nakh=1 then
  gu:=gu union {b}:
fi:
 
od:
 
gu:
 
end:



#GOGa(k,n,a)  gives  the   set of  k by n Gog-trapezoids  such  that
#the rightmost border is the  vector a
 
GOGa:=proc(k,n,a)
local pip,kvu,firow,b,mu,gu,i,j,l,trap,trap1:
 
if  not k>=1 or not n>=k  or  not nops(a)=k  then
  ERROR(`Improper intput`):
fi:
 
 
if n=k and k=1 then
   if not op(1,a)=1 then
     RETURN({}):
   else
     RETURN({[[1]]}):
   fi:
fi:
 
if n=k then
   if not op(1,a)=k then
      ERROR(`Wrong input`):
   fi:
   mu:=GOGa(k-1,k,[op(2..k,a)]):
    gu:={}:
 
    for i from 1 to nops(mu) do
     trap1:=op(i,mu):
     firow:=op(1,trap1):
    
     gu:=gu union {[[op(firow),k],op(2..k,trap1)]}:
        od:
 RETURN(gu):
fi:
 
gu:={}:    
 
kvu:=Tkn(k,n,a):
 
 
 for pip from 1 to nops(kvu) do
   b:=op(pip,kvu):
 
  mu:=GOGa(k,n-1,b):
 
   for j from 1 to nops(mu) do
    trap:=op(j,mu):
    trap1:=[op(1..n-k,trap)]:
 
     for l from n-k+1 to n-1 do
       trap1:=[op(trap1),[op(op(l,trap)),op(l-(n-k),a)]]:
     od:
      
      trap1:=[op(trap1),[op(k,a)]]:
     gu:=gu union {trap1}:
 
   od:
 
 
od:
 
gu:
 
end:



DECSEQ:=proc(k,n)
local gu,gu1,i1:
option remember:
 
if n=1 and  k=1 then
 RETURN({[1]}):
fi:
 
if k=0  and  n>=1 then
    RETURN({[]}):
fi:
 
if n<1 or  k<1  then
   RETURN({}):
fi:
 
gu:=DECSEQ(k,n-1):
gu1:=DECSEQ(k-1,n):
 
for i1 from 1   to  nops(gu1)  do
  gu:=gu  union   {[n,op(op(i1,gu1))]}:
od:
 
gu:
 
end:
 
 
LOGOG:=proc(k,n)
local gu,gu1,i,i1,vec,nakh:
 
if not k>=1  or  not n>=k then
  RETURN({}):
fi:
 
gu1:=DECSEQ(k,n):
 
gu:={}:
 
 
for i from 1 to nops(gu1) do
 vec:=op(i,gu1):
  nakh:=1:
    for  i1  from 1 to k  do
       if  not op(i1,vec)>=k-i1+1 then
           nakh:=0:

           exit:

       fi:
    od:
 
      if nakh=1 then
          gu:=gu union {vec}:
        fi:
od:
 
 
gu:
 
end:

GOGset:=proc(k,n)
local i,gu,lu:
 
lu:=LOGOG(k,n):
gu:={}:
 
for i from 1 to nops(lu) do
 gu:=gu union GOGa(k,n,op(i,lu)):
od:
 
gu:
 
gu:
 
end:

GOGTOASM:=proc(mt)
local k,mat,mat1,ro,i,j:
 
k:=nops(mt):
 
mat:=array(1..k,1..k):
 
for i from 1 to k do
 for j from 1 to k do
   mat[i,j]:=0:
 od:
od:
 
 
  for i from 1 to k do
   ro:=op(i,mt):
    for j from 1 to nops(ro) do
      mat[i,op(j,ro)]:=1:
    od:
  od:
 
for i from 1 to k-1 do
 for j from 1 to k do
  mat1[i,j]:=mat[i,j]-mat[i+1,j]:
 od:
 
 for j from 1 to k do
  mat1[k,j]:=mat[k,j]:
 od:
 
od:
 
[seq([seq(mat1[i,j],j=1..k)],i=1..k)]:
 
end:

pASM:=proc(k)
local i,gu,asm:
 
gu:=GOGset(k,k):
 
print(`There are`, nops(gu),`Alternating Sign Matrices of size`,k):
print(`Here they all are:`):
 
for i from 1 to nops(gu) do
  asm:=GOGTOASM(op(i,gu)):
 print(op(asm)):
od:
end:

ASM:=proc(k)
local i,gu,asm,lu:
 
gu:=GOGset(k,k):
 
lu:={}:
for i from 1 to nops(gu) do
  asm:=GOGTOASM(op(i,gu)):
 lu:=lu union {asm}:
od:
lu:
end:


with(plots):
#DrawFPL(gu,a,b): draws an fpl with origin at (a,b)
#For example DrawFPL(AtF(ASM(2)[1]),0,0);
DrawFPLno:=proc(gu,a,b) local pic,g,gu1:
g:=gu[1]:
pic:=plot([[a+g[1][2],b-g[1][1]],[a+g[2][2],b-g[2][1]]],axes=none):
#scaling=constrained):
gu1:=gu minus {g}:
for g in gu1 do
pic:=pic,plot([[a+g[1][2],b-g[1][1]],[a+g[2][2],b-g[2][1]]],axes=none):
#scaling=constrained):
od:
display(pic):
end:




#AtF(a): inputs an asm a, outputs an FPL as a set of edges
#in [0,k+1]^2
AtF:=proc(a) local i,j,gu,k,Deg,NonEdges:

k:=nops(a):

for i from 0 to k+1 do
for j from 0 to k+1 do
 Deg[i,j]:=0:
od:
od:

gu:={}:

NonEdges:={}:

if k mod 2=1 then

for i from 1 by 2 to k do
gu:=gu union {{[i,1],[i,0]}}:
Deg[i,1]:=Deg[i,1]+1:
Deg[i,0]:=Deg[i,0]+1:
NonEdges:=NonEdges union {{[i+1,1],[i+1,0]}}:
gu:=gu union {{[i,k],[i,k+1]}}:
Deg[i,k]:=Deg[i,k]+1:
Deg[i,k+1]:=Deg[i,k+1]+1:
NonEdges:=NonEdges union {{[i+1,k],[i+1,k+1]}}:
od:

for j from 2 by 2 to k do
gu:=gu union {{ [1,j],[0,j]}}:
Deg[1,j]:=Deg[1,j]+1:
Deg[0,j]:=Deg[0,j]+1:

NonEdges:=NonEdges union {{[1,j-1],[0,j-1]}}:

gu:=gu union {{ [k,j],[k+1,j]}}:

Deg[k,j]:=Deg[k,j]+1:
Deg[k+1,j]:=Deg[k+1,j]+1:


NonEdges:=NonEdges union {{[k,j-1],[k+1,j-1]}}:
od:

NonEdges:=NonEdges union {{[k,k],[k+1,k]}}:
NonEdges:=NonEdges union {{[0,k],[1,k]}}:

else

for i from 1 by 2 to k-1 do
gu:=gu union {{[i,1],[i,0]}}:
Deg[i,1]:=Deg[i,1]+1:
Deg[i,0]:=Deg[i,0]+1:

NonEdges:=NonEdges union {{[i+1,1],[i+1,0]}}:

gu:=gu union {{[i+1,k],[i+1,k+1]}}:
Deg[i+1,k]:=Deg[i+1,k]+1:
Deg[i+1,k+1]:=Deg[i+1,k+1]+1:

NonEdges:=NonEdges union {{[i,k],[i,k+1]}}:
od:

for j from 2 by 2 to k do
gu:=gu union {{ [1,j],[0,j]}}:
Deg[1,j]:=Deg[1,j]+1:
Deg[0,j]:=Deg[0,j]+1:

NonEdges:=NonEdges union {{[1,j-1],[0,j-1]}}:

gu:=gu union {{ [k,j-1],[k+1,j-1]}}:
Deg[k,j-1]:=Deg[k,j-1]+1:
Deg[k+1,j-1]:=Deg[k+1,j-1]+1:

NonEdges:=NonEdges union {{[k,j],[k+1,j]}}:
od:

fi:




for i from 1 to k do
 for j from 1 to k do
  if (i+j mod 2=1 and a[i][j]=1) or (i+j mod 2=0 and a[i][j]=-1) then
  Deg[i,j]:=2:

    if not member({[i,j],[i-1,j]},gu) then
      Deg[i-1,j]:=Deg[i-1,j]+1:
     fi:

    if not member({[i,j],[i+1,j]},gu) then
      Deg[i+1,j]:=Deg[i+1,j]+1:
     fi:

   gu:=gu union {{[i,j],[i-1,j]},{[i,j],[i+1,j]}}:

 elif
 (i+j mod 2=0 and a[i][j]=1) or (i+j mod 2=1 and a[i][j]=-1) then



  Deg[i,j]:=2:

    if not member({[i,j-1],[i,j]},gu) then
      Deg[i,j-1]:=Deg[i,j-1]+1:
     fi:

    if not member({[i,j],[i,j+1]},gu) then
      Deg[i,j+1]:=Deg[i,j+1]+1:
     fi:

   gu:=gu union {{[i,j-1],[i,j]},{[i,j],[i,j+1]}}:

 fi:
od:
od:



for i from 1 to k do
for j from 1 to k do
 if Deg[i,j]=0 then
   gu:=gu union {{[i,j],[i+1,j]}, {[i,j],[i,j+1]}}:

    Deg[i,j]:=2:
    Deg[i+1,j]:=Deg[i+1,j]+1:
    Deg[i,j+1]:=Deg[i,j+1]+1:
 
 elif Deg[i,j]=1 then

 if member({[i,j],[i,j-1]},gu) or member({[i,j],[i,j+1]},gu)  then
   gu:=gu union {{[i,j],[i+1,j]}}:
   Deg[i,j]:=2:
   Deg[i+1,j]:=Deg[i+1,j]+1:
 
elif member({[i,j],[i-1,j]},gu) or member({[i,j],[i+1,j]},gu)  then

   gu:=gu union {{[i,j],[i,j+1]}}:

   Deg[i,j]:=2:
   Deg[i,j+1]:=Deg[i,j+1]+1:
else
  RETURN(FAIL):
 fi:

fi:
od:
od:

 
gu:

end:



#DrawFPL(gu,a,b): draws an fpl with origin at (a,b)
#For example DrawFPL(AtF(ASM(2)[1]),0,0);
DrawFPL:=proc(gu,a,b,k) local pic,g,gu1,i,kulam,mu:
kulam:={seq(seq({[i,j],[i,j+1]},j=1..k-1),i=1..k),
seq(seq({[i,j],[i+1,j]},i=1..k-1),j=1..k)}:

mu:=kulam minus gu:

g:=gu[1]:
pic:=plot([[a+g[1][2],b-g[1][1]],[a+g[2][2],b-g[2][1]]],axes=none):
gu1:=gu minus {g}:
for g in gu1 do
pic:=pic,plot([[a+g[1][2],b-g[1][1]],[a+g[2][2],b-g[2][1]]],axes=none):
od:


for g in mu do
pic:=pic,plot([[a+g[1][2],b-g[1][1]],[a+g[2][2],b-g[2][1]]],color=blue,
linestyle=2,axes=none):
od:

pic:=pic,textplot([a-1/2,b-1,1]):

if k mod 2=1 then

for i from 2 to (k+1)/2 do
 pic:=pic,textplot([a+2*(i-1),b+1/2,i]):
od:

for i from (k+1)/2+1 to k+1 do
 pic:=pic,textplot([a+k+3/2,b-2*(i-(k+1)/2)+1,i]):
od:




for i from k+2  to k+(k+1)/2 do
 pic:=pic,textplot([a+k+1-2*(i-k-1),b-k-3/2,i]):
od:


for i from k+(k+1)/2+1 to 2*k do
 pic:=pic,textplot([a-1/2,b-k-2+2*(i-k-(k+1)/2),i]):
od:



else



for i from 2 to k/2+1 do
 pic:=pic,textplot([a+2*(i-1),b+1/2,i]):
od:

for i from k/2+2 to k+1 do
 pic:=pic,textplot([a+k+3/2,b-2*(i-(k+1)/2)+1,i]):
od:


for i from k+2  to k+k/2+1 do
 pic:=pic,textplot([a+k+1-2*(i-k-1),b-k-3/2,i]):
od:


for i from k+k/2+2 to 2*k do
 pic:=pic,textplot([a-1/2,b-k-2+2*(i-k-(k+1)/2),i]):
od:







fi:

display(pic):
end:



#DrawFPL1(gu,a,b): draws an fpl with origin at (a,b)
#For example DrawFPL(AtF(ASM(2)[1]),0,0);
DrawFPL1:=proc(gu,a,b,k) local pic,g,gu1,i,kulam,mu:
kulam:={seq(seq({[i,j],[i,j+1]},j=1..k-1),i=1..k),
seq(seq({[i,j],[i+1,j]},i=1..k-1),j=1..k)}:

mu:=kulam minus gu:

g:=gu[1]:
pic:=plot([[a+g[1][2],b-g[1][1]],[a+g[2][2],b-g[2][1]]],axes=none):
gu1:=gu minus {g}:
for g in gu1 do
pic:=pic,plot([[a+g[1][2],b-g[1][1]],[a+g[2][2],b-g[2][1]]],axes=none):
od:


for g in mu do
pic:=pic,plot([[a+g[1][2],b-g[1][1]],[a+g[2][2],b-g[2][1]]],color=blue,
linestyle=2,axes=none):
od:

pic:=pic,textplot([a-1/2,b-1,1]):

if k mod 2=1 then

for i from 2 to (k+1)/2 do
 pic:=pic,textplot([a+2*(i-1),b+1/2,i]):
od:

for i from (k+1)/2+1 to k+1 do
 pic:=pic,textplot([a+k+3/2,b-2*(i-(k+1)/2)+1,i]):
od:




for i from k+2  to k+(k+1)/2 do
 pic:=pic,textplot([a+k+1-2*(i-k-1),b-k-3/2,i]):
od:


for i from k+(k+1)/2+1 to 2*k do
 pic:=pic,textplot([a-1/2,b-k-2+2*(i-k-(k+1)/2),i]):
od:



else



for i from 2 to k/2+1 do
 pic:=pic,textplot([a+2*(i-1),b+1/2,i]):
od:

for i from k/2+2 to k+1 do
 pic:=pic,textplot([a+k+3/2,b-2*(i-(k+1)/2)+1,i]):
od:


for i from k+2  to k+k/2+1 do
 pic:=pic,textplot([a+k+1-2*(i-k-1),b-k-3/2,i]):
od:


for i from k+k/2+2 to 2*k do
 pic:=pic,textplot([a-1/2,b-k-2+2*(i-k-(k+1)/2),i]):
od:

fi:

pic:
end:




#FPL(n): The set of fpls of size n
FPL:=proc(n) local gu,g:
gu:=ASM(n):
{seq(AtF(g),g in gu)}:
end:




#DrawFPLs(S,k): draws a set of FPLs S of size k
#For example, try: DrawFPLs(FPL(3),3);
DrawFPLs:=proc(S,k)
local pic,godel,i,j,co:

godel:=trunc(sqrt(nops(S))):


pic:=DrawFPL1(S[1],0,0,k) :

co:=2:

 for i from 1 to godel-1 while co<=nops(S) do
 pic:=pic,DrawFPL1(S[co],i*(k+4),0,k) :
  co:=co+1:
 od:

for j from 1 to godel+1 while co<=nops(S) do
 for i from 0 to godel-1 while co<=nops(S) do
 pic:=pic,DrawFPL1(S[co],i*(k+4),-j*(k+4),k) :
  co:=co+1:
 od:
od:

display(pic):

end:





#Milon(k): all the terminal vertices labelled 1,..., 2k
#in a size-k FPL, listed in order. Try: Milon(3);
Milon:=proc(k) local i,gu:

gu:=[[1,0]]:
if k mod 2 =1 then
gu:=[op(gu),seq([0,2*i],i=1..(k-1)/2)]:
gu:=[op(gu),seq([1+2*i,k+1],i=0..(k-1)/2)]:
gu:=[op(gu),seq([k+1,k-1-2*i],i=0..(k-1)/2-1)]:
gu:=[op(gu),seq([k-2*i,0],i=0..(k-1)/2-1)]:
RETURN(gu):
else

gu:=[op(gu),seq([0,2*i],i=1..k/2)]:
gu:=[op(gu),seq([2*i,k+1],i=1..k/2)]:
gu:=[op(gu),seq([k+1,k-1-2*i],i=0..k/2-1)]:
gu:=[op(gu),seq([k-1-2*i,0],i=0..k/2-2)]:
RETURN(gu):
fi:



end:



#Mate(F,k,i): Given an FPL of size k and one of the starting
#vertices i, (1<=i<=2k) finds its mate
#For example, try:
#Mate(FPL(3)[1],3,1);
Mate:=proc(F,k,i) local M,AM,V,Shakhen,sta,khaveryashan,lu,i1,
khaver,f,v:
M:=Milon(k):

for i1 from 1 to nops(M) do
 AM[M[i1]]:=i1:
od:

V:={seq(op(f),f in F)}:

for v in V do
 Shakhen[v]:={}:
od:

for f in F do
 Shakhen[f[1]]:= Shakhen[f[1]] union {f[2]}:
 Shakhen[f[2]]:= Shakhen[f[2]] union {f[1]}:
od:

sta:=M[i]:


khaver:=Shakhen[sta][1]:
khaveryashan:=sta:
while nops(Shakhen[khaver])=2 do
 lu:=Shakhen[khaver] minus {khaveryashan}:
  khaveryashan:=khaver:
  khaver:=lu[1]:
od:

AM[khaver]:
 end:


#Conn(F,k): the connectivity of the FPL F of size k
#For example, try: Conn(FPL(3)[1],3);
Conn:=proc(F,k) local i,gu,S,s,t:
option remember:
gu:={}:
S:={seq(i,i=1..2*k)}:

while S<>{} do
 s:=S[1]:
 t:=Mate(F,k,s):
 gu:=gu union {{s,t}}:
 S:=S minus {s,t}:
od:
gu:
end:


#Conns(k): all the connectivities of {1, ..., 2k}
Conns:=proc(k) local gu1,gu2,i,lu1,j,g1,g2,gu:
if k=0 then
 RETURN({{}}):
fi:

gu:={}:
for i from 2 by 2 to 2*k do
lu1:={1,i}:
gu1:=Conns((i-2)/2):
gu2:=Conns(k-i/2):

gu1:=subs({seq(j=j+1,j=1..i-2)},gu1):
gu2:=subs({seq(j=j+i,j=1..2*k-i)},gu2):

gu:= gu union { seq(seq({lu1,op(g1),op(g2)},g1 in gu1),g2 in gu2)}:

od:
gu:
end:


ConnsD:=proc(k) local gu,g:
gu:=FPL(k):
{seq(Conn(g,k),g in gu)}:
end:



#FPLcAll(k): the table of all FPLs of size k according to
#connectivity, followed by the list of connectivities
FPLcAll:=proc(k) local gu,mu,T,g,m:
option remember:
gu:=FPL(k):
mu:=Conns(k):

for m in mu do
T[m]:={}:
od:

for g in gu do
 T[Conn(g,k)]:=T[Conn(g,k)] union {g}:
od:

{seq([m,T[m]],m in mu)}:
end:



#FPLc(k,C): Given a k and a connectivity of {1, ..., 2k}
#outputs the set of all FPLs with that connectivity
#for example, try:
#FPLc(3,Conns(3)[1]);
FPLc:=proc(k,C) local gu,g:
gu:=FPLcAll(k):

for g in gu do
 if g[1]=C then
  RETURN(g[2]):
 fi:
od:
FAIL:
end:

#eipi(pi,i): applies e_i to connectivity pi
#For example, try:
#eipi({{1,2},{3,4}},2);
eipi:=proc(pi,i) local ba,k,zug,L,zug1,zug2:
k:=nops(pi):

if i<2*k then
 ba:=i+1:
elif i=2*k then
 ba:=1:
fi:


if member(ba,pi) then
 RETURN(pi):
fi:


for zug in pi while not member(i,zug) do od:
zug1:=zug:
k:=(zug1 minus {i})[1]:

for zug in pi while not member(ba,zug) do od:
zug2:=zug:
L:=(zug2 minus {ba})[1]:

(pi minus {zug1, zug2}) union {{i,ba},{k,L}}:

end:


#RS(pi): The set counted by the left hand side of the Razumov-Stroganov conjecture
#connectivity pi
RS:=proc(pi) local k,sig,gu,C,vu,v,i:
k:=nops(pi):
C:=Conns(k):
gu:={}:

for i from 1 to 2*k do
for sig in C do
 if eipi(sig,i)=pi then
   vu:=FPLc(k,sig):
   gu:=gu union {seq([i,sig,v], v in vu)}:
 fi:
od:
od:
gu:
end:

#CheckRS(k): verifies the R-S conj. for fpl's of length k
#for example,try: CheckRS(3);
CheckRS:=proc(k) local gu,pi:
gu:=Conns(k):

evalb(
{true}={seq(evalb(nops(RS(pi))=2*k*nops(FPLc(k,pi))), pi in gu) }):
end:

 


#DrawFPLs1(S,k,koteret): the plot-structre for FPLs S of size k
#For example, try: DrawFPLs(FPL(3),3);
DrawFPLs1:=proc(S,k,koteret)
local pic,godel,i,j,co:

godel:=trunc(sqrt(nops(S))):


pic:=DrawFPL1(S[1],0,0,k) :

pic:=pic,textplot([3,3,koteret]):

co:=2:

 for i from 1 to godel-1 while co<=nops(S) do
 pic:=pic,DrawFPL1(S[co],i*(k+4),0,k) :
  co:=co+1:
 od:

for j from 1 to godel+1 while co<=nops(S) do
 for i from 0 to godel-1 while co<=nops(S) do
 pic:=pic,DrawFPL1(S[co],i*(k+4),-j*(k+4),k) :
  co:=co+1:
 od:
od:

pic:

end:



#Yafe(k): makes gif files for all FPL's of size k
#according to the connectivity outputs .gif files
#names oka.gif where a ranges from 1 to the  Catalan(k)
#For example, try: Yafe(3);

Yafe:=proc(k) local cu, i,gu,lu:

cu:=Conns(k):

for i from 1 to nops(cu) do
plotsetup(gif,plotoutput= cat(o,k,i, `.gif`),plotoptions=`portrait,noborder`):

lu:=cu[i]:
gu:=FPLc(k,lu):
print(display(DrawFPLs1(gu,k,lu)));

od:

end: