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

 
#Created: June 2026

print(`This is ParkingSchroder.txt, a Maple package that efficiently computes the number of parking functions of length n`):
print(`that lead to permutations that avoid the patterns 1234 and 2134, whose naive count is given by the Schroeder numbers`):
print(`Hence they may viewed as Parking analogs of Schroder numbers.`):

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 procedures are: Bni, Bnir`):
else
ezra(args):
fi:

end:



ezra:=proc()

if args=NULL then
 print(`The main procedures are:  Bn`):



elif nargs=1 and args[1]=Bn  then
print(`Bn(n), The number of parking functions of length n that lead to permutations that avoid the patterns 1234 and 2134,  done via the SCHEME`):
print(`Try:`):
print(`[seq(Bn(n),n=1..30)];`):

elif nargs=1 and args[1]=Bni  then
print(`Bni(n,i), The number of parking functions of length n that lead to permutations that avoid the patterns 1234 and 2134 and end with i,  done via the SCHEME`):
print(`Try:`):
print(`[seq(Bni(10,i),i=1..10)];`):


elif nargs=1 and args[1]=Bnir  then
print(`Bnri(n,i,r), The number of parking functions of length n that lead to permutations that avoid the patterns 1234 and 2134 and end with i, and the parking table ends with r. Done via the SCHEME`):
print(`Try:`):
print(`[seq(Bnir(10,5,r),r=1..5)];`):

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

#Bn(n), The number of parking functions of length n that lead to permutations that avoid the patterns 1234 and 2134,  done via the SCHEME
Bn:=proc(n) local i:
option remember:
if n=0 then
 RETURN(1):
fi:
add(Bni(n,i),i=1..n):
end:

#Bni(n,i), The number of parking functions of length n that lead to permutations that avoid the patterns 1234 and 2134 and that end with i, by the SCHEME
Bni:=proc(n,i) local r:
option remember:
add(Bnir(n,i,r),r=1..i):
end:
#Bnir(n,i,r): The number of parking functions of length n that lead to permutations that avoid the patterns 1234 and 2134 and that end with i, and whose CFO vector ends with r, by the SCHEME:
Bnir:=proc(n,i,r) local j,r1:
option remember:
if n=1 then
if i=1 and r=1 then
 RETURN(1):
 else
  RETURN(0):
fi:
fi:

if n=2 then
if i=1 and r=1 then
 RETURN(1):
 elif i=2 and r=2 then
  RETURN(2):
 else
  RETURN(0):
fi:
fi:

if n=3 then
 if i=1 and r=1 then
  RETURN(3):
   elif i=2 and r=1 then
  RETURN(2):
   elif i=2 and r=2 then
  RETURN(2):
   elif i=3 and r=3 then
  RETURN(9):
   else
  RETURN(0):
  fi:
 fi:

if r=1 then
RETURN(add(Bni(n-1,j),j=i..n-1)):
fi:
if r=2 then
 if i=2 then
  RETURN(2*Bn(n-2)):
  else
  RETURN(4*Bnir(n-1,i-1,1)):
 fi:
fi:

if i=r and i<n then
 RETURN(Bn(n-r)*Bni(r,r)):
fi:

if i=r and i=n then
RETURN(n/(n-1)*Bnir(n-1,n-1,n-1)+add(2*n/(n-r1)*Bnir(n-r1,n-r1,n-r1),r1=2..n-1)):
fi:
r/(r-1)*Bnir(n-1,i-1,r-1)+add(2*r/(r-j)*Bnir(n-j,i-j,r-j),j=2..r-1)+r*Bnir(n-r+1,i-r+1,1):
end: