#####################################################################
##PWilfCases.txt: Save this file as PWilfCases.txt.                  #
#To use it, stay in the                                              #
##same directory, get into Maple (by typing: maple <Enter> )         #
##and then type:  read `PWilfcases.txt` : <Enter                     #
##Then follow the instructions given there                           #
##                                                                   #
##Written by Lucy Martinez and Doron Zeilberger, Rutgers University  #
#######################################################################

 
#Created: July 2025. 

print(`This is PWilfCases.txt, a Maple package that does special cases of schemes for Parking-counting special Pattern avoding classes`):
print(`It is one of the packages in an article by Lucy Martinez and Doron Zeilberger`):
print(`Auomated Counting of Parking Wilf Classes`):
print(`This Maple package, as well as the article, are `):
print(`available from:`):
print(` http://www.math.rutgers.edu/~zeilberg/mamarim/mamarimhtml/pwilf.html `):
lprint(``):
print(`Please report bugs to DoronZeil@gmail.com `):

print(``):
print(`-----------------------------`):

lprint(``):
 print(`For a list of the procedures type ezra(), for help with`):
 print(`a specific procedure, type ezra(procedure_name)`):
print(`-----------------------------`):


print(`-----------------------------`):
 print(``):
lprint(``):
 print(`For a list of the supporting procedures type ezra1(), for help with`):
 print(`a specific procedure, type ezra(procedure_name)`):
print(`-----------------------------`):


with(combinat):



ezra1:=proc()

if args=NULL then
 print(` The supporting procedurs are: a123, All1a, All1b, All1c, b123132, c123231, Childa, Childb, Childc `):
else
ezra(args):
fi:

end:



ezra:=proc()

if args=NULL then
 print(`The main procedures are: A123, B123132, C123231`):
 print(`   `):



elif nops([args])=1 and op(1,[args])=a123 then
print(`a123(n,s): the contribution from suffix s to 123-avoiding permutations`):


elif nops([args])=1 and op(1,[args])=A123 then
print(`A123(n): the number of parking functions that lead to 123-avoding permutations of length n. Try:`):
print(`[seq(A123(i),i=1..20)];`):

elif nops([args])=1 and op(1,[args])=All1a then
print(`All1a(n): all the bi-suffixes of 123-avoiding permutations. Try:`):
print(`All1a(7);`):


elif nops([args])=1 and op(1,[args])=All1b then
print(`All1b(n): all the bi-suffixes of 123- and 132avoiding permutations. Try:`):
print(`All1b(7);`):


elif nops([args])=1 and op(1,[args])=All1c then
print(`All1c(n): all the bi-suffixes of 123- and  231 voiding permutations. Try:`):
print(`All1c(7);`):



elif nops([args])=1 and op(1,[args])=B123132 then
print(`B123132(n): the number of parking functions that lead to {123, 132} -avoding permutations of length n. Try:`):
print(`[seq(B123132(i),i=1..20)];`):

elif nops([args])=1 and op(1,[args])=b123132 then
print(`b123132(n,s): the contribution from suffix s to 123- and 132 avoiding permutations`):


elif nops([args])=1 and op(1,[args])=c123231 then
print(`c123231(n,s): the contribution from suffix s to 123- and 231 avoiding permutations`):


elif nops([args])=1 and op(1,[args])=C123231 then
print(`C123231(n): the number of parking functions that lead to {123, 231} -avoding permutations of length n. Try:`):
print(`[seq(C123231(i),i=1..20)];`):

elif nops([args])=1 and op(1,[args])=Childa then
print(`Childa(n,s): all the kids of suffix s for permutations of length n avoiding 123. Try:`):
print(`Childa(7,[[1],[1]]);`):

elif nops([args])=1 and op(1,[args])=Childb then
print(`Childb(n,s): all the kids of suffix s for permutations of length n avoiding 123 and 132. Try:`):
print(`Childb(7,[[1],[1]]);`):

elif nops([args])=1 and op(1,[args])=Childc then
print(`Childc(n,s): all the kids of suffix s for permutations of length n avoiding 123 and 231. Try:`):
print(`Childc(7,[[1],[1]]);`):

else
print(`There is no ezra for`,args):
fi:
 
end:

ez:=proc(): print(`All1a(n), Childa(n,s), a123(n,s), A123(n) `): end:


#Start 123-avoiding
#All1a(n): all the bi-suffixes of 123-avoiding permutations. Try
#All1a(7);
All1a:=proc(n) local i,r:
{seq(seq([[i],[r]],r=1..i),i=1..n-1),[[n],[n]]}:
end:

#Childa(n,s): all the kids of suffix s for permutations of length n avoiding 123. Try:
#Childa(7,[[1],[1]]);
Childa:=proc(n,s) local a1,i,j:
if not member(s,All1a(n)) then
  RETURN(FAIL):
fi:

a1:=s[1][1]:

if s[2]=[1] then
 RETURN({seq(seq([[i,a1],[j,1]],j=1..i-1),i=a1+1..n-1), [[n,a1],[n-1,1]]}):
else
RETURN({[[1,s[1][1]],[1,s[2][1]]]}):
fi:


end:



#a123(n,s): the contribution from suffix s
a123:=proc(n,s) local lu,lu1:
option remember:
if n=1 then
 if s=[[1],[1]] then
  RETURN(1):
 else
  RETURN(0):
fi:
fi:


if nops(s[1])=1 then
lu:=Childa(n,s):
RETURN(add(a123(n,lu1),lu1 in lu)):
fi:

if s[1][1]>s[1][2] then
  if s[2][2]<>1 then
   RETURN(FAIL):
  else
 RETURN(a123(n-1,[[s[1][1]-1],[s[2][1]]])):
  fi:
else
 if s[1][1]<>1 then
  RETURN(FAIL):
else
 RETURN(s[2][2]/(s[2][2]-1)*a123(n-1,[[s[1][2]-1],[s[2][2]-1]])):
fi:
fi:
end:





#A123(n): The sum of CFO for 123-avoding permutations of length n. Try:
#A123(10):
A123:=proc(n) local gu,gu1:
option remember:
gu:=All1a(n):
add(a123(n,gu1), gu1 in gu):
end:

#End 123-avoiding

#Start 123 and 132 -avoiding

ez:=proc(): print(`All1b(n), Childb(n,s), b123132(n,s), B123132(n) `): end:


#All1b(n): all the bi-suffixes of 123-avoiding permutations. Try
#All1b(7);
All1b:=proc(n) local i:
{seq([[i],[i]],i=1..n)}:
end:

#Childb(n,s): all the kids of suffix s for permutations of length n avoiding 123. Try:
#Childb(7,[[1],[1]]);
Childb:=proc(n,s) local i:
if not member(s,All1b(n)) then
  RETURN(FAIL):
fi:

if s=[[1],[1]] then
 RETURN({seq([[i,1],[i-1,1]],i=2..n)}):
else
 RETURN({[[1,s[1][1]],[1,s[2][1]]]}):
fi:

end:


#B123132(n): The sum of CFO for 123-avoding permutations of length n. Try:
#B123132(10):
B123132:=proc(n) local gu,gu1:
option remember:
gu:=All1b(n):
add(b123132(n,gu1), gu1 in gu):
end:



#b123132(n,s): the contribution from suffix s
b123132:=proc(n,s) local lu,lu1:
option remember:
if n=1 then
 if s=[[1],[1]] then
  RETURN(1):
 else
  RETURN(0):
fi:
fi:


if nops(s[1])=1 then
lu:=Childb(n,s):
RETURN(add(b123132(n,lu1),lu1 in lu)):
fi:

if s[1][1]>s[1][2] then
  if s[2][2]<>1 then
   RETURN(FAIL):
  else
 RETURN(b123132(n-1,[[s[1][1]-1],[s[2][1]]])):
  fi:
else
 if s[1][1]<>1 then
  RETURN(FAIL):
else
 RETURN(s[2][2]/(s[2][2]-1)*b123132(n-1,[[s[1][2]-1],[s[2][2]-1]])):
fi:
fi:
end:

#End 123 and 132 -avoiding




#123 and 231 avoding
ez:=proc(): print(`All1c(n), Childc(n,s), c123231(n,s), C123231(n) `): end:


#All1c(n): all the bi-suffixes of 123-avoiding permutations. Try
#All1c(7);
All1c:=proc(n) local i:
{seq([[i],[i]],i=1..n-1),seq([[i],[1]],i=1..n-1),[[n],[n]]}
end:

#Childc(n,s): all the kids of suffix s for permutations of length n avoiding 123. Try:
#Child(7,[[1],[1]]);
Childc:=proc(n,s):
if not member(s,All1c(n)) then
  RETURN(FAIL):
fi:

if s=[[1],[1]] then
 RETURN({[[2,1],[1,1]]}):
fi:

if s[1]=s[2] then
RETURN({[[1,s[1][1]],[1,s[2][1]]]}):
else
 if s[2][1]<>1 then
  RETURN(FAIL):
elif s=[[n-1],[1]] then
  RETURN({[[n,n-1],[n-1,1]]}):
else
 RETURN({[[s[1][1]+1,s[1][1]],[s[1][1],1]],[[s[1][1]+1,s[1][1]],[1,1]]}):
 fi:

fi:

end:


#C123231(n): The sum of CFO for 123-avoding permutations of length n. Try:
#C123231(10):
C123231:=proc(n) local gu,gu1:
option remember:
gu:=All1c(n):
add(c123231(n,gu1), gu1 in gu):
end:



#c123231(n,s): the contribution from suffix s
c123231:=proc(n,s) local lu,lu1:
option remember:
if n=1 then
 if s=[[1],[1]] then
  RETURN(1):
 else
  RETURN(0):
fi:
fi:


if nops(s[1])=1 then
lu:=Childc(n,s):
RETURN(add(c123231(n,lu1),lu1 in lu)):
fi:

if s[1][1]>s[1][2] then
if s[1][1]-s[1][2]<>1 then
 RETURN(FAIL):
else
 RETURN(c123231(n-1,[[s[1][1]-1],[s[2][1]]])):
fi:
fi:

 if s[1][1]<>1 then
  RETURN(FAIL):
else
 RETURN(s[2][2]*c123231(n-1,[[1],[1]])):
fi:

end: