# This is code to check the E6 version of the Lemma 2.4 in the paper
# "Cominuscule tableau combinatorics" by Hugh Thomas and Alexander Yong
# Start the check by e6teststart(). This procedure takes one input "traceit"
# which if set equal to 1 will output the current position of the tableaux
# being analyzed together with the positions that the program is considering to 
# slide into (in standard matrix notation). 
# The program checks if after each choice of slide that the two (claimed) dual equivalent
# tableau retain the same shape. If not "COUNTEREXAMPLE" is noted. Otherwise the code
# terminates with a "1".
#
# for example:
#
#
#  [Z    Z    Z    1    3    5    _    _]
#  [                                    ]
#  [Z    Z    Z    _    2    4    Z    Z]
#  [                                    ],
#  [Z    Z    _    _    _    Z    Z    Z]
#  [                                    ]
#  [_    _    _    _    _    Z    Z    Z]
#
#        [Z    Z    Z    2    3    5    _    _]
#        [                                    ]
#        [Z    Z    Z    _    1    4    Z    Z]
#        [                                    ]
#        [Z    Z    _    _    _    Z    Z    Z]
#        [                                    ]
#        [_    _    _    _    _    Z    Z    Z]
#
#                               [[1, 7]]
#
#
# shows the current skew tableau and the two possible reverse jdt slides (towards the NE corner)
# that are possible.
#

`e6teststart`:=proc(traceit) local ii, ambientmatrix, aa, bb, ambientmatrix2, jj, ambientmatrix3, 
                            ambientmatrix4, kk, thematrix;

	ambientmatrix:=linalg[matrix](4,8):

	for aa from 1 to 4 do
		    for bb from 1 to 8 do
			if(aa=1) then
				if(bb>=4 and bb<=8) then
				   ambientmatrix[aa,bb]:=_:
				else
				   ambientmatrix[aa,bb]:=Z:
				fi:
			fi:
			if(aa=2) then
				if(bb>=4 and bb<=6) then
				   ambientmatrix[aa,bb]:=_:
				else
				   ambientmatrix[aa,bb]:=Z:
				fi:
			fi:
			if(aa=3) then
				if(bb>=3 and bb<=5) then
				   ambientmatrix[aa,bb]:=_:
				else
				   ambientmatrix[aa,bb]:=Z:
				fi:
			fi:
			if(aa=4) then
				if(bb>=1 and bb<=5) then
				   ambientmatrix[aa,bb]:=_:
				else
				   ambientmatrix[aa,bb]:=Z:
				fi:
			fi:
		    od:
	od:
	
	ambientmatrix2:=linalg[matrix](4,8):
	for ii from 1 to 4 do
	    for jj from 1 to 8 do
		ambientmatrix2[ii,jj]:=ambientmatrix[ii,jj]:
	    od:
	od:

	ambientmatrix[4,1]:=1;
	ambientmatrix[4,2]:=2;
	ambientmatrix[4,3]:=3;
	ambientmatrix[4,4]:=4;
	ambientmatrix[3,3]:=5;

	ambientmatrix2[4,1]:=1;
	ambientmatrix2[4,2]:=2;
	ambientmatrix2[4,3]:=3;
	ambientmatrix2[4,4]:=5;
	ambientmatrix2[3,3]:=4;
	print(ambientmatrix, ambientmatrix2);
	e6testrec(ambientmatrix, ambientmatrix2, traceit);

end:


`e6testrec`:=proc(inputmatrix1, inputmatrix2, traceit) local ambientmatrix, ambientmatrix2, ii, jj, aa, bb, slidelist, ambientmatrix3,
                                                    ambientmatrix4, kk;


	ambientmatrix:=linalg[matrix](4,8):
	ambientmatrix2:=linalg[matrix](4,8):
	for ii from 1 to 4 do
	    for jj from 1 to 8 do
		ambientmatrix[ii,jj]:=inputmatrix1[ii,jj]:
		ambientmatrix2[ii,jj]:=inputmatrix2[ii,jj]:
	    od:
	od:
	
	ambientmatrix3:=linalg[matrix](4,8):
	ambientmatrix4:=linalg[matrix](4,8):

	if(traceit=1) then
		      print(ambientmatrix, ambientmatrix2):
	fi:

	# now determine boxes that can be slid into
	slidelist:=slideableboxes(ambientmatrix, traceit):
	if(nops(slidelist)=0) then
		#print(DONEDONE);
		return(1);
	else
		for kk from 1 to nops(slidelist) do
		    ambientmatrix3:=revjdt(op(kk,slidelist),ambientmatrix):
		    ambientmatrix4:=revjdt(op(kk,slidelist),ambientmatrix2):
		    if(testsameshape(ambientmatrix3,ambientmatrix4)=0) then
			print(COUNTEREXAMPLE, ambientmatrix, ambientmatrix2):
		    else
			#print(ambientmatrix3, ambientmatrix4);
			e6testrec(ambientmatrix3, ambientmatrix4, traceit):
		    fi:
		od:
	fi:
end:

# returns a list
`slideableboxes`:=proc(inputmatrix, traceit) local ii, slidelist, thematrix, jj, leftmin, flag; 

	slidelist:=[]:
	thematrix:=linalg[matrix](4,8):
	for ii from 1 to 4 do
	    for jj from 1 to 8 do
		thematrix[ii,jj]:=inputmatrix[ii,jj]:
	    od:
	od:

	leftmin:=-99;
	for jj from 2 to 8 do
	    ii:=4:
	    flag:=0:
	    while(ii>=1 and flag=0) do:
		    if(thematrix[ii,jj]=_) then
			if(ii>leftmin) then    				       
			   if(ii=4) then

				    if(thematrix[ii,jj-1]<>Z and thematrix[ii,jj-1]<>_) then
					slidelist:=[op(slidelist), [ii,jj]]:
					leftmin:=4:
					flag:=1:
				    fi:
			   else
				    if(thematrix[ii+1,jj]=Z) then
					if(thematrix[ii,jj-1]<>Z and thematrix[ii,jj-1]<>_) then
					    slidelist:=[op(slidelist),[ii,jj]]:
					    leftmin:=ii:
					    flag:=1:
					fi:
				    else 
					if(thematrix[ii+1,jj]<>Z and thematrix[ii+1,jj]<>_) then
					  slidelist:=[op(slidelist), [ii,jj]]:
					  leftmin:=ii:
					  flag:=1:
					fi:
				    fi:
			   fi:   
			fi:
		    fi:
	            ii:=ii-1:	
	    od:
	od:
	if(traceit=1) then
		      print(slidelist);
	fi:
	return(slidelist):
end:

# execute a revjdtslide

`revjdt`:=proc(inputslideposition, inputmatrix) local ii, ambientmatrix, slideposition, jj, jdtslidedone, leftvalue, downvalue;

				
	slideposition:=inputslideposition;
	ambientmatrix:=linalg[matrix](4,8);
	for ii from 1 to 4 do
	    for jj from 1 to 8 do
		ambientmatrix[ii,jj]:=inputmatrix[ii,jj]:
	    od:
	od:
	# now do the sliding
	jdtslidedone:=0:
	while(jdtslidedone=0) do
 	  if((op(2,slideposition)>1) and 
                            (ambientmatrix[op(1,slideposition),op(2,slideposition)-1]<>Z) and
			    (ambientmatrix[op(1,slideposition),op(2,slideposition)-1]<>_)) then
		leftvalue:=ambientmatrix[op(1,slideposition),op(2,slideposition)-1]: 
	  else
		leftvalue:=-infinity:
	  fi:

	  if((op(1,slideposition)<4) and 
                            (ambientmatrix[op(1,slideposition)+1,op(2,slideposition)]<>Z) and
			    (ambientmatrix[op(1,slideposition)+1,op(2,slideposition)]<>_)) then	

		downvalue:=ambientmatrix[op(1,slideposition)+1,op(2,slideposition)]: 
	  else
		downvalue:=-infinity:
	  fi:


	  if((leftvalue=-infinity) and (downvalue=-infinity)) then
		jdtslidedone:=1:

	  else # now do the slide
		if(downvalue>leftvalue) then
				ambientmatrix[op(1,slideposition),op(2,slideposition)]:=
				      downvalue:
				ambientmatrix[op(1,slideposition)+1,op(2,slideposition)]:=_:
				slideposition:=[op(1,slideposition)+1,op(2,slideposition)]:
		else
				ambientmatrix[op(1,slideposition),op(2,slideposition)]:=
				      leftvalue:
				ambientmatrix[op(1,slideposition),op(2,slideposition)-1]:=_:
				slideposition:=[op(1,slideposition),op(2,slideposition)-1]:
		fi:
	  fi:
	od:
	return(ambientmatrix):
end:

# checks if the two shapes are the same
`testsameshape`:=proc(input1, input2) local ii, jj, flag;
			     
	flag:=1:
	for ii from 1 to 4 do
		for jj from 1 to 8 do
		    if(input1[ii,jj]<>Z and input1[ii,jj]<>_) then
			if(input2[ii,jj]=Z or input2[ii,jj]=_) then
				flag:=0;
			fi:
		    fi:
		od:
	od:
	return(flag);
end: