# --------------------------------------------------------------------------------------------------
# Monk code: version of April 26, 2003.
# Author: Alexander Yong
#
# Written to accompany: 
# "On combinatorics of cohomology classes related to Schubert calculus"
# by Alexander Yong, a proposed PhD dissertation at the University of Michigan, Ann Arbor
#
# This version requires Maple V,VI,VII and J.R. Stembridge's Coxeter package
# available at his website www.math.lsa.umich.edu/~jrs
#
# This is ** not ** a Maple worksheet
#
# To run this, load Coxeter and this file in a Maple session
# Theorem 5 for the Exceptional Lie types is verified by running "verify_thm()"
# which also prints out the resulting classes in each type
# Note that the labelings of the simple roots in Coxeter and in the thesis differ,
# the code below is written to  
#
# Acknowledgements: I thank John Stembridge for explaining how to use Coxeter to obtain a reduced
#                   word corresponding to a given positive root (which we use in "Monk")
# --------------------------------------------------------------------------------------------------

`Monk`:=proc(root_sys, b_root_position, weyl_elt)
	local the_b_roots, the_pos_roots, transposition, v0, ans,
	      ii,jj,temp_root,weyl_elt_length,prod_temp,n_alpha_beta,beta;

	the_b_roots:=base(root_sys):
	beta:=op(b_root_position,the_b_roots):
	the_pos_roots:=pos_roots(root_sys):
	ans:=0:
	weyl_elt_length:=nops(weyl_elt):

	for ii from 1 to nops(the_pos_roots) do
		v0:=interior_pt(root_sys):
		temp_root:=op(ii,the_pos_roots):
		vec2fc(reflect(temp_root,v0),root_sys,'transposition'):
		prod_temp:=reduce([op(weyl_elt),op(transposition)],root_sys):
		if((nops(prod_temp)-weyl_elt_length)=1) then
			n_alpha_beta:=op(b_root_position,root_coords(temp_root,root_sys)):
			ans:=ans+n_alpha_beta*(iprod(beta,beta)/iprod(temp_root,temp_root))*X[prod_temp]:
		fi: 
	od:

	RETURN(ans):
end:

# This applies Monk to  a linear combo of Schubert classes.
`Monk_poly`:=proc(root_system,i,p) 
# For each element of the ``polynomial'' p we do the Monk calculation, and
# collect terms.
	local num_terms,counter1, p_temp,p_temp1,num_pos_roots,beta_coords,
	alpha_coords,n_alpha_beta,u,s,us,outcoef;

	# bust out if p=0
	if(p=0) then
		RETURN(0):
	fi:

	p_temp:=0;
	
	# num terms is a little tricky: b/c of the way nops works
	if(type(p,`+`)=true) then
			     num_terms:=nops(p):
	else
			     num_terms:=1:
        fi:

	for counter1 from 1 to num_terms by 1 do
	    #we have to keep track of the coefficient that appears in the polynomial
	    if(num_terms=1) then
			    if(nops(p)=1) then
					  outcoef:=1:
			    else
					  outcoef:=op(1,p):
			    fi:
	    else
			    if(nops(op(counter1,p))=1) then
				          outcoef:=1:
			    else
					  outcoef:=op(1,op(counter1,p)):
			    fi:
	    fi:


	    # slightly tricky extracting the right thing here, b/c of the way op works
	    # we need to determine if it is a sum of monomials, or just a single monomial 
	    if(num_terms>1) then
                     u:=op(counter1,p):
		     if(nops(u)=1) then
				   u:=op(u):					                         else
				   u:=op(op(2,u)):
		     fi:
	    else
		     if(nops(p)=1) then
				   u:=op(p):
		     else
				   u:=op(op(2,p)):
		     fi:
	    fi:


	    p_temp1:=Monk(root_system,i,u);
	    p_temp:=p_temp+outcoef*p_temp1;
        od:

	RETURN(p_temp);
end:


# checking type G2
# we only have to compute \tau_{i,d} for d=1,2,3,4,5 

`iterate_MonkG2_1`:=proc()

local iii,SC,ASD;

	iii:=2:
	SC[1]:=X[[1]]:
	print(X[[1]]);
	ASD:=X[[1]]:
	while(iii<6) do
		ASD:=Monk_poly(G2,1,ASD):
		SC[iii]:=ASD;
		
		print(SC[iii]);
		if(searchtext("-",convert(SC[iii],string))>0) then
			print(COUNTEREXAMPLE);
		fi:
		iii:=iii+1:
	od:
	RETURN(SC);
end:

# checking type F4
# Coxeter uses the labelling 1--2=<=3--4, we use 1--4=>=3--2 in the thesis, translate accordingly 
# By looking at the max(i) values, we only have to check for \tau_{2,d} and \tau_{3,d}

`iterate_MonkF4_1`:=proc() # i.e, computing \tau_{2,d}

local iii,SC,ASD,max_nops;

        max_nops:=1:
        iii:=2:
        SC[1]:=X[[1]]:
	print(X[[1]]);
        ASD:=X[[1]]:
        while(iii<10) do
                ASD:=Monk_poly(F4,1,ASD):
                SC[iii]:=ASD;  
                print(SC[iii]);
		if(searchtext("-",convert(SC[iii],string))>0) then
			print(COUNTEREXAMPLE);
		fi:
		if(nops(SC[iii])>max_nops) then
		        max_nops:=nops(SC[iii]):
		fi:
                iii:=iii+1:
           
        od:
	print("Max nops was:");
	print(max_nops);	
        RETURN(SC);
end:


`iterate_MonkF4_2`:=proc() # i.e., compute \tau_{3,d}
			   # assumes iterate_MonkF4_1 dumped out to F4_1
local iii,SC,ASD,max_nops;

        max_nops:=1:
        iii:=2:
        SC[1]:=X[[2]]:
	print(X[[2]]);
        ASD:=X[[2]]:   
        while(iii<8) do
                ASD:=Monk_poly(F4,2,ASD)-Monk_poly(F4,1,ASD)+F4_1[iii]:
                SC[iii]:=ASD;
                print(SC[iii]);
		if(searchtext("-",convert(SC[iii],string))>0) then
			print(COUNTEREXAMPLE);
		fi:
		if(nops(SC[iii])>max_nops) then
		        max_nops:=nops(SC[iii]):
		fi:
                iii:=iii+1:
                
        od:     
	print("Max nops was:");
	print(max_nops);	
        RETURN(SC);
end:

# checking type E6
# Coxeter uses:         We use in the thesis
#       2                     5  
#       |                     |
# 1--3--4--5--6         6--4--3--2--1
# so we translate accordingly
# Note, we only have to check for \tau_{1,d},\tau_{2,d},\tau_{3,d},\tau_{4,d}
# also, we don't have max(i) values to work with, so we compute until we get 0

`iterate_MonkE6_6`:=proc() # i.e, computing \widehat{\tau_{1,d}}

local iii,SC,ASD,max_nops;

        max_nops:=1:
        iii:=2:
        SC[1]:=X[[6]]:
	print(X[[6]]);
        ASD:=X[[6]]:
        while(ASD<>0) do
                ASD:=Monk_poly(E6,6,ASD):
                SC[iii]:=ASD;  
                print(SC[iii]);
		if(searchtext("-",convert(SC[iii],string))>0) then
			print(COUNTEREXAMPLE);
		fi:
		if(nops(SC[iii])>max_nops) then
		        max_nops:=nops(SC[iii]):
		fi:
                iii:=iii+1:
           
        od:
	print("Max nops was:");
	print(max_nops);	
        RETURN(SC);
end:


`iterate_MonkE6_5`:=proc() # i.e., compute \tau_{2,d}
			   # assumes iterate_MonkE6_6 dumped out to E6_6
local iii,SC,ASD,max_nops;

        max_nops:=1:
        iii:=2:
        SC[1]:=X[[5]]:
	print(X[[5]]);
        ASD:=X[[5]]:   
        while(ASD<>0) do
                ASD:=Monk_poly(E6,5,ASD)-Monk_poly(E6,6,ASD)+E6_6[iii]:
                SC[iii]:=ASD;
                print(SC[iii]);
		if(searchtext("-",convert(SC[iii],string))>0) then
			print(COUNTEREXAMPLE);
		fi:
		if(nops(SC[iii])>max_nops) then
		        max_nops:=nops(SC[iii]):
		fi:
                iii:=iii+1:
                
        od:     
	print("Max nops was:");
	print(max_nops);	
        RETURN(SC);
end:

`iterate_MonkE6_4`:=proc() # i.e., compute \tau_{3,d}
			   # assumes iterate_MonkE6_5 dumped out to E6_5
local iii,SC,ASD,max_nops;

        max_nops:=1:
        iii:=2:
        SC[1]:=X[[4]]:
	print(X[[4]]);
        ASD:=X[[4]]:   
        while(ASD<>0) do
                ASD:=Monk_poly(E6,4,ASD)-Monk_poly(E6,5,ASD)+E6_5[iii]:
                SC[iii]:=ASD;
                print(SC[iii]);
		if(searchtext("-",convert(SC[iii],string))>0) then
			print(COUNTEREXAMPLE);
		fi:
		if(nops(SC[iii])>max_nops) then
		        max_nops:=nops(SC[iii]):
		fi:
                iii:=iii+1:
                
        od:     
	print("Max nops was:");
	print(max_nops);	
        RETURN(SC);
end:

`iterate_MonkE6_3`:=proc() # i.e., compute \tau_{4,d}
			   # assumes iterate_MonkE6_4 dumped out to E6_4
local iii,SC,ASD,max_nops;

        max_nops:=1:
        iii:=2:
        SC[1]:=X[[3]]+X[[2]]:
	print(X[[3]]+X[[2]]);
        ASD:=X[[3]]+X[[2]]:   
        while(ASD<>0) do
                ASD:=Monk_poly(E6,3,ASD)+Monk_poly(E6,2,ASD)-Monk_poly(E6,4,ASD)+E6_4[iii]:
                SC[iii]:=ASD;
                print(SC[iii]);
		if(searchtext("-",convert(SC[iii],string))>0) then
			print(COUNTEREXAMPLE);
		fi:
		if(nops(SC[iii])>max_nops) then
		        max_nops:=nops(SC[iii]):
		fi:
                iii:=iii+1:
                
        od:     
	print("Max nops was:");
	print(max_nops);	
        RETURN(SC);
end:

# checking type E7
# Coxeter uses:           We use in the thesis
#       2                        6
#       |			 |
# 1--3--4--5--6--7         7--5--4--3--2--1
# so we translate accordingly
# Note, we only have to check for \tau_{1,d},\tau_{2,d},\tau_{3,d},\tau_{4,d},\tau_{5,d}
# also, we don't have max(i) values to work with, so we compute until we get 0

`iterate_MonkE7_7`:=proc() # i.e, computing \widehat{\tau_{1,d}}

local iii,SC,ASD,max_nops;

        max_nops:=1:
        iii:=2:
        SC[1]:=X[[7]]:
	print(X[[7]]);
        ASD:=X[[7]]:
        while(ASD<>0) do
                ASD:=Monk_poly(E7,7,ASD):
                SC[iii]:=ASD;  
                print(SC[iii]);
		if(searchtext("-",convert(SC[iii],string))>0) then
			print(COUNTEREXAMPLE);
		fi:
		if(nops(SC[iii])>max_nops) then
		        max_nops:=nops(SC[iii]):
		fi:
                iii:=iii+1:
           
        od:
	print("Max nops was:");
	print(max_nops);	
        RETURN(SC);
end:


`iterate_MonkE7_6`:=proc() # i.e., compute \tau_{2,d}
			   # assumes iterate_MonkE7_7 dumped out to E7_7
local iii,SC,ASD,max_nops;

        max_nops:=1:
        iii:=2:
        SC[1]:=X[[6]]:
	print(X[[6]]);
        ASD:=X[[6]]:   
        while(ASD<>0) do
                ASD:=Monk_poly(E7,6,ASD)-Monk_poly(E7,7,ASD)+E7_7[iii]:
                SC[iii]:=ASD;
                print(SC[iii]);
		if(searchtext("-",convert(SC[iii],string))>0) then
			print(COUNTEREXAMPLE);
		fi:
		if(nops(SC[iii])>max_nops) then
		        max_nops:=nops(SC[iii]):
		fi:
                iii:=iii+1:
                
        od:     
	print("Max nops was:");
	print(max_nops);	
        RETURN(SC);
end:

`iterate_MonkE7_5`:=proc() # i.e., compute \tau_{3,d}
			   # assumes iterate_MonkE7_6 dumped out to E7_6
local iii,SC,ASD,max_nops;

        max_nops:=1:
        iii:=2:
        SC[1]:=X[[5]]:
	print(X[[5]]);
        ASD:=X[[5]]:   
        while(ASD<>0) do
                ASD:=Monk_poly(E7,5,ASD)-Monk_poly(E7,6,ASD)+E7_6[iii]:
                SC[iii]:=ASD;
                print(SC[iii]);
		if(searchtext("-",convert(SC[iii],string))>0) then
			print(COUNTEREXAMPLE);
		fi:
		if(nops(SC[iii])>max_nops) then
		        max_nops:=nops(SC[iii]):
		fi:
                iii:=iii+1:
                
        od:     
	print("Max nops was:");
	print(max_nops);	
        RETURN(SC);
end:

`iterate_MonkE7_4`:=proc() # i.e., compute \tau_{4,d}
			   # assumes iterate_MonkE7_5 dumped out to E7_5

local iii,SC,ASD,max_nops;

        max_nops:=1:
        iii:=2:
        SC[1]:=X[[4]]:
	print(X[[4]]);
        ASD:=X[[4]]:   
        while(ASD<>0) do
                ASD:=Monk_poly(E7,4,ASD)-Monk_poly(E7,5,ASD)+E7_5[iii]:
                SC[iii]:=ASD;
                print(SC[iii]);
		if(searchtext("-",convert(SC[iii],string))>0) then
			print(COUNTEREXAMPLE);
		fi:
		if(nops(SC[iii])>max_nops) then
		        max_nops:=nops(SC[iii]):
		fi:
                iii:=iii+1:
                
        od:     
	print("Max nops was:");
	print(max_nops);	
        RETURN(SC);
end:


`iterate_MonkE7_3`:=proc() # i.e., compute \tau_{3,d}
			   # assumes iterate_MonkE7_4 dumped out to E7_4
local iii,SC,ASD,max_nops;

        max_nops:=1:
        iii:=2:
        SC[1]:=X[[3]]+X[[2]]:
	print(X[[3]]+X[[2]]);
        ASD:=X[[3]]+X[[2]]:   
        while(ASD<>0) do
                ASD:=Monk_poly(E7,3,ASD)+Monk_poly(E7,2,ASD)-Monk_poly(E7,4,ASD)+E7_4[iii]:
                SC[iii]:=ASD;
                print(SC[iii]);
		if(searchtext("-",convert(SC[iii],string))>0) then
			print(COUNTEREXAMPLE);
		fi:
		if(nops(SC[iii])>max_nops) then
		        max_nops:=nops(SC[iii]):
		fi:
                iii:=iii+1:
                
        od:     
	print("Max nops was:");
	print(max_nops);	
        RETURN(SC);
end:

# checking type E8
# Coxeter uses:             We use in the thesis
#       2                         7
#       |			  |
# 1--3--4--5--6--7--8       8--6--5--4--3--2--1
# so we translate accordingly
# Note, we only have to check for \tau_{1,d},\tau_{2,d},\tau_{3,d},\tau_{4,d},\tau_{5,d},\tau_{6,d}
# also, we don't have max(i) values to work with, so we compute until we get 0

`iterate_MonkE8_8`:=proc() # i.e, computing \widehat{\tau_{1,d}}

local iii,SC,ASD,max_nops;

        max_nops:=1:
        iii:=2:
        SC[1]:=X[[8]]:
	print(X[[8]]);
        ASD:=X[[8]]:
        while(ASD<>0) do
                ASD:=Monk_poly(E8,8,ASD):
                SC[iii]:=ASD;  
                print(SC[iii]);
		if(searchtext("-",convert(SC[iii],string))>0) then
			print(COUNTEREXAMPLE);
		fi:
		if(nops(SC[iii])>max_nops) then
		        max_nops:=nops(SC[iii]):
		fi:
                iii:=iii+1:
           
        od:
	print("Max nops was:");
	print(max_nops);	
        RETURN(SC);
end:

`iterate_MonkE8_7`:=proc() # i.e., compute \tau_{2,d}
			   # assumes iterate_MonkE8_8 dumped out to E8_8
local iii,SC,ASD,max_nops;

        max_nops:=1:
        iii:=2:
        SC[1]:=X[[7]]:
	print(X[[7]]);
        ASD:=X[[7]]:   
        while(ASD<>0) do
                ASD:=Monk_poly(E8,7,ASD)-Monk_poly(E8,8,ASD)+E8_8[iii]:
                SC[iii]:=ASD;
                print(SC[iii]);
		if(searchtext("-",convert(SC[iii],string))>0) then
			print(COUNTEREXAMPLE);
		fi:
		if(nops(SC[iii])>max_nops) then
		        max_nops:=nops(SC[iii]):
		fi:
                iii:=iii+1:
                
        od:     
	print("Max nops was:");
	print(max_nops);	
        RETURN(SC);
end:

`iterate_MonkE8_6`:=proc() # i.e., compute \tau_{2,d}
			   # assumes iterate_MonkE8_7 dumped out to E8_7
local iii,SC,ASD,max_nops;

        max_nops:=1:
        iii:=2:
        SC[1]:=X[[6]]:
	print(X[[6]]);
        ASD:=X[[6]]:   
        while(ASD<>0) do
                ASD:=Monk_poly(E8,6,ASD)-Monk_poly(E8,7,ASD)+E8_7[iii]:
                SC[iii]:=ASD;
                print(SC[iii]);
		if(searchtext("-",convert(SC[iii],string))>0) then
			print(COUNTEREXAMPLE);
		fi:
		if(nops(SC[iii])>max_nops) then
		        max_nops:=nops(SC[iii]):
		fi:
                iii:=iii+1:
                
        od:     
	print("Max nops was:");
	print(max_nops);	
        RETURN(SC);
end:

`iterate_MonkE8_5`:=proc() # i.e., compute \tau_{3,d}
			   # assumes iterate_MonkE8_6 dumped out to E8_6
local iii,SC,ASD,max_nops;

        max_nops:=1:
        iii:=2:
        SC[1]:=X[[5]]:
	print(X[[5]]);
        ASD:=X[[5]]:   
        while(ASD<>0) do
                ASD:=Monk_poly(E8,5,ASD)-Monk_poly(E8,6,ASD)+E8_6[iii]:
                SC[iii]:=ASD;
                print(SC[iii]);
		if(searchtext("-",convert(SC[iii],string))>0) then
			print(COUNTEREXAMPLE);
		fi:
		if(nops(SC[iii])>max_nops) then
		        max_nops:=nops(SC[iii]):
		fi:
                iii:=iii+1:
                
        od:     
	print("Max nops was:");
	print(max_nops);	
        RETURN(SC);
end:

`iterate_MonkE8_4`:=proc() # i.e., compute \tau_{4,d}
			   # assumes iterate_MonkE8_5 dumped out to E8_5

local iii,SC,ASD,max_nops;

        max_nops:=1:
        iii:=2:
        SC[1]:=X[[4]]:
	print(X[[4]]);
        ASD:=X[[4]]:   
        while(ASD<>0) do
                ASD:=Monk_poly(E8,4,ASD)-Monk_poly(E8,5,ASD)+E8_5[iii]:
                SC[iii]:=ASD;
                print(SC[iii]);
		if(searchtext("-",convert(SC[iii],string))>0) then
			print(COUNTEREXAMPLE);
		fi:
		if(nops(SC[iii])>max_nops) then
		        max_nops:=nops(SC[iii]):
		fi:
                iii:=iii+1:
                
        od:     
	print("Max nops was:");
	print(max_nops);	
        RETURN(SC);
end:


`iterate_MonkE8_3`:=proc() # i.e., compute \tau_{3,d}
			   # assumes iterate_MonkE8_4 dumped out to E8_4
local iii,SC,ASD,max_nops;

        max_nops:=1:
        iii:=2:
        SC[1]:=X[[3]]+X[[2]]:
	print(X[[3]]+X[[2]]);
        ASD:=X[[3]]+X[[2]]:   
        while(ASD<>0) do
                ASD:=Monk_poly(E8,3,ASD)+Monk_poly(E8,2,ASD)-Monk_poly(E8,4,ASD)+E8_4[iii]:
                SC[iii]:=ASD;
                print(SC[iii]);
		if(searchtext("-",convert(SC[iii],string))>0) then
			print(COUNTEREXAMPLE);
		fi:
		if(nops(SC[iii])>max_nops) then
		        max_nops:=nops(SC[iii]):
		fi:
                iii:=iii+1:
                
        od:     
	print("Max nops was:");
	print(max_nops);	
        RETURN(SC);
end:


# Verify theorem procedure
# If positivity fails, "COUNTEREXAMPLE" should get written out

`verify_thm`:=proc() 
			 
global F4_1,E6_6,E6_5,E6_4,E6_3,E7_7,E7_6,E7_5,E7_4,E7_3,E8_8,E8_7,E8_6,E8_5,E8_4,E8_3;

      print("Remember that Coxeter2_2v and our thesis conventions on root labellings differ.");
      print("We have internally accounted for this, see the source code");

      print("Type G2 check");
      print("For i=1");
      iterate_MonkG2_1();

      print("Type F4 check");
      print("For i=2");
      F4_1:=iterate_MonkF4_1();
      print("For i=3");
      iterate_MonkF4_2();

      print("Type E6 check");
      print("For i=1");
      E6_6:=iterate_MonkE6_6();
      print("For i=2");
      E6_5:=iterate_MonkE6_5();
      print("For i=3");
      E6_4:=iterate_MonkE6_4();
      print("For i=4");
      E6_3:=iterate_MonkE6_3();           

      print("Type E7 check");
      print("For i=1");
      E7_7:=iterate_MonkE7_7();
      print("For i=2");
      E7_6:=iterate_MonkE7_6();
      print("For i=3");
      E7_5:=iterate_MonkE7_5();
      print("For i=4");
      E7_4:=iterate_MonkE7_4();       
      print("For i=5");
      E7_3:=iterate_MonkE7_3();

      print("Type E8 check");
      print("For i=1");
      E8_8:=iterate_MonkE8_8();
      print("For i=2");
      E8_7:=iterate_MonkE8_7();
      print("For i=3");
      E8_6:=iterate_MonkE8_6();
      print("For i=4");
      E8_5:=iterate_MonkE8_5();       
      print("For i=5");
      E8_4:=iterate_MonkE8_4();
      print("For i=6");
      E8_3:=iterate_MonkE8_3();           

      RETURN(0);
end: