%%%%%  Simple Type Sizes  %%%%%

stp-size : stp -> nat -> type.

stp-size/t	: stp-size st (s 0).
stp-size/pi	: stp-size (spi S T) M+N
		   <- stp-size S M
		   <- stp-size T N
		   <- sum M N M+N.
stp-size/sigma	: stp-size (ssigma S T) M+N
		   <- stp-size S M
		   <- stp-size T N
		   <- sum M N M+N.



stp-size-fun : stp-size T M -> stp-size T N -> nat-eq M N -> type.
%mode stp-size-fun +X1 +X2 -X3.

-t	: stp-size-fun stp-size/t stp-size/t nat-eq/i.

-pi	: stp-size-fun (stp-size/pi Dsum DsizeT DsizeS) (stp-size/pi Dsum' DsizeT' DsizeS') Deq
	   <- stp-size-fun DsizeS DsizeS' DeqS
	   <- stp-size-fun DsizeT DsizeT' DeqT
	   <- sum-resp DeqS DeqT nat-eq/i Dsum Dsum''
	   <- sum-fun3 Dsum'' Dsum' Deq.

-sigma	: stp-size-fun (stp-size/sigma Dsum DsizeT DsizeS) (stp-size/sigma Dsum' DsizeT' DsizeS') Deq
	   <- stp-size-fun DsizeS DsizeS' DeqS
	   <- stp-size-fun DsizeT DsizeT' DeqT
	   <- sum-resp DeqS DeqT nat-eq/i Dsum Dsum''
	   <- sum-fun3 Dsum'' Dsum' Deq.

%worlds () (stp-size-fun _ _ _).
%total D (stp-size-fun D _ _).



can-stp-size : {T:stp} stp-size T N -> type.
%mode can-stp-size +X1 -X2.

-	: can-stp-size st stp-size/t.

-	: can-stp-size (spi S T) (stp-size/pi Dsum DsizeT DsizeS)
	   <- can-stp-size S DsizeS
	   <- can-stp-size T DsizeT
	   <- can-sum _ _ _ Dsum.

-	: can-stp-size (ssigma S T) (stp-size/sigma Dsum DsizeT DsizeS)
	   <- can-stp-size S DsizeS
	   <- can-stp-size T DsizeT
	   <- can-sum _ _ _ Dsum.

%worlds () (can-stp-size _ _).
%total T (can-stp-size T _).



stp-size-leq : stp-size S Ssz -> stp-size T Tsz -> stp-leq S T -> leq Ssz Tsz -> type.
%mode stp-size-leq +X1 +X2 +X3 -X4.

-eq	: stp-size-leq D1 D2 stp-leq/eq Dleq
	   <- stp-size-fun D1 D2 Deq
	   <- leq-reflex' Deq Dleq.
-pi1	: stp-size-leq DsizeS (stp-size/pi Dsum DsizeT2 DsizeT1) (stp-leq/pi1 Dleqt) Dleq''
	   <- stp-size-leq DsizeS DsizeT1 Dleqt Dleq
	   <- sum-implies-leq Dsum Dleq'
	   <- leq-trans Dleq Dleq' Dleq''.
-pi2	: stp-size-leq DsizeS (stp-size/pi Dsum DsizeT2 DsizeT1) (stp-leq/pi2 Dleqt) Dleq''
	   <- stp-size-leq DsizeS DsizeT2 Dleqt Dleq
	   <- sum-implies-leq' Dsum Dleq'
	   <- leq-trans Dleq Dleq' Dleq''.
-sigma1	: stp-size-leq DsizeS (stp-size/sigma Dsum DsizeT2 DsizeT1) (stp-leq/sigma1 Dleqt) Dleq''
	   <- stp-size-leq DsizeS DsizeT1 Dleqt Dleq
	   <- sum-implies-leq Dsum Dleq'
	   <- leq-trans Dleq Dleq' Dleq''.
-sigma2	: stp-size-leq DsizeS (stp-size/sigma Dsum DsizeT2 DsizeT1) (stp-leq/sigma2 Dleqt) Dleq''
	   <- stp-size-leq DsizeS DsizeT2 Dleqt Dleq
	   <- sum-implies-leq' Dsum Dleq'
	   <- leq-trans Dleq Dleq' Dleq''.

%worlds () (stp-size-leq _ _ _ _).
%total D (stp-size-leq _ _ D _).



stp-size-pos : stp-size T N -> lt 0 N -> type.
%mode stp-size-pos +X1 -X2.

-	: stp-size-pos stp-size/t lt/z.

-	: stp-size-pos (stp-size/pi Dsum _ Dsize) Dlt''
	   <- stp-size-pos Dsize Dlt
	   <- leq-reflex _ Dleq
	   <- sum-lt-leq sum/z Dsum Dlt Dleq Dlt'
	   <- leq-lt-trans leq/z Dlt' Dlt''.

-	: stp-size-pos (stp-size/sigma Dsum _ Dsize) Dlt''
	   <- stp-size-pos Dsize Dlt
	   <- leq-reflex _ Dleq
	   <- sum-lt-leq sum/z Dsum Dlt Dleq Dlt'
	   <- leq-lt-trans leq/z Dlt' Dlt''.

%worlds () (stp-size-pos _ _).
%total D (stp-size-pos D _).




%%%%%  Substitution Permutation (Simply Typed, Explicit Context)  %%%%%

sub-at-tsub : sub ([x] at (R x)) M (at Rx) -> tsub ([x] sing (R x)) M (sing Rx) -> type.
%mode sub-at-tsub +X1 -X2.

-	: sub-at-tsub (sub/aa Dsub) (tsub/singa Dsub).
-	: sub-at-tsub (sub/ao Dsub) (tsub/singo Dsub).

%worlds (var) (sub-at-tsub _ _).
%total {} (sub-at-tsub _ _).



aosub-permute-esm : {Size}
		 stp-size S SizeS
		 -> stp-size T SizeT
		 -> sum SizeS SizeT Size
		 -> ({x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
		 -> ({x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
		 -> ({x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
		 -> ({x} isvar x I -> {y} isvar y J -> ofes (G x y) (N x) T)
		 -> ({x} isvar x I -> {y} isvar y J -> aofes (G x y) (R x y) U)
%%
		 -> ({x} aosub ([y] R x y) (N x) (Oy x))
		 -> sub Oy M Oyx
%%
		 -> ({y} aasub ([x] R x y) M (Rx y))
		 -> sub N M Nx
		 -> aosub Rx Nx Oyx -> type. 
%mode aosub-permute-esm +X1 +X2 +X3 +X4 +X5 +X6 +X7 +X8 +X9 +X10 +X11 -X12 -X13 -X14.

aasub-aosub-permute-esm : {Size}
		       stp-size S SizeS
		       -> stp-size T SizeT
		       -> sum SizeS SizeT Size
		       -> ({x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
		       -> ({x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
		       -> ({x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
		       -> ({x} isvar x I -> {y} isvar y J -> ofes (G x y) (N x) T)
		       -> ({x} isvar x I -> {y} isvar y J -> aofes (G x y) (R x y) U)
%%
		       -> ({x} aasub ([y] R x y) (N x) (Ry x))
		       -> aosub Ry M Oyx
%%
		       -> ({y} aosub ([x] R x y) M (Ox y))
		       -> sub N M Nx
		       -> sub Ox Nx Oyx -> type. 
%mode aasub-aosub-permute-esm +X1 +X2 +X3 +X4 +X5 +X6 +X7 +X8 +X9 +X10 +X11 -X12 -X13 -X14.

aasub-permute-esm : {Size}
		 stp-size S SizeS
		 -> stp-size T SizeT
		 -> sum SizeS SizeT Size
		 -> ({x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
		 -> ({x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
		 -> ({x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
		 -> ({x} isvar x I -> {y} isvar y J -> ofes (G x y) (N x) T)
		 -> ({x} isvar x I -> {y} isvar y J -> aofes (G x y) (R x y) U)
%%
		 -> ({x} aasub ([y] R x y) (N x) (Ry x))
		 -> aasub Ry M Ryx
%%
		 -> ({y} aasub ([x] R x y) M (Rx y))
		 -> sub N M Nx
		 -> aasub ([y] Rx y) Nx Ryx -> type.
%mode aasub-permute-esm +X1 +X2 +X3 +X4 +X5 +X6 +X7 +X8 +X9 +X10 +X11 -X12 -X13 -X14.

sub-permute-esm : {Size}
	       stp-size S SizeS
	       -> stp-size T SizeT
	       -> sum SizeS SizeT Size
	       -> ({x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	       -> ({x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	       -> ({x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	       -> ({x} isvar x I -> {y} isvar y J -> ofes (G x y) (N x) T)
	       -> ({x} isvar x I -> {y} isvar y J -> ofes (G x y) (O x y) U)
%%
	       -> ({x} sub ([y] O x y) (N x) (Oy x))
	       -> sub Oy M Oyx
%%
	       -> ({y} sub ([x] O x y) M (Ox y))
	       -> sub N M Nx
	       -> sub Ox Nx Oyx -> type. 
%mode sub-permute-esm +X1 +X2 +X3 +X4 +X5 +X6 +X7 +X8 +X9 +X10 +X11 -X12 -X13 -X14.

tsub-permute-esm :  {Size}
		   stp-size S SizeS
		   -> stp-size T SizeT
		   -> sum SizeS SizeT Size
		   -> ({x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
		   -> ({x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
		   -> ({x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
		   -> ({x} isvar x I -> {y} isvar y J -> ofes (G x y) (N x) T)
		   -> ({x} isvar x I -> {y} isvar y J -> wfes (G x y) (A x y))
%%
		   -> ({x} tsub ([y] A x y) (N x) (Ay x))
		   -> tsub ([x] Ay x) M Ayx
%%
		   -> ({y} tsub ([x] A x y) M (Ax y))
		   -> sub ([x] N x) M Nx
		   -> tsub ([y] Ax y) Nx Ayx -> type.
%mode tsub-permute-esm +X1 +X2 +X3 +X4 +X5 +X6 +X7 +X8 +X9 +X10 +X11 -X12 -X13 -X14.

-var	: aosub-permute-esm _ _ _ _ _ _ _ _ _
	   ([x] aosub/var) (Dsub : sub ([x] N x) M O)
	   ([y] aasub/closed) Dsub aosub/var.

-app	: aosub-permute-esm _ (DsizeS : stp-size S SizeS) (DsizeT : stp-size T SizeT) (Dsum : sum SizeS SizeT Size)
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofN : {x} isvar x I -> {y} isvar y J -> ofes (G x y) (N x) T)
	   (DofApp : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (app (R x y) (O x y)) U2)
%%
	   ([x] aosub/app
	      (DsubPz x : sub ([z] P x z) (Oy x) (Pz x))
	      (DsubOy x : sub ([y] O x y) (N x) (Oy x))
	      (Daosub x : aosub ([y] R x y) (N x) (lam ([z] P x z)))
	      : aosub ([y] app (R x y) (O x y)) (N x) (Pz x))
	   (DsubPzx : sub ([x] Pz x) M Pzx)
%%
	   ([y] aasub/app (DsubOx y) (DsubRx y)
	      : aasub ([x] app (R x y) (O x y)) M (app (Rx y) (Ox y)))
	   DsubNx
	   (aosub/app (DsubPxz aca) DsubOxy DsubLam'
	      : aosub ([y] app (Rx y) (Ox y)) Nx Pzx)
	   %% first get some typing derivations
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J} 
		 aofes-invert-app (DofApp x d y e)
		    (DofR x d y e : aofes (G x y) (R x y) (spi U1 U2))
		    (DofO x d y e : ofes (G x y) (O x y) U1))
	   <- ({x} {d:isvar x I}
		 subst-es ([y] [e] DlookupY x d y e) ([y] [e] DofN x d y e) ([y] [e] DofO x d y e) (DsubOy x)
		    (DofOy x d : {y} isvar y J -> ofes (G x y) (Oy x) U1))
	   <- ({x} {d:isvar x I}
		 aosubst-es ([y] [e] DlookupY x d y e) ([y] [e] DofN x d y e) ([y] [e] DofR x d y e) (Daosub x)
		    ([y] [e]
		       (ofes/lam 
			  (DofP x d y e : {z} isvar z K -> ofes (scons (G x y) z U1) (P x z) U2))
		       : ofes (G x y) (lam ([z] P x z)) (spi U1 U2)))
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J} 
		 {z} {f:isvar z K}
		 ofes-context (DofP x d y e z f) 
		    (sordered/cons
		       (Dbounded x d y e z f : sbounded (G x y) z)
		       : sordered (scons (G x y) z U1)))
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J} 
		 {z} {f:isvar z K}
		 weaken-ofes (Dbounded x d y e z f) (DofM x d y e) _ 
		    (DofM' x d y e z f : ofes (scons (G x y) z U1) M S))
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J} 
		 {z} {f:isvar z K}
		 weaken-ofes (Dbounded x d y e z f) (DofOy x d y e) _ 
		    (DofOy' x d y e z f : ofes (scons (G x y) z U1) (Oy x) U1))
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J} 
		 {z} {f:isvar z K}
		 weaken-slookup (Dbounded x d y e z f) (DlookupX x d y e) _
		    (DlookupX' x d y e z f : slookup (scons (G x y) z U1) x S))
	   %% show that our metric is reduced
	   <- can-stp-size U1 (DsizeU1 : stp-size U1 SizeU1)
	   <- can-stp-size U2 (DsizeU2 : stp-size U2 SizeU2)
	   <- can-sum SizeU1 SizeU2 SizeU1->U2 
	      (DsumU1+U2 : sum SizeU1 SizeU2 SizeU1->U2)
	   <- can-sum SizeS SizeU1 SizeS+U1 
	      (DsumS+U1 : sum SizeS SizeU1 SizeS+U1)
	   <- ({x} aosub-headvar (Daosub x) (Dheadvar x : headvar ([y] R x y)))
	   <- ({x} {d:isvar x I}
		 headvar-stp-size ([y] [e] DlookupY x d y e) ([y] [e] DofR x d y e) (Dheadvar x)
		    (Dleqt : stp-leq (spi U1 U2) T))
	   <- stp-size-leq (stp-size/pi DsumU1+U2 DsizeU2 DsizeU1) DsizeT Dleqt 
	      (Dleq : leq SizeU1->U2 SizeT)
	   <- stp-size-pos DsizeU2 
	      (DltU2 : lt 0 SizeU2)
	   <- sum-implies-lt DsumU1+U2 DltU2 
	      (DltU1 : lt SizeU1 SizeU1->U2)
	   <- lt-leq-trans DltU1 Dleq 
	      (DltU1T : lt SizeU1 SizeT)
	   <- leq-reflex SizeS 
	      (DleqS : leq SizeS SizeS)
	   <- sum-leq-lt DsumS+U1 Dsum DleqS DltU1T (Dlt : lt SizeS+U1 Size)
	   <- lt-subterm SizeS+U1 Size Dlt
	   %% now get to work
	   <- ({y} {e:isvar y J}
		 sub-permute-esm SizeS+U1 DsizeS DsizeU1 DsumS+U1
		    ([x] [d] [z] [f] DlookupX' x d y e z f) ([x] [d] [z] [f] slookup/hit (Dbounded x d y e z f)) ([x] [d] [z] [f] DofM' x d y e z f) ([x] [d] [z] [f] DofOy' x d y e z f) ([x] [d:isvar x I] [z] [f:isvar z K] DofP x d y e z f)
		    DsubPz DsubPzx
		    %% extraneous dependencies on y
		    (DsubPx_y y : {z} sub ([x] P x z) M (Px_y y z))
		    (DsubOyx_y y : sub Oy M (Oyx_y y))
		    (DsubPxz_y y  : sub ([z] Px_y y z) (Oyx_y y) Pzx))
	   %% clean up extraneous dependencies
	   <- ({z} 
		 sub-closed ([y] DsubPx_y y z) ([y] DeqPx_y y z : term-eq (Px_y y z) (Px z)))
	   <- sub-closed DsubOyx_y ([y] DeqOyx_y y : term-eq (Oyx_y y) Oyx)
	   <- ({y} {z}
		 sub-resp ([_] term-eq/i) term-eq/i (DeqPx_y y z) (DsubPx_y y z) (DsubPx y z : sub ([x] P x z) M (Px z)))
	   <- ({y}
		 sub-resp ([_] term-eq/i) term-eq/i (DeqOyx_y y) (DsubOyx_y y) (DsubOyx y : sub Oy M Oyx))
	   <- ({y}
		 sub-resp ([z] DeqPx_y y z) (DeqOyx_y y) term-eq/i (DsubPxz_y y) (DsubPxz y : sub ([z] Px z) Oyx Pzx))
	   %% ok, proceed
	   <- sub-permute-esm  _ DsizeS DsizeT Dsum
	      DlookupX DlookupY DofM DofN DofO
	      DsubOy (DsubOyx aca)
	      (DsubOx : {y} sub ([x] O x y) M (Ox y))
	      (DsubNx : sub N M Nx)
	      (DsubOxy : sub Ox Nx Oyx)
	   <- aosub-permute-esm  _ DsizeS DsizeT Dsum
	      DlookupX DlookupY DofM DofN DofR
	      Daosub (sub/lam (DsubPx aca) : sub ([x] lam ([z] P x z)) M (lam ([z] Px z)))
	      (DsubRx : {y} aasub ([x] R x y) M (Rx y))
	      (DsubNx' : sub N M Nx')
	      (DsubLam : aosub ([y] Rx y) Nx' (lam ([z] Px z)))
	   <- sub-fun DsubNx' DsubNx (Deq : term-eq Nx' Nx)
	   <- aosub-resp ([_] atom-eq/i) Deq term-eq/i DsubLam (DsubLam' : aosub ([y] Rx y) Nx (lam ([z] Px z))).

-pi1	: aosub-permute-esm _ DsizeS DsizeT Dsum
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofN : {x} isvar x I -> {y} isvar y J -> ofes (G x y) (N x) T)
	   (DofPi : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (pi1 (R x y)) U1)
%%
	   ([x] aosub/pi1 
	      (Daosub x : aosub ([y] R x y) (N x) (pair (P1 x) (P2 x)))
	      : aosub ([y] pi1 (R x y)) (N x) (P1 x))
	   (DsubP1x : sub ([x] P1 x) M P1x)
%%
	   ([y] aasub/pi1 (DsubRx y)
	      : aasub ([x] pi1 (R x y)) M (pi1 (Rx y)))
	   DsubNx
	   (aosub/pi1 DsubPair
	      : aosub ([y] pi1 (Rx y)) Nx P1x)
	   %% first get some typing derivations
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J} 
		 aofes-invert-pi1 (DofPi x d y e)
		    (DofR x d y e : aofes (G x y) (R x y) (ssigma U1 U2)))
	   <- ({x} {d:isvar x I}
		 aosubst-es ([y] [e] DlookupY x d y e) ([y] [e] DofN x d y e) ([y] [e] DofR x d y e) (Daosub x)
		    ([y] [e] ofes/pair
		       (DofP2 x d y e : ofes (G x y) (P2 x) U2)
		       (DofP1 x d y e : ofes (G x y) (P1 x) U1)))
	   %% now get to work
	   <- ({y} {e:isvar y J}
		 can-sub-es ([x] [d] DlookupX x d y e) ([x] [d] DofP2 x d y e) ([x] [d] DofM x d y e)
		    %% extraneous dependency on y
		    (DsubP2x_y y : sub ([x] P2 x) M (P2x_y y)))
	   %% clean up extraneous dependency
	   <- sub-closed DsubP2x_y ([y] DeqP2x_y y : term-eq (P2x_y y) P2x)
	   <- ({y}
		 sub-resp ([_] term-eq/i) term-eq/i (DeqP2x_y y) (DsubP2x_y y) (DsubP2x y : sub ([x] P2 x) M P2x))
	   %% ok, proceed
	   <- aosub-permute-esm _ DsizeS DsizeT Dsum
	      DlookupX DlookupY DofM DofN DofR
	      Daosub
	      (sub/pair (DsubP2x aca) DsubP1x
		 : sub ([x] pair (P1 x) (P2 x)) M (pair P1x P2x))
	      (DsubRx : {y} aasub ([x] R x y) M (Rx y))
	      (DsubNx : sub ([x] N x) M Nx)
	      (DsubPair : aosub ([y] Rx y) Nx (pair P1x P2x)).

-pi2	: aosub-permute-esm _ DsizeS DsizeT Dsum
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofN : {x} isvar x I -> {y} isvar y J -> ofes (G x y) (N x) T)
	   (DofPi : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (pi2 (R x y)) U2)
%%
	   ([x] aosub/pi2
	      (Daosub x : aosub ([y] R x y) (N x) (pair (P1 x) (P2 x)))
	      : aosub ([y] pi2 (R x y)) (N x) (P2 x))
	   (DsubP2x : sub ([x] P2 x) M P2x)
%%
	   ([y] aasub/pi2 (DsubRx y)
	      : aasub ([x] pi2 (R x y)) M (pi2 (Rx y)))
	   DsubNx
	   (aosub/pi2 DsubPair
	      : aosub ([y] pi2 (Rx y)) Nx P2x)
	   %% first get some typing derivations
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J} 
		 aofes-invert-pi2 (DofPi x d y e)
		    (DofR x d y e : aofes (G x y) (R x y) (ssigma U1 U2)))
	   <- ({x} {d:isvar x I}
		 aosubst-es ([y] [e] DlookupY x d y e) ([y] [e] DofN x d y e) ([y] [e] DofR x d y e) (Daosub x)
		    ([y] [e] ofes/pair
		       (DofP2 x d y e : ofes (G x y) (P2 x) U2)
		       (DofP1 x d y e : ofes (G x y) (P1 x) U1)))
	   %% now get to work
	   <- ({y} {e:isvar y J}
		 can-sub-es ([x] [d] DlookupX x d y e) ([x] [d] DofP1 x d y e) ([x] [d] DofM x d y e)
		    %% extraneous dependency on y
		    (DsubP1x_y y : sub ([x] P1 x) M (P1x_y y)))
	   %% clean up extraneous dependency
	   <- sub-closed DsubP1x_y ([y] DeqP1x_y y : term-eq (P1x_y y) P1x)
	   <- ({y}
		 sub-resp ([_] term-eq/i) term-eq/i (DeqP1x_y y) (DsubP1x_y y) (DsubP1x y : sub ([x] P1 x) M P1x))
	   %% ok, proceed
	   <- aosub-permute-esm _ DsizeS DsizeT Dsum
	      DlookupX DlookupY DofM DofN DofR
	      Daosub
	      (sub/pair DsubP2x (DsubP1x aca)
		 : sub ([x] pair (P1 x) (P2 x)) M (pair P1x P2x))
	      (DsubRx : {y} aasub ([x] R x y) M (Rx y))
	      (DsubNx : sub ([x] N x) M Nx)
	      (DsubPair : aosub ([y] Rx y) Nx (pair P1x P2x)).

-closed	: aasub-aosub-permute-esm _ _ _ _
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   _
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofN : {x} isvar x I -> {y} isvar y J -> ofes (G x y) (N x) T)
	   _
%%
	   ([x] aasub/closed)
	   (Daosub : aosub R M O)
%%
	   ([y] Daosub)
	   DsubNx
	   Dsub
	   <- ({y} {e:isvar y J}
		 can-sub-es ([x] [d] DlookupX x d y e) ([x] [d] DofN x d y e) ([x] [d] DofM x d y e)
		    (DsubNx_y y : sub N M (Nx_y y)))
	   <- sub-closed' DsubNx_y (DsubNx : sub N M Nx)
	   <- sub-absent O Nx (Dsub : sub ([_] O) Nx O).


ofes-spi-invert : ({x} isvar x I -> {y} isvar y J -> ofes (G x y) (M y) (spi U1 U2))
		   -> ({y} term-eq (M y) (lam ([z] M' y z))) -> type.
%mode ofes-spi-invert +X1 -X2.

-	: ofes-spi-invert ([x] [d] [y] [e] ofes/lam ([z] [f:isvar z K] D x d y e z f)) ([y] term-eq/i).

%worlds (var | ovar | bind) (ofes-spi-invert _ _).
%total {} (ofes-spi-invert _ _).


-app	: aasub-aosub-permute-esm _ (DsizeS : stp-size S SizeS) (DsizeT : stp-size T SizeT) (Dsum : sum SizeS SizeT Size)
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofN : {x} isvar x I -> {y} isvar y J -> ofes (G x y) (N x) T)
	   (DofApp : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (app (R x y) (O x y)) U2)
%%
	   ([x] aasub/app
	      (DsubOy x : sub ([y] O x y) (N x) (Oy x))
	      (DsubRy x : aasub ([y] R x y) (N x) (Ry x)))
	   (aosub/app
	      (DsubPz : sub P Oyx Pz)
	      (DsubOyx : sub Oy M Oyx)
	      (Daosub : aosub Ry M (lam ([z] P z))))
%%
	   ([y] aosub/app
	      (DsubQz y)
	      (DsubOx y)
	      (Daosub'' y))
	   DsubNx
	   DsubQzy'
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J} 
		 aofes-invert-app (DofApp x d y e)
		    (DofR x d y e : aofes (G x y) (R x y) (spi U1 U2))
		    (DofO x d y e : ofes (G x y) (O x y) U1))
	   <- aasub-aosub-permute-esm _ DsizeS DsizeT Dsum
	      DlookupX DlookupY DofM DofN DofR
	      DsubRy Daosub
	      (Daosub' : {y} aosub ([x] R x y) M (Ql y))
	      (DsubNx : sub N M Nx)
	      (DsubQly : sub ([y] Ql y) Nx (lam ([z] P z)))
	   <- ({y} {e:isvar y J}
		 subst-es ([x] [d] DlookupX x d y e) ([x] [d] DofM x d y e) ([x] [d] DofN x d y e) DsubNx 
		    ([x] [d:isvar x I] DofNx x d y e : ofes (G x y) Nx T))
	   <- ({y} {e:isvar y J}
		 aosubst-es ([x] [d] DlookupX x d y e) ([x] [d] DofM x d y e) ([x] [d] DofR x d y e) (Daosub' y) 
		    ([x] [d:isvar x I] DofQl x d y e : ofes (G x y) (Ql y) (spi U1 U2)))
	   <- ofes-spi-invert DofQl (DeqQl : {y} term-eq (Ql y) (lam ([z] Q y z)))
	   <- sub-resp DeqQl term-eq/i term-eq/i DsubQly
	      (sub/lam
		 (DsubQy : {z} sub ([y] Q y z) Nx (P z))
		 : sub ([y] (lam ([z] Q y z))) Nx (lam ([z] P z)))
	   <- ({y} aosub-resp ([_] atom-eq/i) term-eq/i (DeqQl y) (Daosub' y)
		 (Daosub'' y : aosub ([x] R x y) M (lam ([z] Q y z))))
	   <- sub-permute-esm _ DsizeS DsizeT Dsum
	      DlookupX DlookupY DofM DofN DofO
	      DsubOy DsubOyx
	      (DsubOx : {y} sub ([x] O x y) M (Ox y))
	      (DsubNx' : sub N M Nx')
	      (DsubOxy : sub ([y] Ox y) Nx' Oyx)
	   <- sub-fun DsubNx' DsubNx (DeqNx : term-eq Nx' Nx)
	   <- sub-resp ([_] term-eq/i) DeqNx term-eq/i DsubOxy
	      (DsubOxy' : sub ([y] Ox y) Nx Oyx)
	   %% get a bunch of typing derivations in order
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J}
		 ofes-resp sctx-eq/i (DeqQl y) stp-eq/i (DofQl x d y e) 
		    (ofes/lam
		       ([z] [f:isvar z K]
			  (DofQ x d y e z f : ofes (scons (G x y) z U1) (Q y z) U2))))
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 {z} {f:isvar z K}
		 ofes-context (DofQ x d y e z f) 
		    (sordered/cons 
		       (Dbounded x d y e z f : sbounded (G x y) z)))
	   <- ({y} {e:isvar y J} 
		 subst-es ([x] [d] DlookupX x d y e) ([x] [d] DofM x d y e) ([x] [d] DofO x d y e) (DsubOx y)
		    ([x] [d] DofOx x d y e : ofes (G x y) (Ox y) U1))
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 {z} {f:isvar z K}
		 weaken-ofes (Dbounded x d y e z f) (DofOx x d y e) _ 
		    (DofOx' x d y e z f : ofes (scons (G x y) z U1) (Ox y) U1))
	   %% now we can show [Ox/z]Q exists (where Ox = [M/x]O)
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J} 
		 can-sub-es ([z] [f:isvar z K] slookup/hit (Dbounded x d y e z f)) ([z] [f] DofQ x d y e z f) ([z] [f] DofOx' x d y e z f)
		    (DsubQz_x x y : sub ([z] Q y z) (Ox y) (Qz_x x y)))
	   <- ({y} sub-closed' ([x] DsubQz_x x y) (DsubQz y : sub ([z] Q y z) (Ox y) (Qz y)))
	   %% get more typing derivations
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J} 
		 subst-es ([z] [f:isvar z K] slookup/hit (Dbounded x d y e z f)) ([z] [f] DofOx' x d y e z f) ([z] [f] DofQ x d y e z f) (DsubQz y)
		    ([z] [f:isvar z K] DofQz x d y e z f : ofes (scons (G x y) z U1) (Qz y) U2))
	   %% we've accreted another variable, so do some weakening
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J} 
		 {z} {f:isvar z K} 
		 weaken-slookup (Dbounded x d y e z f) (DlookupY x d y e) _
		    (DlookupY' x d y e z f : slookup (scons (G x y) z U1) y T))
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 {z} {f:isvar z K}
		 weaken-ofes (Dbounded x d y e z f) (DofNx x d y e) _ (DofNx' x d y e z f : ofes (scons (G x y) z U1) Nx T))
	   %% now we can show [Nx/y][Ox/z]Q exists (where Nx = [M/x]N)
	   <- ({x} {d:isvar x I}
		 {z} {f:isvar z K} 
		 can-sub-es ([y] [e] DlookupY' x d y e z f) ([y] [e] DofQz x d y e z f) ([y] [e:isvar y J] DofNx' x d y e z f) 
		    (DsubQzy_xz x z : sub ([y] Qz y) Nx (Qzy_xz x z)))
	   <- ({z} sub-closed' ([x] DsubQzy_xz x z) (DsubQzy_z z : sub ([y] Qz y) Nx (Qzy_z z)))
	   <- sub-closed' DsubQzy_z (DsubQzy : sub ([y] Qz y) Nx Qzy)
	   %% show that our metric is reduced
	   <- can-stp-size U1 (DsizeU1 : stp-size U1 SizeU1)
	   <- can-stp-size U2 (DsizeU2 : stp-size U2 SizeU2)
	   <- can-sum SizeU1 SizeU2 SizeU1->U2 
	      (DsumU1+U2 : sum SizeU1 SizeU2 SizeU1->U2)
	   <- can-sum SizeT SizeU1 SizeT+U1
	      (DsumT+U1 : sum SizeT SizeU1 SizeT+U1)
	   <- ({y} aosub-headvar (Daosub' y) (Dheadvar y : headvar ([x] R x y)))
	   <- ({y} {e:isvar y J}
		 headvar-stp-size ([x] [d] DlookupX x d y e) ([x] [d] DofR x d y e) (Dheadvar y)
		    (Dleqt : stp-leq (spi U1 U2) S))
	   <- stp-size-leq (stp-size/pi DsumU1+U2 DsizeU2 DsizeU1) DsizeS Dleqt
	      (Dleq : leq SizeU1->U2 SizeS)
	   <- stp-size-pos DsizeU2
	      (DltU2 : lt 0 SizeU2)
	   <- sum-implies-lt DsumU1+U2 DltU2
	      (DltU1 : lt SizeU1 SizeU1->U2)
	   <- lt-leq-trans DltU1 Dleq
	      (DltU1S : lt SizeU1 SizeS)
	   <- leq-reflex SizeT
	      (DleqT : leq SizeT SizeT)
	   <- sum-commute Dsum (Dsum' : sum SizeT SizeS Size)
	   <- sum-leq-lt DsumT+U1 Dsum' DleqT DltU1S (Dlt : lt SizeT+U1 Size)
	   <- lt-subterm SizeT+U1 Size Dlt
	   %% now permute the [Nx/y] with the [Ox/z]
	   <- ({x} {d:isvar x I}
		 sub-permute-esm SizeT+U1 DsizeT DsizeU1 DsumT+U1
		    ([y] [e] [z] [f] DlookupY' x d y e z f) ([y] [e] [z] [f] slookup/hit (Dbounded x d y e z f)) ([y] [e] [z] [f] DofNx' x d y e z f) ([y] [e] [z] [f] DofOx' x d y e z f) ([y] [e] [z] [f] DofQ x d y e z f)
		    DsubQz DsubQzy
		    (DsubQy'_x x : {z} sub ([y] Q y z) Nx (Qy_x x z))
		    (DsubOxy''_x x : sub ([y] Ox y) Nx (Oxy_x x))
		    (DsubQyz_x x : sub ([z] Qy_x x z) (Oxy_x x) Qzy))
	   %% remove extraneous x variable from the above
	   <- ({z} sub-closed ([x] DsubQy'_x x z) ([x] DeqQy_x x z : term-eq (Qy_x x z) (Qy z)))
	   <- sub-closed DsubOxy''_x (DeqOxy_x : {x} term-eq (Oxy_x x) Oxy)
	   <- ({z} sub-resp-strengthen ([_] [_] term-eq/i) ([_] term-eq/i) ([x] DeqQy_x x z) ([x] DsubQy'_x x z)
		 (DsubQy' z : sub ([y] Q y z) Nx (Qy z)))
	   <- sub-resp-strengthen ([_] [_] term-eq/i) ([_] term-eq/i) DeqOxy_x DsubOxy''_x
	      (DsubOxy'' : sub ([y] Ox y) Nx Oxy)
	   <- sub-resp-strengthen ([x] [z] DeqQy_x x z) DeqOxy_x ([_] term-eq/i) DsubQyz_x
	      (DsubQyz : sub ([z] Qy z) Oxy Qzy)
	   %% finish up
	   <- ({z} sub-fun (DsubQy' z) (DsubQy z) (DeqQy z : term-eq (Qy z) (P z)))
	   <- sub-fun DsubOxy'' DsubOxy' (DeqOxy : term-eq Oxy Oyx)
	   <- sub-resp DeqQy DeqOxy term-eq/i DsubQyz
	      (DsubPz' : sub ([z] P z) Oyx Qzy)
	   <- sub-fun DsubPz' DsubPz (DeqQzy : term-eq Qzy Pz)
	   <- sub-resp ([_] term-eq/i) term-eq/i DeqQzy DsubQzy
	      (DsubQzy' : sub ([y] Qz y) Nx Pz).


ofes-ssigma-invert :  ({x} isvar x I -> {y} isvar y J -> ofes (G x y) (M y) (ssigma U1 U2))
		      -> ({y} term-eq (M y) (pair (M1 y) (M2 y))) -> type.
%mode ofes-ssigma-invert +X1 -X2.

-	: ofes-ssigma-invert ([x] [d] [y] [e] ofes/pair (D2 x d y e) (D1 x d y e)) ([y] term-eq/i).

%worlds (var | ovar | bind) (ofes-ssigma-invert _ _).
%total {} (ofes-ssigma-invert _ _).


-pi1	: aasub-aosub-permute-esm _ DsizeS DsizeT Dsum
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofN : {x} isvar x I -> {y} isvar y J -> ofes (G x y) (N x) T)
	   (DofPi : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (pi1 (R x y)) U1)
%%
	   ([x] aasub/pi1
	      (DsubRy x : aasub ([y] R x y) (N x) (Ry x)))
	   (aosub/pi1
	      (Daosub : aosub ([x] Ry x) M (pair O1 O2)))
%%
	   ([y] aosub/pi1 (Daosub'' y))
	   DsubNx
	   DsubQ1y
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 aofes-invert-pi1 (DofPi x d y e)
		    (DofR x d y e : aofes (G x y) (R x y) (ssigma U1 U2)))
	   <- aasub-aosub-permute-esm  _ DsizeS DsizeT Dsum
	      DlookupX DlookupY DofM DofN DofR
	      DsubRy Daosub
	      (Daosub' : {y} aosub ([x] R x y) M (Qp y))
	      (DsubNx : sub N M Nx)
	      (DsubQpy : sub ([y] Qp y) Nx (pair O1 O2))
	   <- ({y} {e:isvar y J}
		 aosubst-es ([x] [d] DlookupX x d y e) ([x] [d] DofM x d y e) ([x] [d] DofR x d y e) (Daosub' y)
		    ([x] [d:isvar x I] DofQp x d y e : ofes (G x y) (Qp y) (ssigma U1 U2)))
	   <- ofes-ssigma-invert DofQp 
	      (DeqQp : {y} term-eq (Qp y) (pair (Q1 y) (Q2 y)))
	   <- sub-resp DeqQp term-eq/i term-eq/i DsubQpy
	      (sub/pair
		 (DsubQ2y : sub Q2 Nx O2)
		 (DsubQ1y : sub Q1 Nx O1)
		 : sub ([y] pair (Q1 y) (Q2 y)) Nx (pair O1 O2))
	   <- ({y} aosub-resp ([_] atom-eq/i) term-eq/i (DeqQp y) (Daosub' y)
		 (Daosub'' y : aosub ([x] R x y) M (pair (Q1 y) (Q2 y)))).

-pi2	: aasub-aosub-permute-esm _ DsizeS DsizeT Dsum
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofN : {x} isvar x I -> {y} isvar y J -> ofes (G x y) (N x) T)
	   (DofPi : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (pi2 (R x y)) U2)
%%
	   ([x] aasub/pi2
	      (DsubRy x : aasub ([y] R x y) (N x) (Ry x)))
	   (aosub/pi2
	      (Daosub : aosub ([x] Ry x) M (pair O1 O2)))
%%
	   ([y] aosub/pi2 (Daosub'' y))
	   DsubNx
	   DsubQ2y
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 aofes-invert-pi2 (DofPi x d y e)
		    (DofR x d y e : aofes (G x y) (R x y) (ssigma U1 U2)))
	   <- aasub-aosub-permute-esm  _ DsizeS DsizeT Dsum
	      DlookupX DlookupY DofM DofN DofR
	      DsubRy Daosub
	      (Daosub' : {y} aosub ([x] R x y) M (Qp y))
	      (DsubNx : sub N M Nx)
	      (DsubQpy : sub ([y] Qp y) Nx (pair O1 O2))
	   <- ({y} {e:isvar y J}
		 aosubst-es ([x] [d] DlookupX x d y e) ([x] [d] DofM x d y e) ([x] [d] DofR x d y e) (Daosub' y)
		    ([x] [d:isvar x I] DofQp x d y e : ofes (G x y) (Qp y) (ssigma U1 U2)))
	   <- ofes-ssigma-invert DofQp 
	      (DeqQp : {y} term-eq (Qp y) (pair (Q1 y) (Q2 y)))
	   <- sub-resp DeqQp term-eq/i term-eq/i DsubQpy
	      (sub/pair
		 (DsubQ2y : sub Q2 Nx O2)
		 (DsubQ1y : sub Q1 Nx O1)
		 : sub ([y] pair (Q1 y) (Q2 y)) Nx (pair O1 O2))
	   <- ({y} aosub-resp ([_] atom-eq/i) term-eq/i (DeqQp y) (Daosub' y)
		 (Daosub'' y : aosub ([x] R x y) M (pair (Q1 y) (Q2 y)))).

at-o	: sub-permute-esm _ DsizeS DsizeT Dsum
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofN : {x} isvar x I -> {y} isvar y J -> ofes (G x y) (N x) T)
	   ([x] [d:isvar x I] [y] [e:isvar y J]
	      ofes/at
	      (DofR x d y e : aofes (G x y) (R x y) st))
%%
	   ([x] sub/ao
	      (DsubOy x : aosub ([y] R x y) (N x) (Oy x))
	      : sub ([y] at (R x y)) (N x) (Oy x))
	   (DsubOyx : sub ([x] Oy x) M Oyx)
%%
	   ([y] sub/aa (DsubRx y) : sub ([x] at (R x y)) M (at (Rx y)))
	   DsubNx
	   (sub/ao DsubOxy : sub ([y] at (Rx y)) Nx Oyx)
	   <- aosub-permute-esm _ DsizeS DsizeT Dsum
	      DlookupX DlookupY DofM DofN DofR
	      DsubOy DsubOyx
	      (DsubRx : {y} aasub ([x] R x y) M (Rx y))
	      (DsubNx : sub ([x] N x) M Nx)
	      (DsubOxy : aosub ([y] Rx y) Nx Oyx).

at-ao	: sub-permute-esm _ DsizeS DsizeT Dsum
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofN : {x} isvar x I -> {y} isvar y J -> ofes (G x y) (N x) T)
	   ([x] [d:isvar x I] [y] [e:isvar y J]
	      ofes/at
	      (DofR x d y e : aofes (G x y) (R x y) st))
%%
	   ([x] sub/aa
	      (DsubRy x : aasub ([y] R x y) (N x) (Ry x))
	      : sub ([y] at (R x y)) (N x) (at (Ry x)))
	   (sub/ao
	      (DsubOyx : aosub ([x] Ry x) M Oyx)
	      : sub ([x] at (Ry x)) M Oyx)
%%
	   ([y] sub/ao (DsubOx y)) DsubNx DsubOxy
	   <- aasub-aosub-permute-esm _ DsizeS DsizeT Dsum
	      DlookupX DlookupY DofM DofN DofR
	      DsubRy DsubOyx
	      (DsubOx : {y} aosub ([x] R x y) M (Ox y))
	      (DsubNx : sub N M Nx)
	      (DsubOxy : sub ([y] Ox y) Nx Oyx).

at-a	: sub-permute-esm _ DsizeS DsizeT Dsum
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofN : {x} isvar x I -> {y} isvar y J -> ofes (G x y) (N x) T)
	   ([x] [d:isvar x I] [y] [e:isvar y J]
	      ofes/at
	      (DofR x d y e : aofes (G x y) (R x y) st))
%%
	   ([x] sub/aa
	      (DsubRy x : aasub ([y] R x y) (N x) (Ry x))
	      : sub ([y] at (R x y)) (N x) (at (Ry x)))
	   (sub/aa
	      (DsubRyx : aasub ([x] Ry x) M Ryx)
	      : sub ([x] at (Ry x)) M (at Ryx))
%%
	   ([y] sub/aa (DsubRx y)) DsubNx (sub/aa DsubRxy)
	   <- aasub-permute-esm _ DsizeS DsizeT Dsum
	      DlookupX DlookupY DofM DofN DofR
	      DsubRy DsubRyx
	      (DsubRx : {y} aasub ([x] R x y) M (Rx y))
	      (DsubNx : sub N M Nx)
	      (DsubRxy : aasub ([y] Rx y) Nx Ryx).

-lam	: sub-permute-esm _ DsizeS DsizeT Dsum
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofN : {x} isvar x I -> {y} isvar y J -> ofes (G x y) (N x) T)
	   ([x] [d:isvar x I] [y] [e:isvar y J]
	      ofes/lam
	      (DofO x d y e : {z} isvar z K -> ofes (scons (G x y) z U1) (O x y z) U2)
	      : ofes (G x y) (lam ([z] O x y z)) (spi U1 U2))
%%
	   ([x] sub/lam 
	      (DsubOy x : {z} sub ([y] O x y z) (N x) (Oy x z))
	      : sub ([y] lam ([z] O x y z)) (N x) (lam ([z] Oy x z)))
	   (sub/lam
	      (DsubOyx : {z} sub ([x] Oy x z) M (Oyx z))
	      : sub ([x] lam ([z] Oy x z)) M (lam ([z] Oyx z)))
%%
	   ([y] sub/lam ([z] DsubOx z y))
	   DsubNx
	   (sub/lam ([z] DsubOxy' z))
	   %% first get some typing derivations
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J}
		 {z} {f:isvar z K}
		 ofes-context (DofO x d y e z f)
		    (sordered/cons
		       (Dbounded x d y e z f : sbounded (G x y) z)
		       : sordered (scons (G x y) z U1)))
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J}
		 {z} {f:isvar z K}
		 weaken-ofes (Dbounded x d y e z f) (DofM x d y e) _ 
		    (DofM' x d y e z f : ofes (scons (G x y) z U1) M S))
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J}
		 {z} {f:isvar z K}
		 weaken-ofes (Dbounded x d y e z f) (DofN x d y e) _ 
		    (DofN' x d y e z f : ofes (scons (G x y) z U1) (N x) T))
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J}
		 {z} {f:isvar z K}
		 weaken-slookup (Dbounded x d y e z f) (DlookupX x d y e) _
		    (DlookupX' x d y e z f : slookup (scons (G x y) z U1) x S))
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J}
		 {z} {f:isvar z K}
		 weaken-slookup (Dbounded x d y e z f) (DlookupY x d y e) _
		    (DlookupY' x d y e z f : slookup (scons (G x y) z U1) y T))
	   %% now get to work
	   <- ({z} {f:isvar z K}
		 sub-permute-esm _ DsizeS DsizeT Dsum
		    ([x] [d] [y] [e] DlookupX' x d y e z f) ([x] [d] [y] [e] DlookupY' x d y e z f) ([x] [d] [y] [e] DofM' x d y e z f) ([x] [d] [y] [e] DofN' x d y e z f) ([x] [d] [y] [e] DofO x d y e z f)
		    ([x] DsubOy x z) (DsubOyx z)
		    (DsubOx z : {y} sub ([x] O x y z) M (Ox y z))
		    (DsubNx_z z : sub N M (Nx_z z))
		    (DsubOxy z : sub ([y] Ox y z) (Nx_z z) (Oyx z)))
	   <- sub-closed DsubNx_z (DeqNx_z : {z} term-eq (Nx_z z) Nx)
	   <- sub-resp-strengthen ([_] [_] term-eq/i) ([_] term-eq/i) DeqNx_z DsubNx_z
	      (DsubNx : sub N M Nx)
	   <- ({z} sub-resp ([_] term-eq/i) (DeqNx_z z) term-eq/i (DsubOxy z) (DsubOxy' z)).

-pair	: sub-permute-esm _ DsizeS DsizeT Dsum
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofN : {x} isvar x I -> {y} isvar y J -> ofes (G x y) (N x) T)
	   ([x] [d:isvar x I] [y] [e:isvar y J]
	      ofes/pair
	      (DofO2 x d y e : ofes (G x y) (O2 x y) U2)
	      (DofO1 x d y e : ofes (G x y) (O1 x y) U1))
%%
	   ([x] sub/pair 
	      (DsubO2y x : sub ([y] O2 x y) (N x) (O2y x))
	      (DsubO1y x : sub ([y] O1 x y) (N x) (O1y x)))
	   (sub/pair
	      (DsubO2yx : sub ([x] O2y x) M O2yx)
	      (DsubO1yx : sub ([x] O1y x) M O1yx))
%%
	   ([y] sub/pair (DsubO2x y) (DsubO1x y)) DsubNx (sub/pair DsubO2xy' DsubO1xy)
	   <- sub-permute-esm _ DsizeS DsizeT Dsum
	      DlookupX DlookupY DofM DofN DofO1
	      DsubO1y DsubO1yx
	      (DsubO1x : {y} sub ([x] O1 x y) M (O1x y))
	      (DsubNx : sub N M Nx)
	      (DsubO1xy : sub ([y] O1x y) Nx O1yx)
	   <- sub-permute-esm _ DsizeS DsizeT Dsum
	      DlookupX DlookupY DofM DofN DofO2
	      DsubO2y DsubO2yx
	      (DsubO2x : {y} sub ([x] O2 x y) M (O2x y))
	      (DsubNx' : sub N M Nx')
	      (DsubO2xy : sub ([y] O2x y) Nx' O2yx)
	   <- sub-fun DsubNx' DsubNx (Deq : term-eq Nx' Nx)
	   <- sub-resp ([_] term-eq/i) Deq term-eq/i DsubO2xy (DsubO2xy' : sub ([y] O2x y) Nx O2yx).

-closed	: aasub-permute-esm _ _ _ _
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofN : {x} isvar x I -> {y} isvar y J -> ofes (G x y) (N x) T)
	   _
%%
	   ([_] aasub/closed)
	   Daasub
%%
	   ([_] Daasub)
	   DsubNx
	   aasub/closed
	   <- ({y} {e:isvar y J}
		 can-sub-es ([x] [d] DlookupX x d y e) ([x] [d] DofN x d y e) ([x] [d] DofM x d y e)
		    (DsubNx_y y : sub N M (Nx_y y)))
	   <- sub-closed' DsubNx_y (DsubNx : sub N M Nx).

-forall	: aasub-permute-esm Size DsizeS DsizeT Dsum
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofN : {x} isvar x I -> {y} isvar y J -> ofes (G x y) (N x) T)
	   (DofQuant : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (forall (A x y)) U1)
%%
	   ([x] aasub/forall
	      (DsubAy x : tsub ([y] A x y) (N x) (Ay x)))
	   (aasub/forall
	      (DsubAyx : tsub ([x] Ay x) M Ayx))
%%
	   ([y] aasub/forall (DsubAx y))
	   DsubNx
	   (aasub/forall DsubAxy)
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 aofes-invert-forall (DofQuant x d y e)
		 (DofA x d y e : wfes (G x y) (A x y)))
	   <- tsub-permute-esm Size DsizeS DsizeT Dsum
	      DlookupX DlookupY DofM DofN DofA
	      DsubAy DsubAyx
	      (DsubAx : {y} tsub ([x] A x y) M (Ax y))
	      (DsubNx : sub N M Nx)
	      (DsubAxy : tsub ([y] Ax y) Nx Ayx).

-all-c	: aasub-permute-esm Size DsizeS DsizeT Dsum
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofN : {x} isvar x I -> {y} isvar y J -> ofes (G x y) (N x) T)
	   (DofQuant : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (forall (A x y)) U1)
%%
	   ([x] aasub/forall
	      (DsubAy x : tsub ([y] A x y) (N x) Ay))
	   aasub/closed
%%
	   ([y] aasub/forall (DsubAx y))
	   DsubNx
	   (aasub/forall DsubAxy)
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 aofes-invert-forall (DofQuant x d y e)
		 (DofA x d y e : wfes (G x y) (A x y)))
	   <- tsub-absent Ay M DsubAyx
	   <- tsub-permute-esm Size DsizeS DsizeT Dsum
	      DlookupX DlookupY DofM DofN DofA
	      DsubAy DsubAyx
	      (DsubAx : {y} tsub ([x] A x y) M (Ax y))
	      (DsubNx : sub N M Nx)
	      (DsubAxy : tsub ([y] Ax y) Nx Ay).

-app	: aasub-permute-esm Size DsizeS DsizeT Dsum
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofN : {x} isvar x I -> {y} isvar y J -> ofes (G x y) (N x) T)
	   (DofApp : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (app (R x y) (O x y)) U2)
%%
	   ([x] aasub/app
	      (DsubOy x : sub ([y] O x y) (N x) (Oy x))
	      (DsubRy x : aasub ([y] R x y) (N x) (Ry x)))
	   (aasub/app
	      (DsubOyx : sub ([x] Oy x) M Oyx)
	      (DsubRyx : aasub ([x] Ry x) M Ryx))
%%
	   ([y] aasub/app (DsubOx y) (DsubRx y))
	   DsubNx
	   (aasub/app DsubOxy' DsubRxy)
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 aofes-invert-app (DofApp x d y e)
		    (DofR x d y e : aofes (G x y) (R x y) (spi U1 U2))
		    (DofO x d y e : ofes (G x y) (O x y) U1))
	   <- aasub-permute-esm Size DsizeS DsizeT Dsum
	      DlookupX DlookupY DofM DofN DofR
	      DsubRy DsubRyx
	      (DsubRx : {y} aasub ([x] R x y) M (Rx y))
	      (DsubNx : sub N M Nx)
	      (DsubRxy : aasub ([y] Rx y) Nx Ryx)
	   <- sub-permute-esm Size DsizeS DsizeT Dsum
	      DlookupX DlookupY DofM DofN DofO
	      DsubOy DsubOyx
	      (DsubOx : {y} sub ([x] O x y) M (Ox y))
	      (DsubNx' : sub N M Nx')
	      (DsubOxy : sub ([y] Ox y) Nx' Oyx)
	   <- sub-fun DsubNx' DsubNx (DeqNx : term-eq Nx' Nx)
	   <- sub-resp ([_] term-eq/i) DeqNx term-eq/i DsubOxy
	      (DsubOxy' : sub ([y] Ox y) Nx Oyx).

-app-c	: aasub-permute-esm Size DsizeS DsizeT Dsum
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofN : {x} isvar x I -> {y} isvar y J -> ofes (G x y) (N x) T)
	   (DofApp : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (app (R x y) (O x y)) U2)
%%
	   ([x] aasub/app
	      (DsubOy x : sub ([y] O x y) (N x) Oy)
	      (DsubRy x : aasub ([y] R x y) (N x) Ry))
	   aasub/closed
%%
	   ([y] aasub/app (DsubOx y) (DsubRx y))
	   DsubNx
	   (aasub/app DsubOxy' DsubRxy)
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 aofes-invert-app (DofApp x d y e)
		    (DofR x d y e : aofes (G x y) (R x y) (spi U1 U2))
		    (DofO x d y e : ofes (G x y) (O x y) U1))
	   <- aasub-permute-esm Size DsizeS DsizeT Dsum
	      DlookupX DlookupY DofM DofN DofR
	      DsubRy aasub/closed
	      (DsubRx : {y} aasub ([x] R x y) M (Rx y))
	      (DsubNx : sub N M Nx)
	      (DsubRxy : aasub ([y] Rx y) Nx Ry)
	   <- sub-absent Oy M (DsubOyx : sub ([x] Oy) M Oy)
	   <- sub-permute-esm Size DsizeS DsizeT Dsum
	      DlookupX DlookupY DofM DofN DofO
	      DsubOy DsubOyx
	      (DsubOx : {y} sub ([x] O x y) M (Ox y))
	      (DsubNx' : sub N M Nx')
	      (DsubOxy : sub ([y] Ox y) Nx' Oy)
	   <- sub-fun DsubNx' DsubNx (DeqNx : term-eq Nx' Nx)
	   <- sub-resp ([_] term-eq/i) DeqNx term-eq/i DsubOxy
	      (DsubOxy' : sub ([y] Ox y) Nx Oy).

-pi1	: aasub-permute-esm Size DsizeS DsizeT Dsum
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofN : {x} isvar x I -> {y} isvar y J -> ofes (G x y) (N x) T)
	   (DofPi : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (pi1 (R x y)) U1)
%%
	   ([x] aasub/pi1
	      (DsubRy x : aasub ([y] R x y) (N x) (Ry x)))
	   (aasub/pi1
	      (DsubRyx : aasub ([x] Ry x) M Ryx))
%%
	   ([y] aasub/pi1 (DsubRx y))
	   DsubNx
	   (aasub/pi1 DsubRxy)
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 aofes-invert-pi1 (DofPi x d y e)
		    (DofR x d y e : aofes (G x y) (R x y) (ssigma U1 U2)))
	   <- aasub-permute-esm Size DsizeS DsizeT Dsum
	      DlookupX DlookupY DofM DofN DofR
	      DsubRy DsubRyx
	      (DsubRx : {y} aasub ([x] R x y) M (Rx y))
	      (DsubNx : sub N M Nx)
	      (DsubRxy : aasub ([y] Rx y) Nx Ryx).

-pi1-c	: aasub-permute-esm Size DsizeS DsizeT Dsum
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofN : {x} isvar x I -> {y} isvar y J -> ofes (G x y) (N x) T)
	   (DofPi : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (pi1 (R x y)) U1)
%%
	   ([x] aasub/pi1
	      (DsubRy x : aasub ([y] R x y) (N x) Ry))
	   aasub/closed
%%
	   ([y] aasub/pi1 (DsubRx y))
	   DsubNx
	   (aasub/pi1 DsubRxy)
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 aofes-invert-pi1 (DofPi x d y e)
		    (DofR x d y e : aofes (G x y) (R x y) (ssigma U1 U2)))
	   <- aasub-permute-esm Size DsizeS DsizeT Dsum
	      DlookupX DlookupY DofM DofN DofR
	      DsubRy aasub/closed
	      (DsubRx : {y} aasub ([x] R x y) M (Rx y))
	      (DsubNx : sub N M Nx)
	      (DsubRxy : aasub ([y] Rx y) Nx Ry).
	      
-pi2	: aasub-permute-esm Size DsizeS DsizeT Dsum
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofN : {x} isvar x I -> {y} isvar y J -> ofes (G x y) (N x) T)
	   (DofPi : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (pi2 (R x y)) U2)
%%
	   ([x] aasub/pi2
	      (DsubRy x : aasub ([y] R x y) (N x) (Ry x)))
	   (aasub/pi2
	      (DsubRyx : aasub ([x] Ry x) M Ryx))
%%
	   ([y] aasub/pi2 (DsubRx y))
	   DsubNx
	   (aasub/pi2 DsubRxy)
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 aofes-invert-pi2 (DofPi x d y e)
		    (DofR x d y e : aofes (G x y) (R x y) (ssigma U1 U2)))
	   <- aasub-permute-esm Size DsizeS DsizeT Dsum
	      DlookupX DlookupY DofM DofN DofR
	      DsubRy DsubRyx
	      (DsubRx : {y} aasub ([x] R x y) M (Rx y))
	      (DsubNx : sub N M Nx)
	      (DsubRxy : aasub ([y] Rx y) Nx Ryx).

-pi2-c	: aasub-permute-esm Size DsizeS DsizeT Dsum
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofN : {x} isvar x I -> {y} isvar y J -> ofes (G x y) (N x) T)
	   (DofPi : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (pi2 (R x y)) U2)
%%
	   ([x] aasub/pi2
	      (DsubRy x : aasub ([y] R x y) (N x) Ry))
	   aasub/closed
%%
	   ([y] aasub/pi2 (DsubRx y))
	   DsubNx
	   (aasub/pi2 DsubRxy)
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 aofes-invert-pi2 (DofPi x d y e)
		    (DofR x d y e : aofes (G x y) (R x y) (ssigma U1 U2)))
	   <- aasub-permute-esm Size DsizeS DsizeT Dsum
	      DlookupX DlookupY DofM DofN DofR
	      DsubRy aasub/closed
	      (DsubRx : {y} aasub ([x] R x y) M (Rx y))
	      (DsubNx : sub N M Nx)
	      (DsubRxy : aasub ([y] Rx y) Nx Ry).


%%


-t	: tsub-permute-esm _ DsizeS DsizeT Dsum
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofN : {x} isvar x I -> {y} isvar y J -> ofes (G x y) (N x) T)
	   _
%%
	   ([_] tsub/t) 
	   tsub/t
%%
	   ([_] tsub/t) DsubNx tsub/t
	   <- ({y} {e:isvar y J}
		 can-sub-es ([x] [d] DlookupX x d y e) ([x] [d] DofN x d y e) ([x] [d] DofM x d y e)
		    (DsubNx_y y : sub ([x] N x) M (Nx_y y)))
	   <- sub-closed' DsubNx_y
	      (DsubNx : sub ([x] N x) M Nx).

-pi	: tsub-permute-esm _ DsizeS DsizeT Dsum
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofN : {x} isvar x I -> {y} isvar y J -> ofes (G x y) (N x) T)
	   ([x] [d:isvar x I] [y] [e:isvar y J]
	      wfes/pi
	      ([z] [f:isvar z K]
		 DofB x d y e z f : wfes (scons (G x y) z U) (B x y z))
	      (Dsimp x y : simp (A x y) U)
	      (DofA x d y e : wfes (G x y) (A x y)))
%%
	   ([x] tsub/pi
	      ([z] DsubBy x z : tsub ([y] B x y z) (N x) (By x z))
	      (DsubAy x : tsub ([y] A x y) (N x) (Ay x)))
	   (tsub/pi
	      ([z] DsubByx z : tsub ([x] By x z) M (Byx z))
	      (DsubAyx : tsub ([x] Ay x) M Ayx))
%%
	   ([y] tsub/pi ([z] DsubBx y z) (DsubAx y))
	   DsubNx
	   (tsub/pi ([z] DsubBxy' z) DsubAxy)
	   %% first get typing derivations
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J} 
		 {z} {f:isvar z K}
		 wfes-context (DofB x d y e z f) 
		    (sordered/cons
		       (Dbounded x d y e z f : sbounded (G x y) z)
		       : sordered (scons (G x y) z U)))
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J} 
		 {z} {f:isvar z K}
		 weaken-slookup (Dbounded x d y e z f) (DlookupX x d y e) _
		    (DlookupX' x d y e z f : slookup (scons (G x y) z U) x S))
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J} 
		 {z} {f:isvar z K}
		 weaken-slookup (Dbounded x d y e z f) (DlookupY x d y e) _
		    (DlookupY' x d y e z f : slookup (scons (G x y) z U) y T))
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J} 
		 {z} {f:isvar z K}
		 weaken-ofes (Dbounded x d y e z f) (DofM x d y e) _ 
		    (DofM' x d y e z f : ofes (scons (G x y) z U) M S))
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J} 
		 {z} {f:isvar z K}
		 weaken-ofes (Dbounded x d y e z f) (DofN x d y e) _ 
		    (DofN' x d y e z f : ofes (scons (G x y) z U) (N x) T))
	   %% now to work
	   <- tsub-permute-esm _ DsizeS DsizeT Dsum
	      DlookupX DlookupY DofM DofN DofA
	      DsubAy DsubAyx
	      (DsubAx : {y} tsub ([x] A x y) M (Ax y))
	      (DsubNx : sub ([x] N x) M Nx)
	      (DsubAxy : tsub ([y] Ax y) Nx Ayx)
	   <- ({z} {f:isvar z K}
		 tsub-permute-esm _ DsizeS DsizeT Dsum
		 ([x] [d] [y] [e] DlookupX' x d y e z f) ([x] [d] [y] [e] DlookupY' x d y e z f) ([x] [d] [y] [e] DofM' x d y e z f) ([x] [d] [y] [e] DofN' x d y e z f) ([x] [d] [y] [e] DofB x d y e z f)
		    ([x] DsubBy x z) (DsubByx z)
		    ([y] DsubBx y z : tsub ([x] B x y z) M (Bx y z))
		    (DsubNx' z : sub ([x] N x) M (Nx' z))
		    (DsubBxy z : tsub ([y] Bx y z) (Nx' z) (Byx z)))
	   <- ({z} sub-fun (DsubNx' z) DsubNx (DeqNx z : term-eq (Nx' z) Nx))
	   <- ({z} tsub-resp ([_] tp-eq/i) (DeqNx z) tp-eq/i (DsubBxy z)
		 (DsubBxy' z : tsub ([y] Bx y z) Nx (Byx z))).

-sigma	: tsub-permute-esm _ DsizeS DsizeT Dsum
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofN : {x} isvar x I -> {y} isvar y J -> ofes (G x y) (N x) T)
	   ([x] [d:isvar x I] [y] [e:isvar y J]
	      wfes/sigma
	      ([z] [f:isvar z K]
		 DofB x d y e z f : wfes (scons (G x y) z U) (B x y z))
	      (Dsimp x y : simp (A x y) U)
	      (DofA x d y e : wfes (G x y) (A x y)))
%%
	   ([x] tsub/sigma
	      ([z] DsubBy x z : tsub ([y] B x y z) (N x) (By x z))
	      (DsubAy x : tsub ([y] A x y) (N x) (Ay x)))
	   (tsub/sigma
	      ([z] DsubByx z : tsub ([x] By x z) M (Byx z))
	      (DsubAyx : tsub ([x] Ay x) M Ayx))
%%
	   ([y] tsub/sigma ([z] DsubBx y z) (DsubAx y))
	   DsubNx
	   (tsub/sigma ([z] DsubBxy' z) DsubAxy)
	   %% first get typing derivations
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J} 
		 {z} {f:isvar z K}
		 wfes-context (DofB x d y e z f) 
		    (sordered/cons
		       (Dbounded x d y e z f : sbounded (G x y) z)
		       : sordered (scons (G x y) z U)))
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J} 
		 {z} {f:isvar z K}
		 weaken-slookup (Dbounded x d y e z f) (DlookupX x d y e) _
		    (DlookupX' x d y e z f : slookup (scons (G x y) z U) x S))
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J} 
		 {z} {f:isvar z K}
		 weaken-slookup (Dbounded x d y e z f) (DlookupY x d y e) _
		    (DlookupY' x d y e z f : slookup (scons (G x y) z U) y T))
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J} 
		 {z} {f:isvar z K}
		 weaken-ofes (Dbounded x d y e z f) (DofM x d y e) _ 
		    (DofM' x d y e z f : ofes (scons (G x y) z U) M S))
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J} 
		 {z} {f:isvar z K}
		 weaken-ofes (Dbounded x d y e z f) (DofN x d y e) _ 
		    (DofN' x d y e z f : ofes (scons (G x y) z U) (N x) T))
	   %% now to work
	   <- tsub-permute-esm _ DsizeS DsizeT Dsum
	      DlookupX DlookupY DofM DofN DofA
	      DsubAy DsubAyx
	      (DsubAx : {y} tsub ([x] A x y) M (Ax y))
	      (DsubNx : sub ([x] N x) M Nx)
	      (DsubAxy : tsub ([y] Ax y) Nx Ayx)
	   <- ({z} {f:isvar z K}
		 tsub-permute-esm _ DsizeS DsizeT Dsum
		 ([x] [d] [y] [e] DlookupX' x d y e z f) ([x] [d] [y] [e] DlookupY' x d y e z f) ([x] [d] [y] [e] DofM' x d y e z f) ([x] [d] [y] [e] DofN' x d y e z f) ([x] [d] [y] [e] DofB x d y e z f)
		    ([x] DsubBy x z) (DsubByx z)
		    ([y] DsubBx y z : tsub ([x] B x y z) M (Bx y z))
		    (DsubNx' z : sub ([x] N x) M (Nx' z))
		    (DsubBxy z : tsub ([y] Bx y z) (Nx' z) (Byx z)))
	   <- ({z} sub-fun (DsubNx' z) DsubNx (DeqNx z : term-eq (Nx' z) Nx))
	   <- ({z} tsub-resp ([_] tp-eq/i) (DeqNx z) tp-eq/i (DsubBxy z)
		 (DsubBxy' z : tsub ([y] Bx y z) Nx (Byx z))).

-singaa	: tsub-permute-esm _ DsizeS DsizeT Dsum
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofN : {x} isvar x I -> {y} isvar y J -> ofes (G x y) (N x) T)
	   ([x] [d:isvar x I] [y] [e:isvar y J]
	      wfes/sing 
	      (DofR x d y e : aofes (G x y) (R x y) st))
%%
	   ([x] tsub/singa
	      (DsubRy x : aasub ([y] R x y) (N x) (Ry x)))
	   (tsub/singa
	      (DsubRyx : aasub ([x] Ry x) M Ryx))
%%
	   ([y] tsub/singa (DsubRx y))
	   DsubNx
	   (tsub/singa DsubRxy)
	   <- aasub-permute-esm _ DsizeS DsizeT Dsum
	      DlookupX DlookupY DofM DofN DofR
	      DsubRy DsubRyx
	      (DsubRx : {y} aasub ([x] R x y) M (Rx y))
	      (DsubNx : sub ([x] N x) M Nx)
	      (DsubRxy : aasub ([y] Rx y) Nx Ryx).

-singao	: tsub-permute-esm _ DsizeS DsizeT Dsum
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofN : {x} isvar x I -> {y} isvar y J -> ofes (G x y) (N x) T)
	   ([x] [d:isvar x I] [y] [e:isvar y J]
	      wfes/sing 
	      (DofR x d y e : aofes (G x y) (R x y) st))
%%
	   ([x] tsub/singa
	      (DsubRy x : aasub ([y] R x y) (N x) (Ry x)))
	   (tsub/singo
	      (DsubRyx : aosub ([x] Ry x) M (at Ryx)))
%%
	   ([y] tsub/singo
	      (DsubRx' aca y))
	   DsubNx
	   Dtsub
	   <- aasub-aosub-permute-esm _ DsizeS DsizeT Dsum
	      DlookupX DlookupY DofM DofN DofR
	      DsubRy DsubRyx
	      (DsubRx : {y} aosub ([x] R x y) M (LRx y))
	      (DsubNx : sub ([x] N x) M Nx)
	      (DsubRxy : sub ([y] LRx y) Nx (at Ryx))
	   <- ({y} {e:isvar y J}
		 aosubst-es ([x] [d] DlookupX x d y e) ([x] [d] DofM x d y e) ([x] [d] DofR x d y e) (DsubRx y)
		    ([x] [d] DofRx x d y e : ofes (G x y) (LRx y) st))
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 ofes-invert-st (DofRx x d y e) (DeqRx x y : term-eq (LRx y) (at (Rx_x x y))))
	   <- ({x} {y}
		 aosub-resp ([_] atom-eq/i) term-eq/i (DeqRx x y) (DsubRx y) 
		 (DsubRx' x y : aosub ([x] R x y) M (at (Rx_x x y))))
	   <- sub-resp ([y] DeqRx aca y) term-eq/i term-eq/i DsubRxy
	      (DsubRxy' : sub ([y] at (Rx_x aca y)) Nx (at Ryx))
	   <- sub-at-tsub DsubRxy' (Dtsub : tsub ([y] sing (Rx_x aca y)) Nx (sing Ryx)).

-singoa	: tsub-permute-esm _ DsizeS DsizeT Dsum
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofN : {x} isvar x I -> {y} isvar y J -> ofes (G x y) (N x) T)
	   ([x] [d:isvar x I] [y] [e:isvar y J]
	      wfes/sing 
	      (DofR x d y e : aofes (G x y) (R x y) st))
%%
	   ([x] tsub/singo
	      (DsubRy x : aosub ([y] R x y) (N x) (at (Ry x))))
	   (tsub/singa
	      (DsubRyx : aasub ([x] Ry x) M Ryx))
%%
	   ([y] tsub/singa (DsubRx y))
	   DsubNx
	   (tsub/singo DsubRxy)
	   <- aosub-permute-esm _ DsizeS DsizeT Dsum DlookupX DlookupY DofM DofN DofR
	      DsubRy (sub/aa DsubRyx)
	      (DsubRx : {y} aasub ([x] R x y) M (Rx y))
	      (DsubNx : sub ([x] N x) M Nx)
	      (DsubRxy : aosub ([y] Rx y) Nx (at Ryx)).

-singoo	: tsub-permute-esm _ DsizeS DsizeT Dsum
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofN : {x} isvar x I -> {y} isvar y J -> ofes (G x y) (N x) T)
	   ([x] [d:isvar x I] [y] [e:isvar y J]
	      wfes/sing 
	      (DofR x d y e : aofes (G x y) (R x y) st))
%%
	   ([x] tsub/singo
	      (DsubRy x : aosub ([y] R x y) (N x) (at (Ry x))))
	   (tsub/singo
	      (DsubRyx : aosub ([x] Ry x) M (at Ryx)))
%%
	   ([y] tsub/singa (DsubRx y))
	   DsubNx
	   (tsub/singo DsubRxy)
	   <- aosub-permute-esm _ DsizeS DsizeT Dsum DlookupX DlookupY DofM DofN DofR
	      DsubRy (sub/ao DsubRyx)
	      (DsubRx : {y} aasub ([x] R x y) M (Rx y))
	      (DsubNx : sub ([x] N x) M Nx)
	      (DsubRxy : aosub ([y] Rx y) Nx (at Ryx)).


%worlds (var | ovar | bind) (aosub-permute-esm _ _ _ _ _ _ _ _ _ _ _ _ _ _) (aasub-aosub-permute-esm _ _ _ _ _ _ _ _ _ _ _ _ _ _) (aasub-permute-esm _ _ _ _ _ _ _ _ _ _ _ _ _ _) (sub-permute-esm _ _ _ _ _ _ _ _ _ _ _ _ _ _) (tsub-permute-esm _ _ _ _ _ _ _ _ _ _ _ _ _ _).
%total {(N1 N2 N3 N4 N5) (D1 D2 D3 D4 D5)} (sub-permute-esm N4 _ _ _ _ _ _ _ _ D4 _ _ _ _) (aosub-permute-esm N1 _ _ _ _ _ _ _ _ D1 _ _ _ _) (aasub-aosub-permute-esm N2 _ _ _ _ _ _ _ _ D2 _ _ _ _) (aasub-permute-esm N3 _ _ _ _ _ _ _ _ D3 _ _ _ _) (tsub-permute-esm N5 _ _ _ _ _ _ _ _ D5 _ _ _ _).



sub-permute-es : ({x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
		  -> ({x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
		  -> ({x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
		  -> ({x} isvar x I -> {y} isvar y J -> ofes (G x y) (N x) T)
		  -> ({x} isvar x I -> {y} isvar y J -> ofes (G x y) (O x y) U)
%%
		  -> ({x} sub ([y] O x y) (N x) (Oy x))
		  -> sub Oy M Oyx
%%
		  -> ({y} sub ([x] O x y) M (Ox y))
		  -> sub N M Nx
		  -> sub Ox Nx Oyx -> type. 
%mode sub-permute-es +X1 +X2 +X3 +X4 +X5 +X6 +X7 -X8 -X9 -X10.

-	: sub-permute-es DlookupX DlookupY DofM DofN DofO DsubOy DsubOyx
	   DsubOx DsubNx DsubOxy
	   <- can-stp-size S (DsizeS : stp-size S SizeS)
	   <- can-stp-size T (DsizeT : stp-size T SizeT)
	   <- can-sum SizeS SizeT Size (Dsum : sum SizeS SizeT Size)
	   <- sub-permute-esm Size DsizeS DsizeT Dsum DlookupX DlookupY DofM DofN DofO DsubOy DsubOyx
	      DsubOx DsubNx DsubOxy.

%worlds (var | ovar | bind) (sub-permute-es _ _ _ _ _ _ _ _ _ _).
%total {} (sub-permute-es _ _ _ _ _ _ _ _ _ _).



aasub-aosub-permute-es : ({x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
		    -> ({x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
		    -> ({x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
		    -> ({x} isvar x I -> {y} isvar y J -> ofes (G x y) (N x) T)
		    -> ({x} isvar x I -> {y} isvar y J -> aofes (G x y) (R x y) U)
%%
		    -> ({x} aasub ([y] R x y) (N x) (Ry x))
		    -> aosub Ry M LRyx
%%
		    -> ({y} aosub ([x] R x y) M (LRx y))
		    -> sub N M Nx
		    -> sub ([y] LRx y) Nx LRyx -> type.
%mode aasub-aosub-permute-es +X1 +X2 +X3 +X4 +X5 +X6 +X7 -X8 -X9 -X10.

-	: aasub-aosub-permute-es DlookupX DlookupY DofM DofN DofR DsubRy DsubRyx
	   DsubRx DsubNx DsubRxy
	   <- can-stp-size S (DsizeS : stp-size S SizeS)
	   <- can-stp-size T (DsizeT : stp-size T SizeT)
	   <- can-sum SizeS SizeT Size (Dsum : sum SizeS SizeT Size)
	   <- aasub-aosub-permute-esm Size DsizeS DsizeT Dsum DlookupX DlookupY DofM DofN DofR DsubRy DsubRyx
	      DsubRx DsubNx DsubRxy.

%worlds (var | ovar | bind) (aasub-aosub-permute-es _ _ _ _ _ _ _ _ _ _).
%total {} (aasub-aosub-permute-es _ _ _ _ _ _ _ _ _ _).



aasub-permute-es : ({x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
		    -> ({x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
		    -> ({x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
		    -> ({x} isvar x I -> {y} isvar y J -> ofes (G x y) (N x) T)
		    -> ({x} isvar x I -> {y} isvar y J -> aofes (G x y) (R x y) U)
%%
		    -> ({x} aasub ([y] R x y) (N x) (Ry x))
		    -> aasub Ry M Ryx
%%
		    -> ({y} aasub ([x] R x y) M (Rx y))
		    -> sub N M Nx
		    -> aasub ([y] Rx y) Nx Ryx -> type.
%mode aasub-permute-es +X1 +X2 +X3 +X4 +X5 +X6 +X7 -X8 -X9 -X10.

-	: aasub-permute-es DlookupX DlookupY DofM DofN DofR DsubRy DsubRyx
	   DsubRx DsubNx DsubRxy
	   <- can-stp-size S (DsizeS : stp-size S SizeS)
	   <- can-stp-size T (DsizeT : stp-size T SizeT)
	   <- can-sum SizeS SizeT Size (Dsum : sum SizeS SizeT Size)
	   <- aasub-permute-esm Size DsizeS DsizeT Dsum DlookupX DlookupY DofM DofN DofR DsubRy DsubRyx
	      DsubRx DsubNx DsubRxy.

%worlds (var | ovar | bind) (aasub-permute-es _ _ _ _ _ _ _ _ _ _).
%total {} (aasub-permute-es _ _ _ _ _ _ _ _ _ _).



aosub-permute-es : ({x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
		    -> ({x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
		    -> ({x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
		    -> ({x} isvar x I -> {y} isvar y J -> ofes (G x y) (N x) T)
		    -> ({x} isvar x I -> {y} isvar y J -> aofes (G x y) (R x y) U)
%%
		    -> ({x} aosub ([y] R x y) (N x) (LRy x))
		    -> sub LRy M LRyx
%%
		    -> ({y} aasub ([x] R x y) M (Rx y))
		    -> sub N M Nx
		    -> aosub ([y] Rx y) Nx LRyx -> type.
%mode aosub-permute-es +X1 +X2 +X3 +X4 +X5 +X6 +X7 -X8 -X9 -X10.

-	: aosub-permute-es DlookupX DlookupY DofM DofN DofR DsubRy DsubRyx
	   DsubRx DsubNx DsubRxy
	   <- can-stp-size S (DsizeS : stp-size S SizeS)
	   <- can-stp-size T (DsizeT : stp-size T SizeT)
	   <- can-sum SizeS SizeT Size (Dsum : sum SizeS SizeT Size)
	   <- aosub-permute-esm Size DsizeS DsizeT Dsum DlookupX DlookupY DofM DofN DofR DsubRy DsubRyx
	      DsubRx DsubNx DsubRxy.

%worlds (var | ovar | bind) (aosub-permute-es _ _ _ _ _ _ _ _ _ _).
%total {} (aosub-permute-es _ _ _ _ _ _ _ _ _ _).



tsub-permute-es : ({x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
		   -> ({x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
		   -> ({x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
		   -> ({x} isvar x I -> {y} isvar y J -> ofes (G x y) (N x) T)
		   -> ({x} isvar x I -> {y} isvar y J -> wfes (G x y) (A x y))
%%
		   -> ({x} tsub ([y] A x y) (N x) (Ay x))
		   -> tsub ([x] Ay x) M Ayx
%%
		   -> ({y} tsub ([x] A x y) M (Ax y))
		   -> sub ([x] N x) M Nx
		   -> tsub ([y] Ax y) Nx Ayx -> type.
%mode tsub-permute-es +X1 +X2 +X3 +X4 +X5 +X6 +X7 -X8 -X9 -X10.

-	: tsub-permute-es DlookupX DlookupY DofM DofN DwfA DsubAy DsubAyx
	   DsubAx DsubNx DsubAxy
	   <- can-stp-size S (DsizeS : stp-size S SizeS)
	   <- can-stp-size T (DsizeT : stp-size T SizeT)
	   <- can-sum SizeS SizeT Size (Dsum : sum SizeS SizeT Size)
	   <- tsub-permute-esm Size DsizeS DsizeT Dsum DlookupX DlookupY DofM DofN DwfA DsubAy DsubAyx
	      DsubAx DsubNx DsubAxy.

%worlds (var | ovar | bind) (tsub-permute-es _ _ _ _ _ _ _ _ _ _).
%total {} (tsub-permute-es _ _ _ _ _ _ _ _ _ _).





%%%%%  Substitution Permutation (Explicit Context)  %%%%%

sub-permute-e : ({x} append (cons G1 x A) (G2 x) (G x))
		 -> ofe G1 M A
		 -> ({x} isvar x I -> ofe (G x) (N x) (B x))
		 -> ({x} isvar x I -> {y} isvar y J -> ofe (cons (G x) y (B x)) (O x y) (C x y))
%%
		 -> ({y} sub ([x] O x y) M (Ox y))
		 -> sub N M Nx
		 -> sub ([y] Ox y) Nx Oxy
		 -> ({x} sub ([y] O x y) (N x) (Oy x))
		 -> sub ([x] Oy x) M Oyx
%%
		 -> term-eq Oxy Oyx -> type.
%mode sub-permute-e +X1 +X2 +X3 +X4 +X5 +X6 +X7 +X8 +X9 -X10.

-	: sub-permute-e
	   (Dappend : {x} append (cons G1 x A) (G2 x) (G x))
	   (DofM : ofe G1 M A)
	   (DofN : ({x} isvar x I -> ofe (G x) (N x) (B x)))
	   (DofO : ({x} isvar x I -> {y} isvar y J -> ofe (cons (G x) y (B x)) (O x y) (C x y)))
	   (DsubOx : ({y} sub ([x] O x y) M (Ox y)))
	   (DsubNx : sub N M Nx)
	   (DsubOxy : sub ([y] Ox y) Nx Oxy)
	   (DsubOy : ({x} sub ([y] O x y) (N x) (Oy x)))
	   (DsubOyx : sub ([x] Oy x) M Oyx)
%%
	   Deq
	   %% get context orderings
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 ofe-context (DofO x d y e) 
		    (ordered/cons
		       (Dbounded x d y e : bounded (G x) y)))
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 append-bounded (Dappend x) (Dbounded x d y e)
		    (bounded/cons
		       (Dbounded' x d y e : bounded G1 x)
		       (DprecedesXY x d y e : precedes x y)))
	   %% get simplifications
	   <- can-simp A (DsimpA : simp A S)
	   <- ({x} can-simp (B x) (DsimpB x : simp (B x) T))
	   <- ({x} {y} can-simp (C x y) (DsimpC x y : simp (C x y) U))
	   <- ({y} {e:isvar y J}
		 context-append-simp-lookup Dappend ([x] [d] Dbounded x d y e) DsimpA
		    ([x] Dsimpctx x y : simpctx (G x) (G' x y))
		    ([x] [d] Dsbounded x d y e : sbounded (G' x y) y)
		    ([x] [d] Dlookup x d y e : slookup (G' x y) x S))
	   %% weaken and simplify DofM
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 weaken-ofe (Dbounded' x d y e) DofM _ 
		    (DofM' x d y e : ofe (cons G1 x A) M A))
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 weaken-ofe'' (Dappend x) (Dbounded x d y e) (DofM' x d y e) 
		    (DofM'' x d y e : ofe (G x) M A))
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 weaken-ofe (Dbounded x d y e) (DofM'' x d y e) _
		    (DofM''' x d y e : ofe (cons (G x) y (B x)) M A))
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 ofe-simp (simpctx/cons (DsimpB x) (Dsimpctx x y)) DsimpA (DofM''' x d y e)
		    (DofM'''' x d y e : ofes (scons (G' x y) y T) M S))
	   %% weaken and simplify DofN
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 weaken-ofe (Dbounded x d y e) (DofN x d) _
		    (DofN' x d y e : ofe (cons (G x) y (B x)) (N x) (B x)))
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		    ofe-simp (simpctx/cons (DsimpB x) (Dsimpctx x y)) (DsimpB x) (DofN' x d y e)
		       (DofN'' x d y e : ofes (scons (G' x y) y T) (N x) T))
	   %% simplify DofO
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		    ofe-simp (simpctx/cons (DsimpB x) (Dsimpctx x y)) (DsimpC x y) (DofO x d y e)
		       (DofO' x d y e : ofes (scons (G' x y) y T) (O x y) U))
	   %% go
	   <- sub-permute-es
	      ([x] [d:isvar x I] [y] [e:isvar y J]
		 slookup/miss (Dlookup x d y e) (Dsbounded x d y e))
	      ([x] [d] [y] [e] slookup/hit (Dsbounded x d y e))
	      DofM'''' DofN''  DofO'
	      DsubOy DsubOyx
	      (DsubOx' : {y} sub ([x] O x y) M (Ox' y))
	      (DsubNx' : sub N M Nx')
	      (DsubOxy' : sub Ox' Nx' Oyx)
	   <- ({y} sub-fun (DsubOx' y) (DsubOx y) (DeqOx y : term-eq (Ox' y) (Ox y)))
	   <- sub-fun DsubNx' DsubNx (DeqNx : term-eq Nx' Nx)
	   <- sub-resp DeqOx DeqNx term-eq/i DsubOxy' (DsubOxy'' : sub Ox Nx Oyx)
	   <- sub-fun DsubOxy DsubOxy'' (Deq : term-eq Oxy Oyx).

%worlds (var | ovar | bind) (sub-permute-e _ _ _ _ _ _ _ _ _ _).
%total {} (sub-permute-e _ _ _ _ _ _ _ _ _ _).



aasub-permute-e : ({x} append (cons G1 x A) (G2 x) (G x))
		 -> ofe G1 M A
		 -> ({x} isvar x I -> ofe (G x) (N x) (B x))
		 -> ({x} isvar x I -> {y} isvar y J -> aofe (cons (G x) y (B x)) (R x y) (C x y))
%%
		 -> ({y} aasub ([x] R x y) M (Rx y))
		 -> sub N M Nx
		 -> aasub ([y] Rx y) Nx Rxy
		 -> ({x} aasub ([y] R x y) (N x) (Ry x))
		 -> aasub ([x] Ry x) M Ryx
%%
		 -> atom-eq Rxy Ryx -> type.
%mode aasub-permute-e +X1 +X2 +X3 +X4 +X5 +X6 +X7 +X8 +X9 -X10.

-	: aasub-permute-e
	   (Dappend : {x} append (cons G1 x A) (G2 x) (G x))
	   (DofM : ofe G1 M A)
	   (DofN : ({x} isvar x I -> ofe (G x) (N x) (B x)))
	   (DaofR : ({x} isvar x I -> {y} isvar y J -> aofe (cons (G x) y (B x)) (R x y) (C x y)))
	   (DsubRx : ({y} aasub ([x] R x y) M (Rx y)))
	   (DsubNx : sub N M Nx)
	   (DsubRxy : aasub ([y] Rx y) Nx Rxy)
	   (DsubRy : ({x} aasub ([y] R x y) (N x) (Ry x)))
	   (DsubRyx : aasub ([x] Ry x) M Ryx)
%%
	   Deq
	   %% get context orderings
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 aofe-context (DaofR x d y e) 
		    (ordered/cons
		       (Dbounded x d y e : bounded (G x) y)))
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 append-bounded (Dappend x) (Dbounded x d y e)
		    (bounded/cons
		       (Dbounded' x d y e : bounded G1 x)
		       (DprecedesXY x d y e : precedes x y)))
	   %% get simplifications
	   <- can-simp A (DsimpA : simp A S)
	   <- ({x} can-simp (B x) (DsimpB x : simp (B x) T))
	   <- ({x} {y} can-simp (C x y) (DsimpC x y : simp (C x y) U))
	   <- ({y} {e:isvar y J}
		 context-append-simp-lookup Dappend ([x] [d] Dbounded x d y e) DsimpA
		    ([x] Dsimpctx x y : simpctx (G x) (G' x y))
		    ([x] [d] Dsbounded x d y e : sbounded (G' x y) y)
		    ([x] [d] Dlookup x d y e : slookup (G' x y) x S))
	   %% weaken and simplify DofM
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 weaken-ofe (Dbounded' x d y e) DofM _ 
		    (DofM' x d y e : ofe (cons G1 x A) M A))
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 weaken-ofe'' (Dappend x) (Dbounded x d y e) (DofM' x d y e) 
		    (DofM'' x d y e : ofe (G x) M A))
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 weaken-ofe (Dbounded x d y e) (DofM'' x d y e) _
		    (DofM''' x d y e : ofe (cons (G x) y (B x)) M A))
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 ofe-simp (simpctx/cons (DsimpB x) (Dsimpctx x y)) DsimpA (DofM''' x d y e)
		    (DofM'''' x d y e : ofes (scons (G' x y) y T) M S))
	   %% weaken and simplify DofN
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 weaken-ofe (Dbounded x d y e) (DofN x d) _
		    (DofN' x d y e : ofe (cons (G x) y (B x)) (N x) (B x)))
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		    ofe-simp (simpctx/cons (DsimpB x) (Dsimpctx x y)) (DsimpB x) (DofN' x d y e)
		       (DofN'' x d y e : ofes (scons (G' x y) y T) (N x) T))
	   %% simplify DaofR
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		    aofe-simp (simpctx/cons (DsimpB x) (Dsimpctx x y)) (DsimpC x y) (DaofR x d y e)
		       (DaofR' x d y e : aofes (scons (G' x y) y T) (R x y) U))
	   %% go
	   <- aasub-permute-es
	      ([x] [d:isvar x I] [y] [e:isvar y J]
		 slookup/miss (Dlookup x d y e) (Dsbounded x d y e))
	      ([x] [d] [y] [e] slookup/hit (Dsbounded x d y e))
	      DofM'''' DofN''  DaofR'
	      DsubRy DsubRyx
	      (DsubRx' : {y} aasub ([x] R x y) M (Rx' y))
	      (DsubNx' : sub N M Nx')
	      (DsubRxy' : aasub Rx' Nx' Ryx)
	   <- ({y} aasub-fun (DsubRx' y) (DsubRx y) (DeqRx y : atom-eq (Rx' y) (Rx y)))
	   <- sub-fun DsubNx' DsubNx (DeqNx : term-eq Nx' Nx)
	   <- aasub-resp DeqRx DeqNx atom-eq/i DsubRxy' (DsubRxy'' : aasub Rx Nx Ryx)
	   <- aasub-fun DsubRxy DsubRxy'' (Deq : atom-eq Rxy Ryx).

%worlds (var | ovar | bind) (aasub-permute-e _ _ _ _ _ _ _ _ _ _).
%total {} (aasub-permute-e _ _ _ _ _ _ _ _ _ _).



aasub-aosub-permute-e : ({x} append (cons G1 x A) (G2 x) (G x))
		 -> ofe G1 M A
		 -> ({x} isvar x I -> ofe (G x) (N x) (B x))
		 -> ({x} isvar x I -> {y} isvar y J -> aofe (cons (G x) y (B x)) (R x y) (C x y))
%%
		 -> ({y} aosub ([x] R x y) M (LRx y))
		 -> sub N M Nx
		 -> sub ([y] LRx y) Nx LRxy
		 -> ({x} aasub ([y] R x y) (N x) (Ry x))
		 -> aosub ([x] Ry x) M LRyx
%%
		 -> term-eq LRxy LRyx -> type.
%mode aasub-aosub-permute-e +X1 +X2 +X3 +X4 +X5 +X6 +X7 +X8 +X9 -X10.

-	: aasub-aosub-permute-e
	   (Dappend : {x} append (cons G1 x A) (G2 x) (G x))
	   (DofM : ofe G1 M A)
	   (DofN : ({x} isvar x I -> ofe (G x) (N x) (B x)))
	   (DaofR : ({x} isvar x I -> {y} isvar y J -> aofe (cons (G x) y (B x)) (R x y) (C x y)))
	   (DsubRx : ({y} aosub ([x] R x y) M (LRx y)))
	   (DsubNx : sub N M Nx)
	   (DsubRxy : sub ([y] LRx y) Nx LRxy)
	   (DsubRy : ({x} aasub ([y] R x y) (N x) (Ry x)))
	   (DsubRyx : aosub ([x] Ry x) M LRyx)
%%
	   Deq
	   %% get context orderings
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 aofe-context (DaofR x d y e) 
		    (ordered/cons
		       (Dbounded x d y e : bounded (G x) y)))
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 append-bounded (Dappend x) (Dbounded x d y e)
		    (bounded/cons
		       (Dbounded' x d y e : bounded G1 x)
		       (DprecedesXY x d y e : precedes x y)))
	   %% get simplifications
	   <- can-simp A (DsimpA : simp A S)
	   <- ({x} can-simp (B x) (DsimpB x : simp (B x) T))
	   <- ({x} {y} can-simp (C x y) (DsimpC x y : simp (C x y) U))
	   <- ({y} {e:isvar y J}
		 context-append-simp-lookup Dappend ([x] [d] Dbounded x d y e) DsimpA
		    ([x] Dsimpctx x y : simpctx (G x) (G' x y))
		    ([x] [d] Dsbounded x d y e : sbounded (G' x y) y)
		    ([x] [d] Dlookup x d y e : slookup (G' x y) x S))
	   %% weaken and simplify DofM
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 weaken-ofe (Dbounded' x d y e) DofM _ 
		    (DofM' x d y e : ofe (cons G1 x A) M A))
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 weaken-ofe'' (Dappend x) (Dbounded x d y e) (DofM' x d y e) 
		    (DofM'' x d y e : ofe (G x) M A))
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 weaken-ofe (Dbounded x d y e) (DofM'' x d y e) _
		    (DofM''' x d y e : ofe (cons (G x) y (B x)) M A))
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 ofe-simp (simpctx/cons (DsimpB x) (Dsimpctx x y)) DsimpA (DofM''' x d y e)
		    (DofM'''' x d y e : ofes (scons (G' x y) y T) M S))
	   %% weaken and simplify DofN
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 weaken-ofe (Dbounded x d y e) (DofN x d) _
		    (DofN' x d y e : ofe (cons (G x) y (B x)) (N x) (B x)))
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		    ofe-simp (simpctx/cons (DsimpB x) (Dsimpctx x y)) (DsimpB x) (DofN' x d y e)
		       (DofN'' x d y e : ofes (scons (G' x y) y T) (N x) T))
	   %% simplify DaofR
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		    aofe-simp (simpctx/cons (DsimpB x) (Dsimpctx x y)) (DsimpC x y) (DaofR x d y e)
		       (DaofR' x d y e : aofes (scons (G' x y) y T) (R x y) U))
	   %% go
	   <- aasub-aosub-permute-es
	      ([x] [d:isvar x I] [y] [e:isvar y J]
		 slookup/miss (Dlookup x d y e) (Dsbounded x d y e))
	      ([x] [d] [y] [e] slookup/hit (Dsbounded x d y e))
	      DofM'''' DofN''  DaofR'
	      DsubRy DsubRyx
	      (DsubRx' : {y} aosub ([x] R x y) M (LRx' y))
	      (DsubNx' : sub N M Nx')
	      (DsubRxy' : sub LRx' Nx' LRyx)
	   <- ({y} aosub-fun (DsubRx' y) (DsubRx y) (DeqLRx y : term-eq (LRx' y) (LRx y)))
	   <- sub-fun DsubNx' DsubNx (DeqNx : term-eq Nx' Nx)
	   <- sub-resp DeqLRx DeqNx term-eq/i DsubRxy' (DsubRxy'' : sub LRx Nx LRyx)
	   <- sub-fun DsubRxy DsubRxy'' (Deq : term-eq LRxy LRyx).

%worlds (var | ovar | bind) (aasub-aosub-permute-e _ _ _ _ _ _ _ _ _ _).
%total {} (aasub-aosub-permute-e _ _ _ _ _ _ _ _ _ _).



aosub-permute-e : ({x} append (cons G1 x A) (G2 x) (G x))
		 -> ofe G1 M A
		 -> ({x} isvar x I -> ofe (G x) (N x) (B x))
		 -> ({x} isvar x I -> {y} isvar y J -> aofe (cons (G x) y (B x)) (R x y) (C x y))
%%
		 -> ({y} aasub ([x] R x y) M (Rx y))
		 -> sub N M Nx
		 -> aosub ([y] Rx y) Nx LRxy
		 -> ({x} aosub ([y] R x y) (N x) (LRy x))
		 -> sub ([x] LRy x) M LRyx
%%
		 -> term-eq LRxy LRyx -> type.
%mode aosub-permute-e +X1 +X2 +X3 +X4 +X5 +X6 +X7 +X8 +X9 -X10.

-	: aosub-permute-e
	   (Dappend : {x} append (cons G1 x A) (G2 x) (G x))
	   (DofM : ofe G1 M A)
	   (DofN : ({x} isvar x I -> ofe (G x) (N x) (B x)))
	   (DaofR : ({x} isvar x I -> {y} isvar y J -> aofe (cons (G x) y (B x)) (R x y) (C x y)))
	   (DsubRx : ({y} aasub ([x] R x y) M (Rx y)))
	   (DsubNx : sub N M Nx)
	   (DsubRxy : aosub ([y] Rx y) Nx LRxy)
	   (DsubRy : ({x} aosub ([y] R x y) (N x) (LRy x)))
	   (DsubRyx : sub ([x] LRy x) M LRyx)
%%
	   Deq
	   %% get context orderings
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 aofe-context (DaofR x d y e) 
		    (ordered/cons
		       (Dbounded x d y e : bounded (G x) y)))
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 append-bounded (Dappend x) (Dbounded x d y e)
		    (bounded/cons
		       (Dbounded' x d y e : bounded G1 x)
		       (DprecedesXY x d y e : precedes x y)))
	   %% get simplifications
	   <- can-simp A (DsimpA : simp A S)
	   <- ({x} can-simp (B x) (DsimpB x : simp (B x) T))
	   <- ({x} {y} can-simp (C x y) (DsimpC x y : simp (C x y) U))
	   <- ({y} {e:isvar y J}
		 context-append-simp-lookup Dappend ([x] [d] Dbounded x d y e) DsimpA
		    ([x] Dsimpctx x y : simpctx (G x) (G' x y))
		    ([x] [d] Dsbounded x d y e : sbounded (G' x y) y)
		    ([x] [d] Dlookup x d y e : slookup (G' x y) x S))
	   %% weaken and simplify DofM
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 weaken-ofe (Dbounded' x d y e) DofM _ 
		    (DofM' x d y e : ofe (cons G1 x A) M A))
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 weaken-ofe'' (Dappend x) (Dbounded x d y e) (DofM' x d y e) 
		    (DofM'' x d y e : ofe (G x) M A))
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 weaken-ofe (Dbounded x d y e) (DofM'' x d y e) _
		    (DofM''' x d y e : ofe (cons (G x) y (B x)) M A))
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 ofe-simp (simpctx/cons (DsimpB x) (Dsimpctx x y)) DsimpA (DofM''' x d y e)
		    (DofM'''' x d y e : ofes (scons (G' x y) y T) M S))
	   %% weaken and simplify DofN
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 weaken-ofe (Dbounded x d y e) (DofN x d) _
		    (DofN' x d y e : ofe (cons (G x) y (B x)) (N x) (B x)))
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		    ofe-simp (simpctx/cons (DsimpB x) (Dsimpctx x y)) (DsimpB x) (DofN' x d y e)
		       (DofN'' x d y e : ofes (scons (G' x y) y T) (N x) T))
	   %% simplify DaofR
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		    aofe-simp (simpctx/cons (DsimpB x) (Dsimpctx x y)) (DsimpC x y) (DaofR x d y e)
		       (DaofR' x d y e : aofes (scons (G' x y) y T) (R x y) U))
	   %% go
	   <- aosub-permute-es
	      ([x] [d:isvar x I] [y] [e:isvar y J]
		 slookup/miss (Dlookup x d y e) (Dsbounded x d y e))
	      ([x] [d] [y] [e] slookup/hit (Dsbounded x d y e))
	      DofM'''' DofN''  DaofR'
	      DsubRy DsubRyx
	      (DsubRx' : {y} aasub ([x] R x y) M (Rx' y))
	      (DsubNx' : sub N M Nx')
	      (DsubRxy' : aosub Rx' Nx' LRyx)
	   <- ({y} aasub-fun (DsubRx' y) (DsubRx y) (DeqRx y : atom-eq (Rx' y) (Rx y)))
	   <- sub-fun DsubNx' DsubNx (DeqNx : term-eq Nx' Nx)
	   <- aosub-resp DeqRx DeqNx term-eq/i DsubRxy' (DsubRxy'' : aosub Rx Nx LRyx)
	   <- aosub-fun DsubRxy DsubRxy'' (Deq : term-eq LRxy LRyx).

%worlds (var | ovar | bind) (aosub-permute-e _ _ _ _ _ _ _ _ _ _).
%total {} (aosub-permute-e _ _ _ _ _ _ _ _ _ _).



tsub-permute-e : ({x} append (cons G1 x A) (G2 x) (G x))
		  -> ofe G1 M A
		  -> ({x} isvar x I -> ofe (G x) (N x) (B x))
		  -> ({x} isvar x I -> {y} isvar y J -> wfe (cons (G x) y (B x)) (C x y))
%%
		  -> ({y} tsub ([x] C x y) M (Cx y))
		  -> sub N M Nx
		  -> tsub ([y] Cx y) Nx Cxy
		  -> ({x} tsub ([y] C x y) (N x) (Cy x))
		  -> tsub ([x] Cy x) M Cyx
%%
		  -> tp-eq Cxy Cyx -> type.
%mode tsub-permute-e +X1 +X2 +X3 +X4 +X5 +X6 +X7 +X8 +X9 -X10.

-	: tsub-permute-e
	   (Dappend : {x} append (cons G1 x A) (G2 x) (G x))
	   (DofM : ofe G1 M A)
	   (DofN : ({x} isvar x I -> ofe (G x) (N x) (B x)))
	   (DwfC : ({x} isvar x I -> {y} isvar y J -> wfe (cons (G x) y (B x)) (C x y)))
	   (DsubCx : ({y} tsub ([x] C x y) M (Cx y)))
	   (DsubNx : sub N M Nx)
	   (DsubCxy : tsub ([y] Cx y) Nx Cxy)
	   (DsubCy : ({x} tsub ([y] C x y) (N x) (Cy x)))
	   (DsubCyx : tsub ([x] Cy x) M Cyx)
%%
	   Deq
	   %% get context orderings
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 wfe-context (DwfC x d y e) 
		    (ordered/cons
		       (Dbounded x d y e : bounded (G x) y)))
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 append-bounded (Dappend x) (Dbounded x d y e)
		    (bounded/cons
		       (Dbounded' x d y e : bounded G1 x)
		       (DprecedesXY x d y e : precedes x y)))
	   %% get simplifications
	   <- can-simp A (DsimpA : simp A S)
	   <- ({x} can-simp (B x) (DsimpB x : simp (B x) T))
	   <- ({y} {e:isvar y J}
		 context-append-simp-lookup Dappend ([x] [d] Dbounded x d y e) DsimpA
		    ([x] Dsimpctx x y : simpctx (G x) (G' x y))
		    ([x] [d] Dsbounded x d y e : sbounded (G' x y) y)
		    ([x] [d] Dlookup x d y e : slookup (G' x y) x S))
	   %% weaken and simplify DofM
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 weaken-ofe (Dbounded' x d y e) DofM _ 
		    (DofM' x d y e : ofe (cons G1 x A) M A))
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 weaken-ofe'' (Dappend x) (Dbounded x d y e) (DofM' x d y e) 
		    (DofM'' x d y e : ofe (G x) M A))
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 weaken-ofe (Dbounded x d y e) (DofM'' x d y e) _
		    (DofM''' x d y e : ofe (cons (G x) y (B x)) M A))
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 ofe-simp (simpctx/cons (DsimpB x) (Dsimpctx x y)) DsimpA (DofM''' x d y e)
		    (DofM'''' x d y e : ofes (scons (G' x y) y T) M S))
	   %% weaken and simplify DofN
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 weaken-ofe (Dbounded x d y e) (DofN x d) _
		    (DofN' x d y e : ofe (cons (G x) y (B x)) (N x) (B x)))
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		    ofe-simp (simpctx/cons (DsimpB x) (Dsimpctx x y)) (DsimpB x) (DofN' x d y e)
		       (DofN'' x d y e : ofes (scons (G' x y) y T) (N x) T))
	   %% simplify DofC
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		    wfe-simp (simpctx/cons (DsimpB x) (Dsimpctx x y)) (DwfC x d y e)
		       (DwfC' x d y e : wfes (scons (G' x y) y T) (C x y)))
	   %% go
	   <- tsub-permute-es
	      ([x] [d:isvar x I] [y] [e:isvar y J]
		 slookup/miss (Dlookup x d y e) (Dsbounded x d y e))
	      ([x] [d] [y] [e] slookup/hit (Dsbounded x d y e))
	      DofM'''' DofN''  DwfC'
	      DsubCy DsubCyx
	      (DsubCx' : {y} tsub ([x] C x y) M (Cx' y))
	      (DsubNx' : sub N M Nx')
	      (DsubCxy' : tsub Cx' Nx' Cyx)
	   <- ({y} tsub-fun (DsubCx' y) (DsubCx y) (DeqCx y : tp-eq (Cx' y) (Cx y)))
	   <- sub-fun DsubNx' DsubNx (DeqNx : term-eq Nx' Nx)
	   <- tsub-resp DeqCx DeqNx tp-eq/i DsubCxy' (DsubCxy'' : tsub Cx Nx Cyx)
	   <- tsub-fun DsubCxy DsubCxy'' (Deq : tp-eq Cxy Cyx).

%worlds (var | ovar | bind) (tsub-permute-e _ _ _ _ _ _ _ _ _ _).
%total {} (tsub-permute-e _ _ _ _ _ _ _ _ _ _).




%%%%%  Simple (ie, atom for atom) Substitution Permutations (Simply Typed, Explicit Context)  %%%%%

aasub-into-term : {N:atom -> term}
		   aasub ([x] R x) M Rx
%%
		   -> sub ([x] N (R x)) M (N Rx) -> type.
%mode aasub-into-term +X1 +X2 -X3.

aasub-into-atom : {Q:atom -> atom}
		   aasub ([x] R x) M Rx
%%
		   -> aasub ([x] Q (R x)) M (Q Rx) -> type.
%mode aasub-into-atom +X1 +X2 -X3.

aasub-into-tp	: {A:atom -> tp}
		   aasub ([x] R x) M Rx
%%
		   -> tsub ([x] A (R x)) M (A Rx) -> type.
%mode aasub-into-tp +X1 +X2 -X3.



-	: aasub-into-atom ([y] y)
	   (DsubRx : aasub ([x] R x) M Rx)
	   DsubRx.

-	: aasub-into-atom ([_] Q)
	   _
	   Daasub
	   <- aasub-absent Q M (Daasub : aasub ([_] Q) M Q).

-	: aasub-into-atom ([y] app (Q y) (N y))
	   (DsubRx : aasub ([x] R x) M Rx)
%%
	   (aasub/app DsubNyx DsubQyx)
	   <- aasub-into-atom Q DsubRx
	      (DsubQyx : aasub ([x] Q (R x)) M (Q Rx))
	   <- aasub-into-term N DsubRx
	      (DsubNyx : sub ([x] N (R x)) M (N Rx)).

-	: aasub-into-atom ([y] pi1 (Q y))
	   (DsubRx : aasub ([x] R x) M Rx)
%%
	   (aasub/pi1 DsubQyx)
	   <- aasub-into-atom Q DsubRx
	      (DsubQyx : aasub ([x] Q (R x)) M (Q Rx)).

-	: aasub-into-atom ([y] forall (A y))
	   (DsubRx : aasub ([x] R x) M Rx)
%%
	   (aasub/forall DsubAyx)
	   <- aasub-into-tp A DsubRx
	      (DsubAyx : tsub ([x] A (R x)) M (A Rx)).

-	: aasub-into-atom ([y] pi2 (Q y))
	   (DsubRx : aasub ([x] R x) M Rx)
%%
	   (aasub/pi2 DsubQyx)
	   <- aasub-into-atom Q DsubRx
	      (DsubQyx : aasub ([x] Q (R x)) M (Q Rx)).

-at	: aasub-into-term ([y] at (Q y))
	   (DsubRx : aasub ([x] R x) M Rx)
	   (sub/aa DsubQyx)
	   <- aasub-into-atom Q DsubRx
	      (DsubQyx : aasub ([x] Q (R x)) M (Q Rx)).

-lam	: aasub-into-term ([y] lam ([z] N y z))
	   (DsubRx : aasub ([x] R x) M Rx)
	   (sub/lam DsubNyx)
	   <- ({z} aasub-into-term ([y] N y z) DsubRx
		 (DsubNyx z : sub ([x] N (R x) z) M (N Rx z))).

-pair	: aasub-into-term ([y] pair (N1 y) (N2 y))
	   (DsubRx : aasub ([x] R x) M Rx)
	   (sub/pair DsubN2yx DsubN1yx)
	   <- aasub-into-term N1 DsubRx
	      (DsubN1yx : sub ([x] N1 (R x)) M (N1 Rx))
	   <- aasub-into-term N2 DsubRx
	      (DsubN2yx : sub ([x] N2 (R x)) M (N2 Rx)).


-t	: aasub-into-tp ([y] t)
	   _
	   tsub/t.

-pi	: aasub-into-tp ([y] pi (A y) ([z] B y z))
	   (DsubRx : aasub ([x] R x) M Rx)
	   (tsub/pi DsubNyx DsubAyx)
	   <- aasub-into-tp A DsubRx DsubAyx
	   <- ({z} aasub-into-tp ([y] B y z) DsubRx
		 (DsubNyx z : tsub ([x] B (R x) z) M (B Rx z))).

-sigma	: aasub-into-tp ([y] sigma (A y) ([z] B y z))
	   (DsubRx : aasub ([x] R x) M Rx)
	   (tsub/sigma DsubNyx DsubAyx)
	   <- aasub-into-tp A DsubRx DsubAyx
	   <- ({z} aasub-into-tp ([y] B y z) DsubRx
		 (DsubNyx z : tsub ([x] B (R x) z) M (B Rx z))).

-sing	: aasub-into-tp ([y] sing (Q y))
	   (DsubRx : aasub ([x] R x) M Rx)
	   (tsub/singa DsubQyx)
	   <- aasub-into-atom Q DsubRx
	      (DsubQyx : aasub ([x] Q (R x)) M (Q Rx)).

%worlds (var | ovar | bind) (aasub-into-atom _ _ _) (aasub-into-term _ _ _) (aasub-into-tp _ _ _).
%total (R N A) (aasub-into-atom R _ _) (aasub-into-term N _ _) (aasub-into-tp A _ _).



aosub-into-aasub : aosub ([x] R x) M LRx
		    -> aasub ([y] Q y) LRx Qy
%%
		    -> aasub ([x] Q (R x)) M Qy -> type.
%mode aosub-into-aasub +X1 +X2 -X3.

aosub-into-aosub : aosub ([x] R x) M LRx
		    -> aosub ([y] Q y) LRx LQy
%%
		    -> aosub ([x] Q (R x)) M LQy -> type.
%mode aosub-into-aosub +X1 +X2 -X3.

aosub-into-sub : aosub ([x] R x) M LRx
		  -> sub ([y] N y) LRx Ny
%%
		  -> sub ([x] N (R x)) M Ny -> type.
%mode aosub-into-sub +X1 +X2 -X3.

aosub-into-tsub : aosub ([x] R x) M LRx
		  -> tsub ([y] A y) LRx Ay
%%
		  -> tsub ([x] A (R x)) M Ay -> type.
%mode aosub-into-tsub +X1 +X2 -X3.

-closed	: aosub-into-aasub
	   (DsubRx : aosub ([x] R x) M LRx)
	   aasub/closed
%%
	   Daasub
	   <- aasub-absent Q M (Daasub : aasub ([_] Q) M Q).

-forall	: aosub-into-aasub
	   (DsubRx : aosub ([x] R x) M LRx)
	   (aasub/forall
	      (DsubAy : tsub ([y] A y) LRx Ay))
%%
	   (aasub/forall DsubAyx)
	   <- aosub-into-tsub DsubRx DsubAy
	      (DsubAyx : tsub ([x] A (R x)) M Ay).

-app	: aosub-into-aasub
	   (DsubRx : aosub ([x] R x) M LRx)
	   (aasub/app
	      (DsubNy : sub ([y] N y) LRx Ny)
	      (DsubQy : aasub ([y] Q y) LRx Qy))
%%
	   (aasub/app DsubNyx DsubQyx)
	   <- aosub-into-aasub DsubRx DsubQy
	      (DsubQyx : aasub ([x] Q (R x)) M Qy)
	   <- aosub-into-sub DsubRx DsubNy
	      (DsubNyx : sub ([x] N (R x)) M Ny).

-pi1	: aosub-into-aasub
	   (DsubRx : aosub ([x] R x) M LRx)
	   (aasub/pi1
	      (DsubQy : aasub ([y] Q y) LRx Qy))
%%
	   (aasub/pi1 DsubQyx)
	   <- aosub-into-aasub DsubRx DsubQy
	      (DsubQyx : aasub ([x] Q (R x)) M Qy).

-pi2	: aosub-into-aasub
	   (DsubRx : aosub ([x] R x) M LRx)
	   (aasub/pi2
	      (DsubQy : aasub ([y] Q y) LRx Qy))
%%
	   (aasub/pi2 DsubQyx)
	   <- aosub-into-aasub DsubRx DsubQy
	      (DsubQyx : aasub ([x] Q (R x)) M Qy).


-var	: aosub-into-aosub
	   (DsubRx : aosub ([x] R x) M LRx)
	   aosub/var
%%
	   DsubRx.

-app	: aosub-into-aosub
	   (DsubRx : aosub ([x] R x) M LRx)
	   (aosub/app
	      (DsubPz : sub ([z] P z) Ny Pz)
	      (DsubNy : sub ([y] N y) LRx Ny)
	      (DsubQy : aosub ([y] Q y) LRx (lam ([z] P z))))
%%
	   (aosub/app
	      DsubPz
	      DsubNyx
	      DsubQyx)
	   <- aosub-into-aosub DsubRx DsubQy
	      (DsubQyx : aosub ([x] Q (R x)) M (lam ([z] P z)))
	   <- aosub-into-sub DsubRx DsubNy
	      (DsubNyx : sub ([x] N (R x)) M Ny).

-pi1	: aosub-into-aosub
	   (DsubRx : aosub ([x] R x) M LRx)
	   (aosub/pi1
	      (DsubQy : aosub ([y] Q y) LRx (pair P1 P2)))
%%
	   (aosub/pi1 DsubQyx)
	   <- aosub-into-aosub DsubRx DsubQy
	      (DsubQyx : aosub ([x] Q (R x)) M (pair P1 P2)).

-pi2	: aosub-into-aosub
	   (DsubRx : aosub ([x] R x) M LRx)
	   (aosub/pi2
	      (DsubQy : aosub ([y] Q y) LRx (pair P1 P2)))
%%
	   (aosub/pi2 DsubQyx)
	   <- aosub-into-aosub DsubRx DsubQy
	      (DsubQyx : aosub ([x] Q (R x)) M (pair P1 P2)).


-aa	: aosub-into-sub
	   (DsubRx : aosub ([x] R x) M LRx)
	   (sub/aa
	      (DsubQy : aasub ([y] Q y) LRx Qy))
%%
	   (sub/aa DsubQyx)
	   <- aosub-into-aasub DsubRx DsubQy
	      (DsubQyx : aasub ([x] Q (R x)) M Qy).

-ao	: aosub-into-sub
	   (DsubRx : aosub ([x] R x) M LRx)
	   (sub/ao
	      (DsubQy : aosub ([y] Q y) LRx LQy))
%%
	   (sub/ao DsubQyx)
	   <- aosub-into-aosub DsubRx DsubQy
	      (DsubQyx : aosub ([x] Q (R x)) M LQy).

-lam	: aosub-into-sub
	   (DsubRx : aosub ([x] R x) M LRx)
	   (sub/lam
	      ([z] DsubNy z : sub ([y] N y z) LRx (Ny z)))
%%
	   (sub/lam DsubNyx)
	   <- ({z} aosub-into-sub DsubRx (DsubNy z)
		 (DsubNyx z : sub ([x] N (R x) z) M (Ny z))).

-pair	: aosub-into-sub
	   (DsubRx : aosub ([x] R x) M LRx)
	   (sub/pair
	      (DsubN2y : sub ([y] N2 y) LRx N2y)
	      (DsubN1y : sub ([y] N1 y) LRx N1y))
%%
	   (sub/pair DsubN2yx DsubN1yx)
	   <- aosub-into-sub DsubRx DsubN1y
	      (DsubN1yx : sub ([x] N1 (R x)) M N1y)
	   <- aosub-into-sub DsubRx DsubN2y
	      (DsubN2yx : sub ([x] N2 (R x)) M N2y).


-t	: aosub-into-tsub _ tsub/t tsub/t.

-pi	: aosub-into-tsub
	   (DsubRx : aosub ([x] R x) M LRx)
	   (tsub/pi
	      ([z] DsubBy z : tsub ([y] B y z) LRx (By z))
	      (DsubAy : tsub A LRx Ay))
%%
	   (tsub/pi DsubByx DsubAyx)
	   <- aosub-into-tsub DsubRx DsubAy
	      (DsubAyx : tsub ([x] A (R x)) M Ay)
	   <- ({z} aosub-into-tsub DsubRx (DsubBy z)
		 (DsubByx z : tsub ([x] B (R x) z) M (By z))).

-sigma	: aosub-into-tsub
	   (DsubRx : aosub ([x] R x) M LRx)
	   (tsub/sigma
	      ([z] DsubBy z : tsub ([y] B y z) LRx (By z))
	      (DsubAy : tsub A LRx Ay))
%%
	   (tsub/sigma DsubByx DsubAyx)
	   <- aosub-into-tsub DsubRx DsubAy
	      (DsubAyx : tsub ([x] A (R x)) M Ay)
	   <- ({z} aosub-into-tsub DsubRx (DsubBy z)
		 (DsubByx z : tsub ([x] B (R x) z) M (By z))).

-aa	: aosub-into-tsub
	   (DsubRx : aosub ([x] R x) M LRx)
	   (tsub/singa
	      (DsubQy : aasub ([y] Q y) LRx Qy))
%%
	   (tsub/singa DsubQyx)
	   <- aosub-into-aasub DsubRx DsubQy
	      (DsubQyx : aasub ([x] Q (R x)) M Qy).

-ao	: aosub-into-tsub
	   (DsubRx : aosub ([x] R x) M LRx)
	   (tsub/singo
	      (DsubQy : aosub ([y] Q y) LRx (at LQy)))
%%
	   (tsub/singo DsubQyx)
	   <- aosub-into-aosub DsubRx DsubQy
	      (DsubQyx : aosub ([x] Q (R x)) M (at LQy)).

%worlds (var | ovar | bind) (aosub-into-aasub _ _ _) (aosub-into-aosub _ _ _) (aosub-into-sub _ _ _) (aosub-into-tsub _ _ _).
%total (D1 D2 D3 D4) (aosub-into-aasub _ D1 _) (aosub-into-aosub _ D2 _) (aosub-into-sub _ D3 _) (aosub-into-tsub _ D4 _).



%% hd(R) = z (ie, something other than x)
ssub-z-permute-es : ({x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
		     -> ({x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
		     -> ({x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
		     -> ({x} isvar x I -> {y} isvar y J -> aofes (G x y) (R x) T)
		     -> ({x} isvar x I -> {y} isvar y J -> ofes (G x y) (O x y) U)
%%
		     -> ({y} sub ([x] O x y) M (Ox y))
		     -> aasub ([x] R x) M Rx
%%
		     -> sub ([x] O x (R x)) M (Ox Rx) -> type.
%mode ssub-z-permute-es +X1 +X2 +X3 +X4 +X5 +X6 +X7 -X8.


%% hd(R) = x
ssub-x-permute-es : ({x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
		     -> ({x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
		     -> ({x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
		     -> ({x} isvar x I -> {y} isvar y J -> aofes (G x y) (R x) T)
		     -> ({x} isvar x I -> {y} isvar y J -> ofes (G x y) (O x y) U)
%%
		     -> ({y} sub ([x] O x y) M (Ox y))
		     -> aosub ([x] R x) M LRx
		     -> sub ([y] Ox y) LRx Oxy
%%
		     -> sub ([x] O x (R x)) M Oxy -> type.
%mode ssub-x-permute-es +X1 +X2 +X3 +X4 +X5 +X6 +X7 +X8 -X9.



%% hd(R) = z, hd(Q) = z
ssub-zz-permute-es : ({x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
		     -> ({x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
		     -> ({x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
		     -> ({x} isvar x I -> {y} isvar y J -> aofes (G x y) (R x) T)
		     -> ({x} isvar x I -> {y} isvar y J -> aofes (G x y) (Q x y) U)
%%
		     -> ({y} aasub ([x] Q x y) M (Qx y))
		     -> aasub ([x] R x) M Rx
%%
		     -> aasub ([x] Q x (R x)) M (Qx Rx) -> type.
%mode ssub-zz-permute-es +X1 +X2 +X3 +X4 +X5 +X6 +X7 -X8.



%% hd(R) = z, hd(Q) = x
ssub-zx-permute-es : ({x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
		     -> ({x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
		     -> ({x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
		     -> ({x} isvar x I -> {y} isvar y J -> aofes (G x y) (R x) T)
		     -> ({x} isvar x I -> {y} isvar y J -> aofes (G x y) (Q x y) U)
%%
		     -> ({y} aosub ([x] Q x y) M (LQx y))
		     -> aasub ([x] R x) M Rx
%%
		     -> aosub ([x] Q x (R x)) M (LQx Rx) -> type.
%mode ssub-zx-permute-es +X1 +X2 +X3 +X4 +X5 +X6 +X7 -X8.


%% hd(R) = x, hd(Q) = z
ssub-xz-permute-es : ({x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
		     -> ({x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
		     -> ({x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
		     -> ({x} isvar x I -> {y} isvar y J -> aofes (G x y) (R x) T)
		     -> ({x} isvar x I -> {y} isvar y J -> aofes (G x y) (Q x y) U)
%%
		     -> ({y} aasub ([x] Q x y) M (Qx y))
		     -> aosub ([x] R x) M LRx
		     -> aasub ([y] Qx y) LRx Qxy
%%
		     -> aasub ([x] Q x (R x)) M Qxy -> type.
%mode ssub-xz-permute-es +X1 +X2 +X3 +X4 +X5 +X6 +X7 +X8 -X9.

%% hd(R) = x, hd(Q) = y
ssub-xy-permute-es : ({x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
		     -> ({x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
		     -> ({x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
		     -> ({x} isvar x I -> {y} isvar y J -> aofes (G x y) (R x) T)
		     -> ({x} isvar x I -> {y} isvar y J -> aofes (G x y) (Q x y) U)
%%
		     -> ({y} aasub ([x] Q x y) M (Qx y))
		     -> aosub ([x] R x) M LRx
		     -> aosub ([y] Qx y) LRx LQxy
%%
		     -> aosub ([x] Q x (R x)) M LQxy -> type.
%mode ssub-xy-permute-es +X1 +X2 +X3 +X4 +X5 +X6 +X7 +X8 -X9.

%% hd(R) = x, hd(Q) = x
ssub-xx-permute-es : ({x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
		     -> ({x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
		     -> ({x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
		     -> ({x} isvar x I -> {y} isvar y J -> aofes (G x y) (R x) T)
		     -> ({x} isvar x I -> {y} isvar y J -> aofes (G x y) (Q x y) U)
%%
		     -> ({y} aosub ([x] Q x y) M (LQx y))
		     -> aosub ([x] R x) M LRx
		     -> sub ([y] LQx y) LRx LQxy
%%
		     -> aosub ([x] Q x (R x)) M LQxy -> type.
%mode ssub-xx-permute-es +X1 +X2 +X3 +X4 +X5 +X6 +X7 +X8 -X9.


%% hd(R) = z
stsub-z-permute-es : ({x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
		      -> ({x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
		      -> ({x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
		      -> ({x} isvar x I -> {y} isvar y J -> aofes (G x y) (R x) T)
		      -> ({x} isvar x I -> {y} isvar y J -> wfes (G x y) (A x y))
%%
		      -> ({y} tsub ([x] A x y) M (Ax y))
		      -> aasub ([x] R x) M Rx
%%
		      -> tsub ([x] A x (R x)) M (Ax Rx) -> type.
%mode stsub-z-permute-es +X1 +X2 +X3 +X4 +X5 +X6 +X7 -X8.


%% hd(R) = x
stsub-x-permute-es : ({x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
		      -> ({x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
		      -> ({x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
		      -> ({x} isvar x I -> {y} isvar y J -> aofes (G x y) (R x) T)
		      -> ({x} isvar x I -> {y} isvar y J -> wfes (G x y) (A x y))
%%
		      -> ({y} tsub ([x] A x y) M (Ax y))
		      -> aosub ([x] R x) M LRx
		      -> tsub ([y] Ax y) LRx Axy
%%
		      -> tsub ([x] A x (R x)) M Axy -> type.
%mode stsub-x-permute-es +X1 +X2 +X3 +X4 +X5 +X6 +X7 +X8 -X9.

-aa	: ssub-z-permute-es
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofR : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (R x) T)
	   ([x] [d] [y] [e]
	      (ofes/at (DofQ x d y e : aofes (G x y) (Q x y) st))
	      : ofes (G x y) (at (Q x y)) st)
%%
	   ([y] sub/aa (DsubQx y : aasub ([x] Q x y) M (Qx y)))
	   (DsubRx : aasub R M Rx)
%%
	   (sub/aa DsubQyx)
	   <- ssub-zz-permute-es DlookupX DlookupY DofM DofR DofQ
	      DsubQx DsubRx
	      (DsubQyx : aasub ([x] Q x (R x)) M (Qx Rx)).

-ao	: ssub-z-permute-es
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofR : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (R x) T)
	   ([x] [d] [y] [e]
	      (ofes/at (DofQ x d y e : aofes (G x y) (Q x y) st))
	      : ofes (G x y) (at (Q x y)) st)
%%
	   ([y] sub/ao (DsubQx y : aosub ([x] Q x y) M (LQx y)))
	   (DsubRx : aasub R M Rx)
%%
	   (sub/ao DsubQyx)
	   <- ssub-zx-permute-es DlookupX DlookupY DofM DofR DofQ
	      DsubQx DsubRx
	      (DsubQyx : aosub ([x] Q x (R x)) M (LQx Rx)).

-lam	: ssub-z-permute-es
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofR : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (R x) T)
	   ([x] [d] [y] [e]
	      (ofes/lam (DofO x d y e : {z} isvar z K -> ofes (scons (G x y) z U1) (O x y z) U2))
	      : ofes (G x y) (lam ([z] O x y z)) (spi U1 U2))
%%
	   ([y] sub/lam
	      ([z] DsubOx y z : sub ([x] O x y z) M (Ox y z)))
	   (DsubRx : aasub R M Rx)
%%
	   (sub/lam DsubOyx)
	   %% first get some typing derivations
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J}
		 {z} {f:isvar z K}
		 ofes-context (DofO x d y e z f)
		    (sordered/cons
		       (Dbounded x d y e z f : sbounded (G x y) z)
		       : sordered (scons (G x y) z U1)))
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J}
		 {z} {f:isvar z K}
		 weaken-ofes (Dbounded x d y e z f) (DofM x d y e) _ 
		    (DofM' x d y e z f : ofes (scons (G x y) z U1) M S))
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J}
		 {z} {f:isvar z K}
		 weaken-aofes (Dbounded x d y e z f) (DofR x d y e) _ 
		    (DofR' x d y e z f : aofes (scons (G x y) z U1) (R x) T))
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J}
		 {z} {f:isvar z K}
		 weaken-slookup (Dbounded x d y e z f) (DlookupX x d y e) _
		    (DlookupX' x d y e z f : slookup (scons (G x y) z U1) x S))
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J}
		 {z} {f:isvar z K}
		 weaken-slookup (Dbounded x d y e z f) (DlookupY x d y e) _
		    (DlookupY' x d y e z f : slookup (scons (G x y) z U1) y T))
	   %% now get to work
	   <- ({z} {f:isvar z K}
		 ssub-z-permute-es ([x] [d] [y] [e] DlookupX' x d y e z f) ([x] [d] [y] [e] DlookupY' x d y e z f) ([x] [d] [y] [e] DofM' x d y e z f) ([x] [d] [y] [e] DofR' x d y e z f) ([x] [d] [y] [e] DofO x d y e z f)
		    ([y] DsubOx y z) DsubRx
		    (DsubOyx z : sub ([x] O x (R x) z) M (Ox Rx z))).

-pair	: ssub-z-permute-es
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofR : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (R x) T)
	   ([x] [d] [y] [e]
	      (ofes/pair
		 (DofO2 x d y e : ofes (G x y) (O2 x y) U2)
		 (DofO1 x d y e : ofes (G x y) (O1 x y) U1))
	      : ofes (G x y) (pair (O1 x y) (O2 x y)) (ssigma U1 U2))
%%
	   ([y] sub/pair
	      (DsubO2x y : sub ([x] O2 x y) M (O2x y))
	      (DsubO1x y : sub ([x] O1 x y) M (O1x y)))
	   (DsubRx : aasub R M Rx)
%%
	   (sub/pair DsubO2yx DsubO1yx)
	   <- ssub-z-permute-es DlookupX DlookupY DofM DofR DofO1
	      DsubO1x DsubRx
	      (DsubO1yx : sub ([x] O1 x (R x)) M (O1x Rx))
	   <- ssub-z-permute-es DlookupX DlookupY DofM DofR DofO2
	      DsubO2x DsubRx
	      (DsubO2yx : sub ([x] O2 x (R x)) M (O2x Rx)).


-aa-aa	: ssub-x-permute-es
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofR : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (R x) T)
	   ([x] [d] [y] [e]
	      (ofes/at (DofQ x d y e : aofes (G x y) (Q x y) st))
	      : ofes (G x y) (at (Q x y)) st)
%%
	   ([y] sub/aa (DsubQx y : aasub ([x] Q x y) M (Qx y)))
	   (DsubRx : aosub R M LRx)
	   (sub/aa (DsubQxy : aasub ([y] Qx y) LRx Qxy)
	      : sub ([y] at (Qx y)) LRx (at Qxy))
%%
	   (sub/aa DsubQyx)
	   <- ssub-xz-permute-es DlookupX DlookupY DofM DofR DofQ
	      DsubQx DsubRx DsubQxy
	      (DsubQyx : aasub ([x] Q x (R x)) M Qxy).

-aa-ao	: ssub-x-permute-es
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofR : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (R x) T)
	   ([x] [d] [y] [e]
	      (ofes/at (DofQ x d y e : aofes (G x y) (Q x y) st))
	      : ofes (G x y) (at (Q x y)) st)
%%
	   ([y] sub/aa (DsubQx y : aasub ([x] Q x y) M (Qx y)))
	   (DsubRx : aosub R M LRx)
	   (sub/ao (DsubQxy : aosub ([y] Qx y) LRx LQxy)
	      : sub ([y] at (Qx y)) LRx LQxy)
%%
	   (sub/ao DsubQyx)
	   <- ssub-xy-permute-es DlookupX DlookupY DofM DofR DofQ
	      DsubQx DsubRx DsubQxy
	      (DsubQyx : aosub ([x] Q x (R x)) M LQxy).

-ao	: ssub-x-permute-es
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofR : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (R x) T)
	   ([x] [d] [y] [e]
	      (ofes/at (DofQ x d y e : aofes (G x y) (Q x y) st))
	      : ofes (G x y) (at (Q x y)) st)
%%
	   ([y] sub/ao (DsubQx y : aosub ([x] Q x y) M (LQx y)))
	   (DsubRx : aosub R M LRx)
	   (DsubQxy : sub ([y] LQx y) LRx LQxy)
%%
	   (sub/ao DsubQyx)
	   <- ssub-xx-permute-es DlookupX DlookupY DofM DofR DofQ
	      DsubQx DsubRx DsubQxy
	      (DsubQyx : aosub ([x] Q x (R x)) M LQxy).

-lam	: ssub-x-permute-es
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofR : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (R x) T)
	   ([x] [d] [y] [e]
	      (ofes/lam (DofO x d y e : {z} isvar z K -> ofes (scons (G x y) z U1) (O x y z) U2))
	      : ofes (G x y) (lam ([z] O x y z)) (spi U1 U2))
%%
	   ([y] sub/lam
	      ([z] DsubOx y z : sub ([x] O x y z) M (Ox y z)))
	   (DsubRx : aosub R M LRx)
	   (sub/lam
	      ([z] DsubOxy z : sub ([y] Ox y z) LRx (Oxy z)))
%%
	   (sub/lam DsubOyx)
	   %% first get some typing derivations
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J}
		 {z} {f:isvar z K}
		 ofes-context (DofO x d y e z f)
		    (sordered/cons
		       (Dbounded x d y e z f : sbounded (G x y) z)
		       : sordered (scons (G x y) z U1)))
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J}
		 {z} {f:isvar z K}
		 weaken-ofes (Dbounded x d y e z f) (DofM x d y e) _ 
		    (DofM' x d y e z f : ofes (scons (G x y) z U1) M S))
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J}
		 {z} {f:isvar z K}
		 weaken-aofes (Dbounded x d y e z f) (DofR x d y e) _ 
		    (DofR' x d y e z f : aofes (scons (G x y) z U1) (R x) T))
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J}
		 {z} {f:isvar z K}
		 weaken-slookup (Dbounded x d y e z f) (DlookupX x d y e) _
		    (DlookupX' x d y e z f : slookup (scons (G x y) z U1) x S))
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J}
		 {z} {f:isvar z K}
		 weaken-slookup (Dbounded x d y e z f) (DlookupY x d y e) _
		    (DlookupY' x d y e z f : slookup (scons (G x y) z U1) y T))
	   %% now get to work
	   <- ({z} {f:isvar z K}
		 ssub-x-permute-es ([x] [d] [y] [e] DlookupX' x d y e z f) ([x] [d] [y] [e] DlookupY' x d y e z f) ([x] [d] [y] [e] DofM' x d y e z f) ([x] [d] [y] [e] DofR' x d y e z f) ([x] [d] [y] [e] DofO x d y e z f)
		    ([y] DsubOx y z) DsubRx (DsubOxy z)
		    (DsubOyx z : sub ([x] O x (R x) z) M (Oxy z))).

-pair	: ssub-x-permute-es
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofR : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (R x) T)
	   ([x] [d] [y] [e]
	      (ofes/pair
		 (DofO2 x d y e : ofes (G x y) (O2 x y) U2)
		 (DofO1 x d y e : ofes (G x y) (O1 x y) U1))
	      : ofes (G x y) (pair (O1 x y) (O2 x y)) (ssigma U1 U2))
%%
	   ([y] sub/pair
	      (DsubO2x y : sub ([x] O2 x y) M (O2x y))
	      (DsubO1x y : sub ([x] O1 x y) M (O1x y)))
	   (DsubRx : aosub R M LRx)
	   (sub/pair
	      (DsubO2xy : sub ([y] O2x y) LRx O2xy)
	      (DsubO1xy : sub ([y] O1x y) LRx O1xy))
%%
	   (sub/pair DsubO2yx DsubO1yx)
	   <- ssub-x-permute-es DlookupX DlookupY DofM DofR DofO1
	      DsubO1x DsubRx DsubO1xy
	      (DsubO1yx : sub ([x] O1 x (R x)) M O1xy)
	   <- ssub-x-permute-es DlookupX DlookupY DofM DofR DofO2
	      DsubO2x DsubRx DsubO2xy
	      (DsubO2yx : sub ([x] O2 x (R x)) M O2xy).


-closed	: ssub-zz-permute-es
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofR : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (R x) T)
	   (DofQ : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (Q y) U)
%%
	   ([_] aasub/closed)
	   (DsubRx : aasub ([x] R x) M Rx)
%%
	   DsubQyx
	   <- aasub-into-atom Q DsubRx
	      (DsubQyx : aasub ([x] Q (R x)) M (Q Rx)).

-forall	: ssub-zz-permute-es
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofR : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (R x) T)
	   (DofQuant : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (forall (A x y)) U1)
%%
	   ([y] aasub/forall
	      (DsubAx y : tsub ([x] A x y) M (Ax y)))
	   (DsubRx : aasub ([x] R x) M Rx)
%%
	   (aasub/forall DsubAyx)
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J} 
		 aofes-invert-forall (DofQuant x d y e)
		 (DofA x d y e : wfes (G x y) (A x y)))
	   <- stsub-z-permute-es DlookupX DlookupY DofM DofR DofA
	      DsubAx DsubRx
	      (DsubAyx : tsub ([x] A x (R x)) M (Ax Rx)).

-app	: ssub-zz-permute-es
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofR : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (R x) T)
	   (DofApp : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (app (Q x y) (N x y)) U2)
%%
	   ([y] aasub/app
	      (DsubNx y : sub ([x] N x y) M (Nx y))
	      (DsubQx y : aasub ([x] Q x y) M (Qx y)))
	   (DsubRx : aasub ([x] R x) M Rx)
%%
	   (aasub/app DsubNyx DsubQyx)
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J} 
		 aofes-invert-app (DofApp x d y e)
		    (DofQ x d y e : aofes (G x y) (Q x y) (spi U1 U2))
		    (DofN x d y e : ofes (G x y) (N x y) U1))
	   <- ssub-zz-permute-es DlookupX DlookupY DofM DofR DofQ
	      DsubQx DsubRx
	      (DsubQyx : aasub ([x] Q x (R x)) M (Qx Rx))
	   <- ssub-z-permute-es DlookupX DlookupY DofM DofR DofN
	      DsubNx DsubRx
	      (DsubNyx : sub ([x] N x (R x)) M (Nx Rx)).

-pi1	: ssub-zz-permute-es
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofR : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (R x) T)
	   (DofPi : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (pi1 (Q x y)) U1)
%%
	   ([y] aasub/pi1 
	      (DsubQx y : aasub ([x] Q x y) M (Qx y)))
	   (DsubRx : aasub ([x] R x) M Rx)
%%
	   (aasub/pi1 DsubQyx)
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J} 
		 aofes-invert-pi1 (DofPi x d y e)
		    (DofQ x d y e : aofes (G x y) (Q x y) (ssigma U1 U2)))
	   <- ssub-zz-permute-es DlookupX DlookupY DofM DofR DofQ
	      DsubQx DsubRx
	      (DsubQyx : aasub ([x] Q x (R x)) M (Qx Rx)).

-pi2	: ssub-zz-permute-es
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofR : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (R x) T)
	   (DofPi : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (pi2 (Q x y)) U2)
%%
	   ([y] aasub/pi2 
	      (DsubQx y : aasub ([x] Q x y) M (Qx y)))
	   (DsubRx : aasub ([x] R x) M Rx)
%%
	   (aasub/pi2 DsubQyx)
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J} 
		 aofes-invert-pi2 (DofPi x d y e)
		    (DofQ x d y e : aofes (G x y) (Q x y) (ssigma U1 U2)))
	   <- ssub-zz-permute-es DlookupX DlookupY DofM DofR DofQ
	      DsubQx DsubRx
	      (DsubQyx : aasub ([x] Q x (R x)) M (Qx Rx)).


-var	: ssub-zx-permute-es
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofR : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (R x) T)
	   _
%%
	   ([_] aosub/var)
	   (DsubRx : aasub ([x] R x) M Rx)
%%
	   (aosub/var).

-forall	: ssub-xz-permute-es
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofR : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (R x) T)
	   (DofQuant : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (forall (A x y)) U1)
%%
	   ([y] aasub/forall 
	      (DsubAx y : tsub ([x] A x y) M (Ax y)))
	   (DsubRx : aosub ([x] R x) M LRx)
	   (aasub/forall
	      (DsubAxy : tsub ([y] Ax y) LRx Axy))
%%
	   (aasub/forall DsubAyx)
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J} 
		 aofes-invert-forall (DofQuant x d y e)
		    (DofA x d y e : wfes (G x y) (A x y)))
	   <- stsub-x-permute-es DlookupX DlookupY DofM DofR DofA
	      DsubAx DsubRx DsubAxy
	      (DsubAyx : tsub ([x] A x (R x)) M Axy).

-allcl	: ssub-xz-permute-es
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofR : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (R x) T)
	   (DofQuant : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (forall (A x y)) U1)
%%
	   ([y] aasub/forall 
	      (DsubAx y : tsub ([x] A x y) M Ax))
	   (DsubRx : aosub ([x] R x) M LRx)
	   aasub/closed
%%
	   (aasub/forall DsubAyx)
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J} 
		 aofes-invert-forall (DofQuant x d y e)
		    (DofA x d y e : wfes (G x y) (A x y)))
	   <- tsub-absent Ax LRx
	      (DsubAxy : tsub ([_] Ax) LRx Ax)
	   <- stsub-x-permute-es DlookupX DlookupY DofM DofR DofA
	      DsubAx DsubRx DsubAxy
	      (DsubAyx : tsub ([x] A x (R x)) M Ax).

-app	: ssub-zx-permute-es
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofR : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (R x) T)
	   (DofApp : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (app (Q x y) (N x y)) U2)
%%
	   ([y] aosub/app
	      (DsubPz y : sub ([z] P y z) (Nx y) (Pz y))
	      (DsubNx y : sub ([x] N x y) M (Nx y))
	      (DsubQx y : aosub ([x] Q x y) M (lam ([z] P y z))))
	   (DsubRx : aasub ([x] R x) M Rx)
%%
	   (aosub/app (DsubPz Rx) DsubNyx DsubQyx)
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J} 
		 aofes-invert-app (DofApp x d y e)
		    (DofQ x d y e : aofes (G x y) (Q x y) (spi U1 U2))
		    (DofN x d y e : ofes (G x y) (N x y) U1))
	   <- ssub-zx-permute-es DlookupX DlookupY DofM DofR DofQ
	      DsubQx DsubRx
	      (DsubQyx : aosub ([x] Q x (R x)) M (lam ([z] P Rx z)))
	   <- ssub-z-permute-es DlookupX DlookupY DofM DofR DofN
	      DsubNx DsubRx
	      (DsubNyx : sub ([x] N x (R x)) M (Nx Rx)).

-pi1	: ssub-zx-permute-es
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofR : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (R x) T)
	   (DofPi : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (pi1 (Q x y)) U1)
%%
	   ([y] aosub/pi1
	      (DsubQx y : aosub ([x] Q x y) M (pair (P1 y) (P2 y))))
	   (DsubRx : aasub ([x] R x) M Rx)
%%
	   (aosub/pi1 DsubQyx)
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J} 
		 aofes-invert-pi1 (DofPi x d y e)
		    (DofQ x d y e : aofes (G x y) (Q x y) (ssigma U1 U2)))
	   <- ssub-zx-permute-es DlookupX DlookupY DofM DofR DofQ
	      DsubQx DsubRx
	      (DsubQyx : aosub ([x] Q x (R x)) M (pair (P1 Rx) (P2 Rx))).

-pi2	: ssub-zx-permute-es
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofR : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (R x) T)
	   (DofPi : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (pi2 (Q x y)) U2)
%%
	   ([y] aosub/pi2
	      (DsubQx y : aosub ([x] Q x y) M (pair (P1 y) (P2 y))))
	   (DsubRx : aasub ([x] R x) M Rx)
%%
	   (aosub/pi2 DsubQyx)
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J} 
		 aofes-invert-pi2 (DofPi x d y e)
		    (DofQ x d y e : aofes (G x y) (Q x y) (ssigma U1 U2)))
	   <- ssub-zx-permute-es DlookupX DlookupY DofM DofR DofQ
	      DsubQx DsubRx
	      (DsubQyx : aosub ([x] Q x (R x)) M (pair (P1 Rx) (P2 Rx))).


-closed	: ssub-xz-permute-es
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofR : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (R x) T)
	   (DofQ : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (Q y) U)
%%
	   ([_] aasub/closed)
	   (DsubRx : aosub ([x] R x) M LRx)
	   (DsubQxy : aasub ([y] Q y) LRx Qy)
%%
	   DsubQyx
	   <- aosub-into-aasub DsubRx DsubQxy
	      (DsubQyx : aasub ([x] Q (R x)) M Qy).

-app	: ssub-xz-permute-es
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofR : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (R x) T)
	   (DofApp : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (app (Q x y) (N x y)) U2)
%%
	   ([y] aasub/app
	      (DsubNx y : sub ([x] N x y) M (Nx y))
	      (DsubQx y : aasub ([x] Q x y) M (Qx y)))
	   (DsubRx : aosub ([x] R x) M LRx)
	   (aasub/app
	      (DsubNxy : sub ([y] Nx y) LRx Nxy)
	      (DsubQxy : aasub ([y] Qx y) LRx Qxy))
%%
	   (aasub/app DsubNyx DsubQyx)
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J} 
		 aofes-invert-app (DofApp x d y e)
		    (DofQ x d y e : aofes (G x y) (Q x y) (spi U1 U2))
		    (DofN x d y e : ofes (G x y) (N x y) U1))
	   <- ssub-xz-permute-es DlookupX DlookupY DofM DofR DofQ
	      DsubQx DsubRx DsubQxy
	      (DsubQyx : aasub ([x] Q x (R x)) M Qxy)
	   <- ssub-x-permute-es DlookupX DlookupY DofM DofR DofN
	      DsubNx DsubRx DsubNxy
	      (DsubNyx : sub ([x] N x (R x)) M Nxy).

-app-cl	: ssub-xz-permute-es
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofR : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (R x) T)
	   (DofApp : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (app (Q x y) (N x y)) U2)
%%
	   ([y] aasub/app
	      (DsubNx y : sub ([x] N x y) M Nx)
	      (DsubQx y : aasub ([x] Q x y) M Qx))
	   (DsubRx : aosub ([x] R x) M LRx)
	   aasub/closed
%%
	   (aasub/app DsubNyx DsubQyx)
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J} 
		 aofes-invert-app (DofApp x d y e)
		    (DofQ x d y e : aofes (G x y) (Q x y) (spi U1 U2))
		    (DofN x d y e : ofes (G x y) (N x y) U1))
	   <- ssub-xz-permute-es DlookupX DlookupY DofM DofR DofQ
	      DsubQx DsubRx aasub/closed
	      (DsubQyx : aasub ([x] Q x (R x)) M Qx)
	   <- sub-absent Nx LRx (DsubNxy : sub ([y] Nx) LRx Nx)
	   <- ssub-x-permute-es DlookupX DlookupY DofM DofR DofN
	      DsubNx DsubRx DsubNxy
	      (DsubNyx : sub ([x] N x (R x)) M Nx).

-pi1	: ssub-xz-permute-es
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofR : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (R x) T)
	   (DofPi : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (pi1 (Q x y)) U1)
%%
	   ([y] aasub/pi1 
	      (DsubQx y : aasub ([x] Q x y) M (Qx y)))
	   (DsubRx : aosub ([x] R x) M LRx)
	   (aasub/pi1
	      (DsubQxy : aasub ([y] Qx y) LRx Qxy))
%%
	   (aasub/pi1 DsubQyx)
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J} 
		 aofes-invert-pi1 (DofPi x d y e)
		    (DofQ x d y e : aofes (G x y) (Q x y) (ssigma U1 U2)))
	   <- ssub-xz-permute-es DlookupX DlookupY DofM DofR DofQ
	      DsubQx DsubRx DsubQxy
	      (DsubQyx : aasub ([x] Q x (R x)) M Qxy).

-pi1-cl	: ssub-xz-permute-es
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofR : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (R x) T)
	   (DofPi : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (pi1 (Q x y)) U1)
%%
	   ([y] aasub/pi1 
	      (DsubQx y : aasub ([x] Q x y) M Qx))
	   (DsubRx : aosub ([x] R x) M LRx)
	   aasub/closed
%%
	   (aasub/pi1 DsubQyx)
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J} 
		 aofes-invert-pi1 (DofPi x d y e)
		    (DofQ x d y e : aofes (G x y) (Q x y) (ssigma U1 U2)))
	   <- ssub-xz-permute-es DlookupX DlookupY DofM DofR DofQ
	      DsubQx DsubRx aasub/closed
	      (DsubQyx : aasub ([x] Q x (R x)) M Qx).

-pi2	: ssub-xz-permute-es
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofR : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (R x) T)
	   (DofPi : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (pi2 (Q x y)) U2)
%%
	   ([y] aasub/pi2 
	      (DsubQx y : aasub ([x] Q x y) M (Qx y)))
	   (DsubRx : aosub ([x] R x) M LRx)
	   (aasub/pi2
	      (DsubQxy : aasub ([y] Qx y) LRx Qxy))
%%
	   (aasub/pi2 DsubQyx)
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J} 
		 aofes-invert-pi2 (DofPi x d y e)
		    (DofQ x d y e : aofes (G x y) (Q x y) (ssigma U1 U2)))
	   <- ssub-xz-permute-es DlookupX DlookupY DofM DofR DofQ
	      DsubQx DsubRx DsubQxy
	      (DsubQyx : aasub ([x] Q x (R x)) M Qxy).

-pi2-cl	: ssub-xz-permute-es
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofR : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (R x) T)
	   (DofPi : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (pi2 (Q x y)) U2)
%%
	   ([y] aasub/pi2 
	      (DsubQx y : aasub ([x] Q x y) M Qx))
	   (DsubRx : aosub ([x] R x) M LRx)
	   aasub/closed
%%
	   (aasub/pi2 DsubQyx)
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J} 
		 aofes-invert-pi2 (DofPi x d y e)
		    (DofQ x d y e : aofes (G x y) (Q x y) (ssigma U1 U2)))
	   <- ssub-xz-permute-es DlookupX DlookupY DofM DofR DofQ
	      DsubQx DsubRx aasub/closed
	      (DsubQyx : aasub ([x] Q x (R x)) M Qx).


-closed	: ssub-xy-permute-es
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofR : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (R x) T)
	   (DofQ : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (Q y) U)
%%
	   ([_] aasub/closed)
	   (DsubRx : aosub ([x] R x) M LRx)
	   (DsubQxy : aosub ([y] Q y) LRx LQy)
%%
	   DsubQyx
	   <- aosub-into-aosub DsubRx DsubQxy
	      (DsubQyx : aosub ([x] Q (R x)) M LQy).

-app	: ssub-xy-permute-es
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofR : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (R x) T)
	   (DofApp : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (app (Q x y) (N x y)) U2)
%%
	   ([y] aasub/app
	      (DsubNx y : sub ([x] N x y) M (Nx y))
	      (DsubQx y : aasub ([x] Q x y) M (Qx y)))
	   (DsubRx : aosub ([x] R x) M LRx)
	   (aosub/app
	      (DsubPz : sub ([z] P z) Nxy Pz) 
	      (DsubNxy : sub ([y] Nx y) LRx Nxy)
	      (DsubQxy : aosub ([y] Qx y) LRx (lam ([z] P z))))
%%
	   (aosub/app DsubPz DsubNyx DsubQyx)
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J} 
		 aofes-invert-app (DofApp x d y e)
		    (DofQ x d y e : aofes (G x y) (Q x y) (spi U1 U2))
		    (DofN x d y e : ofes (G x y) (N x y) U1))
	   <- ssub-xy-permute-es DlookupX DlookupY DofM DofR DofQ
	      DsubQx DsubRx DsubQxy
	      (DsubQyx : aosub ([x] Q x (R x)) M (lam ([z] P z)))
	   <- ssub-x-permute-es DlookupX DlookupY DofM DofR DofN
	      DsubNx DsubRx DsubNxy
	      (DsubNyx : sub ([x] N x (R x)) M Nxy).

-pi1	: ssub-xy-permute-es
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofR : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (R x) T)
	   (DofPi : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (pi1 (Q x y)) U1)
%%
	   ([y] aasub/pi1 
	      (DsubQx y : aasub ([x] Q x y) M (Qx y)))
	   (DsubRx : aosub ([x] R x) M LRx)
	   (aosub/pi1
	      (DsubQxy : aosub ([y] Qx y) LRx (pair P1 P2)))
%%
	   (aosub/pi1 DsubQyx)
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J} 
		 aofes-invert-pi1 (DofPi x d y e)
		    (DofQ x d y e : aofes (G x y) (Q x y) (ssigma U1 U2)))
	   <- ssub-xy-permute-es DlookupX DlookupY DofM DofR DofQ
	      DsubQx DsubRx DsubQxy
	      (DsubQyx : aosub ([x] Q x (R x)) M (pair P1 P2)).

-pi2	: ssub-xy-permute-es
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofR : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (R x) T)
	   (DofPi : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (pi2 (Q x y)) U2)
%%
	   ([y] aasub/pi2 
	      (DsubQx y : aasub ([x] Q x y) M (Qx y)))
	   (DsubRx : aosub ([x] R x) M LRx)
	   (aosub/pi2
	      (DsubQxy : aosub ([y] Qx y) LRx (pair P1 P2)))
%%
	   (aosub/pi2 DsubQyx)
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J} 
		 aofes-invert-pi2 (DofPi x d y e)
		    (DofQ x d y e : aofes (G x y) (Q x y) (ssigma U1 U2)))
	   <- ssub-xy-permute-es DlookupX DlookupY DofM DofR DofQ
	      DsubQx DsubRx DsubQxy
	      (DsubQyx : aosub ([x] Q x (R x)) M (pair P1 P2)).


-var	: ssub-xx-permute-es
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofR : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (R x) T)
	   _
%%
	   ([_] aosub/var)
	   (DsubRx : aosub ([x] R x) M LRx)
	   (Dsub : sub ([y] M) LRx LQxy)
%%
	   Daosub
	   <- sub-absent M LRx (Dsub' : sub ([y] M) LRx M)
	   <- sub-fun Dsub' Dsub (Deq : term-eq M LQxy)
	   <- aosub-resp ([_] atom-eq/i) term-eq/i Deq aosub/var
	      (Daosub : aosub ([y] y) M LQxy).

-app	: ssub-xx-permute-es
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofR : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (R x) T)
	   (DofApp : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (app (Q x y) (N x y)) U2)
%%
	   ([y] aosub/app
	      (DsubPz y : sub ([z] P y z) (Nx y) (Pz y))
	      (DsubNx y : sub ([x] N x y) M (Nx y))
	      (DsubQx y : aosub ([x] Q x y) M (lam ([z] P y z))))
	   (DsubRx : aosub ([x] R x) M LRx)
	   (DsubPzy : sub ([y] Pz y) LRx Pzy)
%%
	   (aosub/app
	      DsubPyz
	      DsubNyx
	      DsubQyx)
	   %% first need typing derivations
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J} 
		 aofes-invert-app (DofApp x d y e)
		    (DofQ x d y e : aofes (G x y) (Q x y) (spi U1 U2))
		    (DofN x d y e : ofes (G x y) (N x y) U1))
	   <- ({y} {e:isvar y J}
		 aosubst-es ([x] [d] DlookupX x d y e) ([x] [d] DofM x d y e) ([x] [d] DofR x d y e) DsubRx
		    ([x] [d] DofLRx x d y e : ofes (G x y) LRx T))
	   <- ({y} {e:isvar y J}
		 subst-es ([x] [d] DlookupX x d y e) ([x] [d] DofM x d y e) ([x] [d] DofN x d y e) (DsubNx y)
		    ([x] [d] DofNx x d y e : ofes (G x y) (Nx y) U1))
	   <- ({y} {e:isvar y J}
		 aosubst-es ([x] [d] DlookupX x d y e) ([x] [d] DofM x d y e) ([x] [d] DofQ x d y e) (DsubQx y)
		    ([x] [d:isvar x I]
		       ofes/lam
		       ([z] [f:isvar z K]
			  DofP x d y e z f : ofes (scons (G x y) z U1) (P y z) U2)))
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J}
		 {z} {f:isvar z K}
		 ofes-context (DofP x d y e z f)
		    (sordered/cons
		       (Dbounded x d y e z f : sbounded (G x y) z)
		       : sordered (scons (G x y) z U1)))
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J}
		 {z} {f:isvar z K}
		 weaken-slookup (Dbounded x d y e z f) (DlookupY x d y e) _
		    (DlookupY' x d y e z f : slookup (scons (G x y) z U1) y T))
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J} 
		 {z} {f:isvar z K}
		 weaken-ofes (Dbounded x d y e z f) (DofLRx x d y e) _ 
		    (DofLRx' x d y e z f : ofes (scons (G x y) z U1) LRx T))
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J} 
		 {z} {f:isvar z K}
		 weaken-ofes (Dbounded x d y e z f) (DofNx x d y e) _ 
		    (DofNx' x d y e z f : ofes (scons (G x y) z U1) (Nx y) U1))
	   %% get to work
	   <- ({x} {d:isvar x I} 
		 sub-permute-es ([y] [e] [z] [f] DlookupY' x d y e z f) ([y] [e] [z] [f] slookup/hit (Dbounded x d y e z f)) ([y] [e] [z] [f] DofLRx' x d y e z f) ([y] [e] [z] [f] DofNx' x d y e z f) ([y] [e] [z] [f] DofP x d y e z f)
		    DsubPz DsubPzy
		    (DsubPy_x x : {z} sub ([y] P y z) LRx (Py_x x z))
		    (DsubNxy_x x : sub ([y] Nx y) LRx (Nxy_x x))
		    (DsubPyz_x x : sub ([z] Py_x x z) (Nxy_x x) Pzy))
	   %% remove extraneous x variable
	   <- ({z} sub-closed ([x] DsubPy_x x z) 
		 ([x] DeqPy_x x z : term-eq (Py_x x z) (Py z)))
	   <- sub-closed ([x] DsubNxy_x x) 
	      ([x] DeqNxy_x x : term-eq (Nxy_x x) Nxy)
	   <- ({z} sub-resp-strengthen ([_] [_] term-eq/i) ([_] term-eq/i) ([x] DeqPy_x x z) ([x] DsubPy_x x z)
		 (DsubPy z : sub ([y] P y z) LRx (Py z)))
	   <- sub-resp-strengthen ([_] [_] term-eq/i) ([_] term-eq/i) ([x] DeqNxy_x x) ([x] DsubNxy_x x)
	      (DsubNxy : sub ([y] Nx y) LRx Nxy)
	   <- sub-resp-strengthen ([x] [z] DeqPy_x x z) ([x] DeqNxy_x x) ([_] term-eq/i) ([x] DsubPyz_x x)
	      (DsubPyz : sub ([z] Py z) Nxy Pzy)
	   %% finish up
	   <- ssub-xx-permute-es DlookupX DlookupY DofM DofR DofQ
	      DsubQx DsubRx (sub/lam DsubPy)
	      (DsubQyx : aosub ([x] Q x (R x)) M (lam ([z] Py z)))
	   <- ssub-x-permute-es DlookupX DlookupY DofM DofR DofN
	      DsubNx DsubRx
	      (DsubNxy : sub ([y] Nx y) LRx Nxy)
	      (DsubNyx : sub ([x] N x (R x)) M Nxy).

-pi1	: ssub-xx-permute-es
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofR : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (R x) T)
	   (DofPi : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (pi1 (Q x y)) U1)
%%
	   ([y] aosub/pi1
	      (DsubQx y : aosub ([x] Q x y) M (pair (P1 y) (P2 y))))
	   (DsubRx : aosub ([x] R x) M LRx)
	   (DsubP1y : sub ([y] P1 y) LRx P1y)
%%
	   (aosub/pi1 DsubQyx)
	   %% first need typing derivations
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J} 
		 aofes-invert-pi1 (DofPi x d y e)
		    (DofQ x d y e : aofes (G x y) (Q x y) (ssigma U1 U2)))
	   <- ({y} {e:isvar y J} 
		 aosubst-es ([x] [d] DlookupX x d y e) ([x] [d] DofM x d y e) ([x] [d] DofR x d y e)
		    DsubRx
		    ([x] [d] DofLRx x d y e : ofes (G x y) LRx T))
	   <- ({y} {e:isvar y J} 
		 aosubst-es ([x] [d] DlookupX x d y e) ([x] [d] DofM x d y e) ([x] [d] DofQ x d y e)
		    (DsubQx y)
		    ([x] [d] ofes/pair (DofP2 x d y e) (DofP1 x d y e)))
	   %% now to work
	   <- ({x} {d:isvar x I} 
		 can-sub-es ([y] [e] DlookupY x d y e) ([y] [e] DofP2 x d y e) ([y] [e] DofLRx x d y e)
		    (DsubP2y_x x : sub ([y] P2 y) LRx (P2y_x x)))
	   %% remove extraneous x dependency
	   <- sub-closed' DsubP2y_x (DsubP2y : sub ([y] P2 y) LRx P2y)
	   %% finish up
	   <- ssub-xx-permute-es DlookupX DlookupY DofM DofR DofQ
	      DsubQx DsubRx (sub/pair DsubP2y DsubP1y)
	      (DsubQyx : aosub ([x] Q x (R x)) M (pair P1y P2y)).

-pi2	: ssub-xx-permute-es
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofR : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (R x) T)
	   (DofPi : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (pi2 (Q x y)) U2)
%%
	   ([y] aosub/pi2
	      (DsubQx y : aosub ([x] Q x y) M (pair (P1 y) (P2 y))))
	   (DsubRx : aosub ([x] R x) M LRx)
	   (DsubP2y : sub ([y] P2 y) LRx P2y)
%%
	   (aosub/pi2 DsubQyx)
	   %% first need typing derivations
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J} 
		 aofes-invert-pi2 (DofPi x d y e)
		    (DofQ x d y e : aofes (G x y) (Q x y) (ssigma U1 U2)))
	   <- ({y} {e:isvar y J} 
		 aosubst-es ([x] [d] DlookupX x d y e) ([x] [d] DofM x d y e) ([x] [d] DofR x d y e)
		    DsubRx
		    ([x] [d] DofLRx x d y e : ofes (G x y) LRx T))
	   <- ({y} {e:isvar y J} 
		 aosubst-es ([x] [d] DlookupX x d y e) ([x] [d] DofM x d y e) ([x] [d] DofQ x d y e)
		    (DsubQx y)
		    ([x] [d] ofes/pair (DofP2 x d y e) (DofP1 x d y e)))
	   %% now to work
	   <- ({x} {d:isvar x I} 
		 can-sub-es ([y] [e] DlookupY x d y e) ([y] [e] DofP1 x d y e) ([y] [e] DofLRx x d y e)
		    (DsubP1y_x x : sub ([y] P1 y) LRx (P1y_x x)))
	   %% remove extraneous x dependency
	   <- sub-closed' DsubP1y_x (DsubP1y : sub ([y] P1 y) LRx P1y)
	   %% finish up
	   <- ssub-xx-permute-es DlookupX DlookupY DofM DofR DofQ
	      DsubQx DsubRx (sub/pair DsubP2y DsubP1y)
	      (DsubQyx : aosub ([x] Q x (R x)) M (pair P1y P2y)).


-t	: stsub-z-permute-es
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofR : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (R x) T)
	   ([x] [d] [y] [e] wfes/t _)
	   ([_] tsub/t)
	   _
	   tsub/t.

-pi	: stsub-z-permute-es
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofR : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (R x) T)
	   ([x] [d] [y] [e]
	      wfes/pi
	      (DwfB x d y e : {z} isvar z K -> wfes (scons (G x y) z U) (B x y z))
	      (Dsimp x y : simp (A x y) U)
	      (DwfA x d y e : wfes (G x y) (A x y)))
	   ([y]
	      tsub/pi
	      (DsubBx y : {z} tsub ([x] B x y z) M (Bx y z))
	      (DsubAx y : tsub ([x] A x y) M (Ax y)))
	   (DsubRx : aasub ([x] R x) M Rx)
	   (tsub/pi DsubByx DsubAyx)
	   %% first get some typing derivations
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J}
		 {z} {f:isvar z K}
		 wfes-context (DwfB x d y e z f)
		    (sordered/cons
		       (Dbounded x d y e z f : sbounded (G x y) z)
		       : sordered (scons (G x y) z U)))
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J}
		 {z} {f:isvar z K}
		 weaken-ofes (Dbounded x d y e z f) (DofM x d y e) _ 
		    (DofM' x d y e z f : ofes (scons (G x y) z U) M S))
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J}
		 {z} {f:isvar z K}
		 weaken-aofes (Dbounded x d y e z f) (DofR x d y e) _ 
		    (DofR' x d y e z f : aofes (scons (G x y) z U) (R x) T))
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J}
		 {z} {f:isvar z K}
		 weaken-slookup (Dbounded x d y e z f) (DlookupX x d y e) _
		    (DlookupX' x d y e z f : slookup (scons (G x y) z U) x S))
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J}
		 {z} {f:isvar z K}
		 weaken-slookup (Dbounded x d y e z f) (DlookupY x d y e) _
		    (DlookupY' x d y e z f : slookup (scons (G x y) z U) y T))
	   %% now get to work
	   <- stsub-z-permute-es DlookupX DlookupY DofM DofR DwfA DsubAx DsubRx
	      (DsubAyx : tsub ([x] A x (R x)) M (Ax Rx))
	   <- ({z} {f}
		 stsub-z-permute-es ([x] [d] [y] [e] DlookupX' x d y e z f) ([x] [d] [y] [e] DlookupY' x d y e z f) ([x] [d] [y] [e] DofM' x d y e z f) ([x] [d] [y] [e] DofR' x d y e z f) ([x] [d] [y] [e] DwfB x d y e z f) ([y] DsubBx y z) DsubRx
		 (DsubByx z : tsub ([x] B x (R x) z) M (Bx Rx z))).

-sigma	: stsub-z-permute-es
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofR : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (R x) T)
	   ([x] [d] [y] [e]
	      wfes/sigma
	      (DwfB x d y e : {z} isvar z K -> wfes (scons (G x y) z U) (B x y z))
	      (Dsimp x y : simp (A x y) U)
	      (DwfA x d y e : wfes (G x y) (A x y)))
	   ([y]
	      tsub/sigma
	      (DsubBx y : {z} tsub ([x] B x y z) M (Bx y z))
	      (DsubAx y : tsub ([x] A x y) M (Ax y)))
	   (DsubRx : aasub ([x] R x) M Rx)
	   (tsub/sigma DsubByx DsubAyx)
	   %% first get some typing derivations
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J}
		 {z} {f:isvar z K}
		 wfes-context (DwfB x d y e z f)
		    (sordered/cons
		       (Dbounded x d y e z f : sbounded (G x y) z)
		       : sordered (scons (G x y) z U)))
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J}
		 {z} {f:isvar z K}
		 weaken-ofes (Dbounded x d y e z f) (DofM x d y e) _ 
		    (DofM' x d y e z f : ofes (scons (G x y) z U) M S))
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J}
		 {z} {f:isvar z K}
		 weaken-aofes (Dbounded x d y e z f) (DofR x d y e) _ 
		    (DofR' x d y e z f : aofes (scons (G x y) z U) (R x) T))
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J}
		 {z} {f:isvar z K}
		 weaken-slookup (Dbounded x d y e z f) (DlookupX x d y e) _
		    (DlookupX' x d y e z f : slookup (scons (G x y) z U) x S))
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J}
		 {z} {f:isvar z K}
		 weaken-slookup (Dbounded x d y e z f) (DlookupY x d y e) _
		    (DlookupY' x d y e z f : slookup (scons (G x y) z U) y T))
	   %% now get to work
	   <- stsub-z-permute-es DlookupX DlookupY DofM DofR DwfA DsubAx DsubRx
	      (DsubAyx : tsub ([x] A x (R x)) M (Ax Rx))
	   <- ({z} {f}
		 stsub-z-permute-es ([x] [d] [y] [e] DlookupX' x d y e z f) ([x] [d] [y] [e] DlookupY' x d y e z f) ([x] [d] [y] [e] DofM' x d y e z f) ([x] [d] [y] [e] DofR' x d y e z f) ([x] [d] [y] [e] DwfB x d y e z f) ([y] DsubBx y z) DsubRx
		 (DsubByx z : tsub ([x] B x (R x) z) M (Bx Rx z))).

-singa	: stsub-z-permute-es
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofR : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (R x) T)
	   ([x] [d] [y] [e]
	      wfes/sing
	      (DofQ x d y e : aofes (G x y) (Q x y) st))
	   ([y] tsub/singa
	      (DsubQx y : aasub ([x] Q x y) M (Qx y)))
	   (DsubRx : aasub ([x] R x) M Rx)
	   (tsub/singa DsubQyx)
	   <- ssub-zz-permute-es DlookupX DlookupY DofM DofR DofQ DsubQx DsubRx
	      (DsubQyx : aasub ([x] Q x (R x)) M (Qx Rx)).

-singo	: stsub-z-permute-es
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofR : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (R x) T)
	   ([x] [d] [y] [e]
	      wfes/sing
	      (DofQ x d y e : aofes (G x y) (Q x y) st))
	   ([y] tsub/singo
	      (DsubQx y : aosub ([x] Q x y) M (at (Qx y))))
	   (DsubRx : aasub ([x] R x) M Rx)
	   (tsub/singo DsubQyx)
	   <- ssub-zx-permute-es DlookupX DlookupY DofM DofR DofQ DsubQx DsubRx
	      (DsubQyx : aosub ([x] Q x (R x)) M (at (Qx Rx))).


-t	: stsub-x-permute-es
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofR : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (R x) T)
	   ([x] [d] [y] [e] wfes/t _)
	   ([_] tsub/t)
	   _
	   _
	   tsub/t.

-pi	: stsub-x-permute-es
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofR : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (R x) T)
	   ([x] [d] [y] [e]
	      wfes/pi
	      (DwfB x d y e : {z} isvar z K -> wfes (scons (G x y) z U) (B x y z))
	      (Dsimp x y : simp (A x y) U)
	      (DwfA x d y e : wfes (G x y) (A x y)))
	   ([y]
	      tsub/pi
	      (DsubBx y : {z} tsub ([x] B x y z) M (Bx y z))
	      (DsubAx y : tsub ([x] A x y) M (Ax y)))
	   (DsubRx : aosub ([x] R x) M LRx)
	   (tsub/pi
	      (DsubBxy : {z} tsub ([y] Bx y z) LRx (Bxy z))
	      (DsubAxy : tsub ([y] Ax y) LRx Axy))
	   (tsub/pi DsubByx DsubAyx)
	   %% first get some typing derivations
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J}
		 {z} {f:isvar z K}
		 wfes-context (DwfB x d y e z f)
		    (sordered/cons
		       (Dbounded x d y e z f : sbounded (G x y) z)
		       : sordered (scons (G x y) z U)))
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J}
		 {z} {f:isvar z K}
		 weaken-ofes (Dbounded x d y e z f) (DofM x d y e) _ 
		    (DofM' x d y e z f : ofes (scons (G x y) z U) M S))
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J}
		 {z} {f:isvar z K}
		 weaken-aofes (Dbounded x d y e z f) (DofR x d y e) _ 
		    (DofR' x d y e z f : aofes (scons (G x y) z U) (R x) T))
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J}
		 {z} {f:isvar z K}
		 weaken-slookup (Dbounded x d y e z f) (DlookupX x d y e) _
		    (DlookupX' x d y e z f : slookup (scons (G x y) z U) x S))
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J}
		 {z} {f:isvar z K}
		 weaken-slookup (Dbounded x d y e z f) (DlookupY x d y e) _
		    (DlookupY' x d y e z f : slookup (scons (G x y) z U) y T))
	   %% now get to work
	   <- stsub-x-permute-es DlookupX DlookupY DofM DofR DwfA DsubAx DsubRx DsubAxy
	      (DsubAyx : tsub ([x] A x (R x)) M Axy)
	   <- ({z} {f}
		 stsub-x-permute-es ([x] [d] [y] [e] DlookupX' x d y e z f) ([x] [d] [y] [e] DlookupY' x d y e z f) ([x] [d] [y] [e] DofM' x d y e z f) ([x] [d] [y] [e] DofR' x d y e z f) ([x] [d] [y] [e] DwfB x d y e z f) ([y] DsubBx y z) DsubRx (DsubBxy z)
		 (DsubByx z : tsub ([x] B x (R x) z) M (Bxy z))).

-sigma	: stsub-x-permute-es
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofR : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (R x) T)
	   ([x] [d] [y] [e]
	      wfes/sigma
	      (DwfB x d y e : {z} isvar z K -> wfes (scons (G x y) z U) (B x y z))
	      (Dsimp x y : simp (A x y) U)
	      (DwfA x d y e : wfes (G x y) (A x y)))
	   ([y]
	      tsub/sigma
	      (DsubBx y : {z} tsub ([x] B x y z) M (Bx y z))
	      (DsubAx y : tsub ([x] A x y) M (Ax y)))
	   (DsubRx : aosub ([x] R x) M LRx)
	   (tsub/sigma
	      (DsubBxy : {z} tsub ([y] Bx y z) LRx (Bxy z))
	      (DsubAxy : tsub ([y] Ax y) LRx Axy))
	   (tsub/sigma DsubByx DsubAyx)
	   %% first get some typing derivations
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J}
		 {z} {f:isvar z K}
		 wfes-context (DwfB x d y e z f)
		    (sordered/cons
		       (Dbounded x d y e z f : sbounded (G x y) z)
		       : sordered (scons (G x y) z U)))
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J}
		 {z} {f:isvar z K}
		 weaken-ofes (Dbounded x d y e z f) (DofM x d y e) _ 
		    (DofM' x d y e z f : ofes (scons (G x y) z U) M S))
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J}
		 {z} {f:isvar z K}
		 weaken-aofes (Dbounded x d y e z f) (DofR x d y e) _ 
		    (DofR' x d y e z f : aofes (scons (G x y) z U) (R x) T))
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J}
		 {z} {f:isvar z K}
		 weaken-slookup (Dbounded x d y e z f) (DlookupX x d y e) _
		    (DlookupX' x d y e z f : slookup (scons (G x y) z U) x S))
	   <- ({x} {d:isvar x I} 
		 {y} {e:isvar y J}
		 {z} {f:isvar z K}
		 weaken-slookup (Dbounded x d y e z f) (DlookupY x d y e) _
		    (DlookupY' x d y e z f : slookup (scons (G x y) z U) y T))
	   %% now get to work
	   <- stsub-x-permute-es DlookupX DlookupY DofM DofR DwfA DsubAx DsubRx DsubAxy
	      (DsubAyx : tsub ([x] A x (R x)) M Axy)
	   <- ({z} {f}
		 stsub-x-permute-es ([x] [d] [y] [e] DlookupX' x d y e z f) ([x] [d] [y] [e] DlookupY' x d y e z f) ([x] [d] [y] [e] DofM' x d y e z f) ([x] [d] [y] [e] DofR' x d y e z f) ([x] [d] [y] [e] DwfB x d y e z f) ([y] DsubBx y z) DsubRx (DsubBxy z)
		 (DsubByx z : tsub ([x] B x (R x) z) M (Bxy z))).

-singaa	: stsub-x-permute-es
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofR : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (R x) T)
	   ([x] [d] [y] [e]
	      wfes/sing
	      (DofQ x d y e : aofes (G x y) (Q x y) st))
	   ([y] tsub/singa
	      (DsubQx y : aasub ([x] Q x y) M (Qx y)))
	   (DsubRx : aosub ([x] R x) M LRx)
	   (tsub/singa
	      (DsubQxy : aasub ([y] Qx y) LRx Qxy))
	   (tsub/singa DsubQyx)
	   <- ssub-xz-permute-es DlookupX DlookupY DofM DofR DofQ DsubQx DsubRx DsubQxy
	      (DsubQyx : aasub ([x] Q x (R x)) M Qxy).

-singao	: stsub-x-permute-es
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofR : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (R x) T)
	   ([x] [d] [y] [e]
	      wfes/sing
	      (DofQ x d y e : aofes (G x y) (Q x y) st))
	   ([y] tsub/singa
	      (DsubQx y : aasub ([x] Q x y) M (Qx y)))
	   (DsubRx : aosub ([x] R x) M LRx)
	   (tsub/singo
	      (DsubQxy : aosub ([y] Qx y) LRx (at Qxy)))
	   (tsub/singo DsubQyx)
	   <- ssub-xy-permute-es DlookupX DlookupY DofM DofR DofQ DsubQx DsubRx DsubQxy
	      (DsubQyx : aosub ([x] Q x (R x)) M (at Qxy)).

-singoa	: stsub-x-permute-es
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofR : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (R x) T)
	   ([x] [d] [y] [e]
	      wfes/sing
	      (DofQ x d y e : aofes (G x y) (Q x y) st))
	   ([y] tsub/singo
	      (DsubQx y : aosub ([x] Q x y) M (at (Qx y))))
	   (DsubRx : aosub ([x] R x) M LRx)
	   (tsub/singa
	      (DsubQxy : aasub ([y] Qx y) LRx Qxy))
	   (tsub/singo DsubQyx)
	   <- ssub-xx-permute-es DlookupX DlookupY DofM DofR DofQ DsubQx DsubRx (sub/aa DsubQxy)
	      (DsubQyx : aosub ([x] Q x (R x)) M (at Qxy)).

-singoo	: stsub-x-permute-es
	   (DlookupX : {x} isvar x I -> {y} isvar y J -> slookup (G x y) x S)
	   (DlookupY : {x} isvar x I -> {y} isvar y J -> slookup (G x y) y T)
	   (DofM : {x} isvar x I -> {y} isvar y J -> ofes (G x y) M S)
	   (DofR : {x} isvar x I -> {y} isvar y J -> aofes (G x y) (R x) T)
	   ([x] [d] [y] [e]
	      wfes/sing
	      (DofQ x d y e : aofes (G x y) (Q x y) st))
	   ([y] tsub/singo
	      (DsubQx y : aosub ([x] Q x y) M (at (Qx y))))
	   (DsubRx : aosub ([x] R x) M LRx)
	   (tsub/singo
	      (DsubQxy : aosub ([y] Qx y) LRx (at Qxy)))
	   (tsub/singo DsubQyx)
	   <- ssub-xx-permute-es DlookupX DlookupY DofM DofR DofQ DsubQx DsubRx (sub/ao DsubQxy)
	      (DsubQyx : aosub ([x] Q x (R x)) M (at Qxy)).


%worlds (var | ovar | bind) 
(ssub-z-permute-es _ _ _ _ _ _ _ _) 
(ssub-x-permute-es _ _ _ _ _ _ _ _ _) 
(ssub-zz-permute-es _ _ _ _ _ _ _ _) 
(ssub-zx-permute-es _ _ _ _ _ _ _ _) 
(ssub-xz-permute-es _ _ _ _ _ _ _ _ _) 
(ssub-xy-permute-es _ _ _ _ _ _ _ _ _)
(ssub-xx-permute-es _ _ _ _ _ _ _ _ _)
(stsub-x-permute-es _ _ _ _ _ _ _ _ _)
(stsub-z-permute-es _ _ _ _ _ _ _ _).

%total (D1 D2 D3 D4 D5 D6 D7 D8 D9) 
(ssub-z-permute-es _ _ _ _ _ D1 _ _) 
(ssub-x-permute-es _ _ _ _ _ D2 _ _ _) 
(ssub-zz-permute-es _ _ _ _ _ D3 _ _) 
(ssub-zx-permute-es _ _ _ _ _ D4 _ _)
(ssub-xz-permute-es _ _ _ _ _ D5 _ _ _)
(ssub-xy-permute-es _ _ _ _ _ D6 _ _ _)
(ssub-xx-permute-es _ _ _ _ _ D7 _ _ _)
(stsub-x-permute-es _ _ _ _ _ D8 _ _ _)
(stsub-z-permute-es _ _ _ _ _ D9 _ _).




%%%%%  Simple (ie, atom for atom) Substitution Permutations (Explicit Context)  %%%%%

ssub-aa-permute-e : ({x} append (cons G1 x A) (G2 x) (G x))
		      -> ofe G1 M A
		      -> ({x} isvar x I -> aofe (G x) (R x) (B x))
		      -> ({x} isvar x I -> {y} isvar y J -> ofe (cons (G x) y (B x)) (N x y) (C x y))
%%
		      -> ({y} sub ([x] N x y) M (Nx y))
		      -> aasub R M Rx
		      -> sub ([x] N x (R x)) M Nyx
%%
		      -> term-eq (Nx Rx) Nyx -> type.
%mode ssub-aa-permute-e +X1 +X2 +X3 +X4 +X5 +X6 +X7 -X8.

-	: ssub-aa-permute-e
	   (Dappend : {x} append (cons G1 x A) (G2 x) (G x))
	   (DofM : ofe G1 M A)
	   (DofR : ({x} isvar x I -> aofe (G x) (R x) (B x)))
	   (DofN : ({x} isvar x I -> {y} isvar y J -> ofe (cons (G x) y (B x)) (N x y) (C x y)))
%%
	   (DsubNx : ({y} sub ([x] N x y) M (Nx y)))
	   (DsubRx : aasub R M Rx)
	   (DsubNyx : sub ([x] N x (R x)) M Nyx)
%%
	   Deq
	   %% get context orderings
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 ofe-context (DofN x d y e) 
		    (ordered/cons
		       (Dbounded x d y e : bounded (G x) y)))
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 append-bounded (Dappend x) (Dbounded x d y e)
		    (bounded/cons
		       (Dbounded' x d y e : bounded G1 x)
		       (DprecedesXY x d y e : precedes x y)))
	   %% get simplifications
	   <- can-simp A (DsimpA : simp A S)
	   <- ({x} can-simp (B x) (DsimpB x : simp (B x) T))
	   <- ({x} {y} can-simp (C x y) (DsimpC x y : simp (C x y) U))
	   <- ({y} {e:isvar y J}
		 context-append-simp-lookup Dappend ([x] [d] Dbounded x d y e) DsimpA
		    ([x] Dsimpctx x y : simpctx (G x) (G' x y))
		    ([x] [d] Dsbounded x d y e : sbounded (G' x y) y)
		    ([x] [d] Dlookup x d y e : slookup (G' x y) x S))
	   %% weaken and simplify DofM
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 weaken-ofe (Dbounded' x d y e) DofM _ 
		    (DofM' x d y e : ofe (cons G1 x A) M A))
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 weaken-ofe'' (Dappend x) (Dbounded x d y e) (DofM' x d y e) 
		    (DofM'' x d y e : ofe (G x) M A))
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 weaken-ofe (Dbounded x d y e) (DofM'' x d y e) _
		    (DofM''' x d y e : ofe (cons (G x) y (B x)) M A))
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 ofe-simp (simpctx/cons (DsimpB x) (Dsimpctx x y)) DsimpA (DofM''' x d y e)
		    (DofM'''' x d y e : ofes (scons (G' x y) y T) M S))
	   %% weaken and simplify DofR
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 weaken-aofe (Dbounded x d y e) (DofR x d) _
		    (DofR' x d y e : aofe (cons (G x) y (B x)) (R x) (B x)))
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		    aofe-simp (simpctx/cons (DsimpB x) (Dsimpctx x y)) (DsimpB x) (DofR' x d y e)
		       (DofR'' x d y e : aofes (scons (G' x y) y T) (R x) T))
	   %% simplify DofN
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		    ofe-simp (simpctx/cons (DsimpB x) (Dsimpctx x y)) (DsimpC x y) (DofN x d y e)
		       (DofN' x d y e : ofes (scons (G' x y) y T) (N x y) U))
	   %% go
	   <- ssub-z-permute-es
	      ([x] [d:isvar x I] [y] [e:isvar y J]
		 slookup/miss (Dlookup x d y e) (Dsbounded x d y e))
	      ([x] [d] [y] [e] slookup/hit (Dsbounded x d y e))
	      DofM'''' DofR''  DofN'
	      DsubNx DsubRx
	      (DsubNyx' : sub ([x] N x (R x)) M (Nx Rx))
	   <- sub-fun DsubNyx' DsubNyx (Deq : term-eq (Nx Rx) Nyx).

%worlds (var | ovar | bind) (ssub-aa-permute-e _ _ _ _ _ _ _ _).
%total {} (ssub-aa-permute-e _ _ _ _ _ _ _ _).



ssub-ao-permute-e : ({x} append (cons G1 x A) (G2 x) (G x))
		      -> ofe G1 M A
		      -> ({x} isvar x I -> aofe (G x) (R x) (B x))
		      -> ({x} isvar x I -> {y} isvar y J -> ofe (cons (G x) y (B x)) (N x y) (C x y))
%%
		      -> ({y} sub ([x] N x y) M (Nx y))
		      -> aosub R M LRx
		      -> sub ([y] Nx y) LRx Nxy
		      -> sub ([x] N x (R x)) M Nyx
%%
		      -> term-eq Nxy Nyx -> type.
%mode ssub-ao-permute-e +X1 +X2 +X3 +X4 +X5 +X6 +X7 +X8 -X9.

-	: ssub-ao-permute-e
	   (Dappend : {x} append (cons G1 x A) (G2 x) (G x))
	   (DofM : ofe G1 M A)
	   (DofR : ({x} isvar x I -> aofe (G x) (R x) (B x)))
	   (DofN : ({x} isvar x I -> {y} isvar y J -> ofe (cons (G x) y (B x)) (N x y) (C x y)))
%%
	   (DsubNx : ({y} sub ([x] N x y) M (Nx y)))
	   (DsubRx : aosub R M LRx)
	   (DsubNxy : sub ([y] Nx y) LRx Nxy)
	   (DsubNyx : sub ([x] N x (R x)) M Nyx)
%%
	   Deq
	   %% get context orderings
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 ofe-context (DofN x d y e) 
		    (ordered/cons
		       (Dbounded x d y e : bounded (G x) y)))
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 append-bounded (Dappend x) (Dbounded x d y e)
		    (bounded/cons
		       (Dbounded' x d y e : bounded G1 x)
		       (DprecedesXY x d y e : precedes x y)))
	   %% get simplifications
	   <- can-simp A (DsimpA : simp A S)
	   <- ({x} can-simp (B x) (DsimpB x : simp (B x) T))
	   <- ({x} {y} can-simp (C x y) (DsimpC x y : simp (C x y) U))
	   <- ({y} {e:isvar y J}
		 context-append-simp-lookup Dappend ([x] [d] Dbounded x d y e) DsimpA
		    ([x] Dsimpctx x y : simpctx (G x) (G' x y))
		    ([x] [d] Dsbounded x d y e : sbounded (G' x y) y)
		    ([x] [d] Dlookup x d y e : slookup (G' x y) x S))
	   %% weaken and simplify DofM
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 weaken-ofe (Dbounded' x d y e) DofM _ 
		    (DofM' x d y e : ofe (cons G1 x A) M A))
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 weaken-ofe'' (Dappend x) (Dbounded x d y e) (DofM' x d y e) 
		    (DofM'' x d y e : ofe (G x) M A))
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 weaken-ofe (Dbounded x d y e) (DofM'' x d y e) _
		    (DofM''' x d y e : ofe (cons (G x) y (B x)) M A))
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 ofe-simp (simpctx/cons (DsimpB x) (Dsimpctx x y)) DsimpA (DofM''' x d y e)
		    (DofM'''' x d y e : ofes (scons (G' x y) y T) M S))
	   %% weaken and simplify DofR
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 weaken-aofe (Dbounded x d y e) (DofR x d) _
		    (DofR' x d y e : aofe (cons (G x) y (B x)) (R x) (B x)))
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		    aofe-simp (simpctx/cons (DsimpB x) (Dsimpctx x y)) (DsimpB x) (DofR' x d y e)
		       (DofR'' x d y e : aofes (scons (G' x y) y T) (R x) T))
	   %% simplify DofN
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		    ofe-simp (simpctx/cons (DsimpB x) (Dsimpctx x y)) (DsimpC x y) (DofN x d y e)
		       (DofN' x d y e : ofes (scons (G' x y) y T) (N x y) U))
	   %% go
	   <- ssub-x-permute-es
	      ([x] [d:isvar x I] [y] [e:isvar y J]
		 slookup/miss (Dlookup x d y e) (Dsbounded x d y e))
	      ([x] [d] [y] [e] slookup/hit (Dsbounded x d y e))
	      DofM'''' DofR''  DofN'
	      DsubNx DsubRx DsubNxy
	      (DsubNyx' : sub ([x] N x (R x)) M Nxy)
	   <- sub-fun DsubNyx' DsubNyx (Deq : term-eq Nxy Nyx).

%worlds (var | ovar | bind) (ssub-ao-permute-e _ _ _ _ _ _ _ _ _).
%total {} (ssub-ao-permute-e _ _ _ _ _ _ _ _ _).



ssub-ao-permute2-e : ({x} append (cons G1 x A) (G2 x) (G x))
		      -> ofe G1 M A
		      -> ({x} isvar x I -> aofe (G x) (R x) (B x))
		      -> ({x} isvar x I -> {y} isvar y J -> ofe (cons (cons (G x) y (B x)) Z (D x y)) (N x y) (C x y))
%%
		      -> ({y} sub ([x] N x y) M (Nx y))
		      -> aosub R M LRx
		      -> sub ([y] Nx y) LRx Nxy
		      -> sub ([x] N x (R x)) M Nyx
%%
		      -> term-eq Nxy Nyx -> type.
%mode ssub-ao-permute2-e +X1 +X2 +X3 +X4 +X5 +X6 +X7 +X8 -X9.

-	: ssub-ao-permute2-e
	   (Dappend : {x} append (cons G1 x A) (G2 x) (G x))
	   (DofM : ofe G1 M A)
	   (DofR : ({x} isvar x I -> aofe (G x) (R x) (B x)))
	   (DofN : ({x} isvar x I -> {y} isvar y J -> ofe (cons (cons (G x) y (B x)) Z (D x y)) (N x y) (C x y)))
%%
	   (DsubNx : ({y} sub ([x] N x y) M (Nx y)))
	   (DsubRx : aosub R M LRx)
	   (DsubNxy : sub ([y] Nx y) LRx Nxy)
	   (DsubNyx : sub ([x] N x (R x)) M Nyx)
%%
	   Deq
	   %% get context orderings
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 ofe-context (DofN x d y e) 
		 (ordered/cons
		    (bounded/cons
		       (Dbounded x d y e : bounded (G x) y)
		       (DprecedesYZ x d y e : precedes y Z))))
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 append-bounded (Dappend x) (Dbounded x d y e)
		    (bounded/cons
		       (Dbounded' x d y e : bounded G1 x)
		       (DprecedesXY x d y e : precedes x y)))
	   %% get simplifications
	   <- can-simp A (DsimpA : simp A S)
	   <- ({x} can-simp (B x) (DsimpB x : simp (B x) T))
	   <- ({x} {y} can-simp (C x y) (DsimpC x y : simp (C x y) U))
	   <- ({x} {y} can-simp (D x y) (DsimpD x y : simp (D x y) V))
	   <- ({y} {e:isvar y J}
		 context-append-simp-lookup Dappend ([x] [d] Dbounded x d y e) DsimpA
		    ([x] Dsimpctx x y : simpctx (G x) (G' x y))
		    ([x] [d] Dsbounded x d y e : sbounded (G' x y) y)
		    ([x] [d] Dlookup x d y e : slookup (G' x y) x S))
	   %% weaken and simplify DofM
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 weaken-ofe (Dbounded' x d y e) DofM _ 
		    (DofM' x d y e : ofe (cons G1 x A) M A))
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 weaken-ofe'' (Dappend x) (Dbounded x d y e) (DofM' x d y e) 
		    (DofM'' x d y e : ofe (G x) M A))
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 weaken-ofe (Dbounded x d y e) (DofM'' x d y e) _
		    (DofM''' x d y e : ofe (cons (G x) y (B x)) M A))
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 weaken-ofe (bounded/cons (Dbounded x d y e) (DprecedesYZ x d y e)) (DofM''' x d y e) _
		    (DofM'''' x d y e : ofe (cons (cons (G x) y (B x)) Z (D x y)) M A))
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 ofe-simp
		 (simpctx/cons (DsimpD x y) (simpctx/cons (DsimpB x) (Dsimpctx x y)))
		 DsimpA 
		 (DofM'''' x d y e)
		 (DofM''''' x d y e : ofes (scons (scons (G' x y) y T) Z V) M S))
	   %% weaken and simplify DofR
	   <- ({x} {d:isvar x I} {y} {e:isvar y J}
		 weaken-aofe (Dbounded x d y e) (DofR x d) _
		 (DofR' x d y e : aofe (cons (G x) y (B x)) (R x) (B x)))
	   <- ({x} {d:isvar x I} {y} {e:isvar y J}
		 weaken-aofe
		 (bounded/cons (Dbounded x d y e) (DprecedesYZ x d y e)) 
		 (DofR' x d y e) _
		 (DofR'' x d y e : aofe (cons (cons (G x) y (B x)) Z (D x y)) (R x) (B x)))
	   <- ({x} {d:isvar x I} {y} {e:isvar y J}
		 aofe-simp 
		 (simpctx/cons (DsimpD x y) (simpctx/cons (DsimpB x) (Dsimpctx x y)))
		 (DsimpB x) (DofR'' x d y e)
		 (DofR''' x d y e : aofes (scons (scons (G' x y) y T) Z V) (R x) T))
	   %% simplify DofN
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 ofe-simp 
		 (simpctx/cons (DsimpD x y) (simpctx/cons (DsimpB x) (Dsimpctx x y)))
		 (DsimpC x y) (DofN x d y e)
		 (DofN' x d y e : ofes (scons (scons (G' x y) y T) Z V) (N x y) U))
	   %% go
	   <- ssub-x-permute-es
	      ([x] [d:isvar x I] [y] [e:isvar y J]
		slookup/miss 
		 (slookup/miss (Dlookup x d y e) (Dsbounded x d y e)) 
		 (sbounded/cons (Dsbounded x d y e) (DprecedesYZ x d y e)))
	      ([x] [d] [y] [e] 
		 slookup/miss 
		 (slookup/hit (Dsbounded x d y e)) 
		 (sbounded/cons (Dsbounded x d y e) (DprecedesYZ x d y e)))
	      DofM''''' DofR'''  DofN'
	      DsubNx DsubRx DsubNxy
	      (DsubNyx' : sub ([x] N x (R x)) M Nxy)
	   <- sub-fun DsubNyx' DsubNyx (Deq : term-eq Nxy Nyx).

%worlds (var | ovar | bind) (ssub-ao-permute2-e _ _ _ _ _ _ _ _ _).
%total {} (ssub-ao-permute2-e _ _ _ _ _ _ _ _ _).



stsub-aa-permute-e : ({x} append (cons G1 x A) (G2 x) (G x))
		      -> ofe G1 M A
		      -> ({x} isvar x I -> aofe (G x) (R x) (B x))
		      -> ({x} isvar x I -> {y} isvar y J -> wfe (cons (G x) y (B x)) (C x y))
%%
		      -> ({y} tsub ([x] C x y) M (Cx y))
		      -> aasub R M Rx
		      -> tsub ([x] C x (R x)) M Cyx
%%
		      -> tp-eq (Cx Rx) Cyx -> type.
%mode stsub-aa-permute-e +X1 +X2 +X3 +X4 +X5 +X6 +X7 -X8.

-	: stsub-aa-permute-e
	   (Dappend : {x} append (cons G1 x A) (G2 x) (G x))
	   (DofM : ofe G1 M A)
	   (DofR : ({x} isvar x I -> aofe (G x) (R x) (B x)))
	   (DwfC : ({x} isvar x I -> {y} isvar y J -> wfe (cons (G x) y (B x)) (C x y)))
%%
	   (DsubCx : ({y} tsub ([x] C x y) M (Cx y)))
	   (DsubRx : aasub R M Rx)
	   (DsubCyx : tsub ([x] C x (R x)) M Cyx)
%%
	   Deq
	   %% get context orderings
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 wfe-context (DwfC x d y e) 
		    (ordered/cons
		       (Dbounded x d y e : bounded (G x) y)))
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 append-bounded (Dappend x) (Dbounded x d y e)
		    (bounded/cons
		       (Dbounded' x d y e : bounded G1 x)
		       (DprecedesXY x d y e : precedes x y)))
	   %% get simplifications
	   <- can-simp A (DsimpA : simp A S)
	   <- ({x} can-simp (B x) (DsimpB x : simp (B x) T))
	   <- ({y} {e:isvar y J}
		 context-append-simp-lookup Dappend ([x] [d] Dbounded x d y e) DsimpA
		    ([x] Dsimpctx x y : simpctx (G x) (G' x y))
		    ([x] [d] Dsbounded x d y e : sbounded (G' x y) y)
		    ([x] [d] Dlookup x d y e : slookup (G' x y) x S))
	   %% weaken and simplify DofM
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 weaken-ofe (Dbounded' x d y e) DofM _ 
		    (DofM' x d y e : ofe (cons G1 x A) M A))
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 weaken-ofe'' (Dappend x) (Dbounded x d y e) (DofM' x d y e) 
		    (DofM'' x d y e : ofe (G x) M A))
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 weaken-ofe (Dbounded x d y e) (DofM'' x d y e) _
		    (DofM''' x d y e : ofe (cons (G x) y (B x)) M A))
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 ofe-simp (simpctx/cons (DsimpB x) (Dsimpctx x y)) DsimpA (DofM''' x d y e)
		    (DofM'''' x d y e : ofes (scons (G' x y) y T) M S))
	   %% weaken and simplify DofR
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 weaken-aofe (Dbounded x d y e) (DofR x d) _
		    (DofR' x d y e : aofe (cons (G x) y (B x)) (R x) (B x)))
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		    aofe-simp (simpctx/cons (DsimpB x) (Dsimpctx x y)) (DsimpB x) (DofR' x d y e)
		       (DofR'' x d y e : aofes (scons (G' x y) y T) (R x) T))
	   %% simplify DofC
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		    wfe-simp (simpctx/cons (DsimpB x) (Dsimpctx x y)) (DwfC x d y e)
		       (DwfC' x d y e : wfes (scons (G' x y) y T) (C x y)))
	   %% go
	   <- stsub-z-permute-es
	      ([x] [d:isvar x I] [y] [e:isvar y J]
		 slookup/miss (Dlookup x d y e) (Dsbounded x d y e))
	      ([x] [d] [y] [e] slookup/hit (Dsbounded x d y e))
	      DofM'''' DofR''  DwfC'
	      DsubCx DsubRx
	      (DsubCyx' : tsub ([x] C x (R x)) M (Cx Rx))
	   <- tsub-fun DsubCyx' DsubCyx (Deq : tp-eq (Cx Rx) Cyx).

%worlds (var | ovar | bind) (stsub-aa-permute-e _ _ _ _ _ _ _ _).
%total {} (stsub-aa-permute-e _ _ _ _ _ _ _ _).



stsub-ao-permute-e : ({x} append (cons G1 x A) (G2 x) (G x))
		      -> ofe G1 M A
		      -> ({x} isvar x I -> aofe (G x) (R x) (B x))
		      -> ({x} isvar x I -> {y} isvar y J -> wfe (cons (G x) y (B x)) (C x y))
%%
		      -> ({y} tsub ([x] C x y) M (Cx y))
		      -> aosub R M LRx
		      -> tsub ([y] Cx y) LRx Cxy
		      -> tsub ([x] C x (R x)) M Cyx
%%
		      -> tp-eq Cxy Cyx -> type.
%mode stsub-ao-permute-e +X1 +X2 +X3 +X4 +X5 +X6 +X7 +X8 -X9.

-	: stsub-ao-permute-e
	   (Dappend : {x} append (cons G1 x A) (G2 x) (G x))
	   (DofM : ofe G1 M A)
	   (DofR : ({x} isvar x I -> aofe (G x) (R x) (B x)))
	   (DwfC : ({x} isvar x I -> {y} isvar y J -> wfe (cons (G x) y (B x)) (C x y)))
%%
	   (DsubCx : ({y} tsub ([x] C x y) M (Cx y)))
	   (DsubRx : aosub R M LRx)
	   (DsubCxy : tsub ([y] Cx y) LRx Cxy)
	   (DsubCyx : tsub ([x] C x (R x)) M Cyx)
%%
	   Deq
	   %% get context orderings
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 wfe-context (DwfC x d y e) 
		    (ordered/cons
		       (Dbounded x d y e : bounded (G x) y)))
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 append-bounded (Dappend x) (Dbounded x d y e)
		    (bounded/cons
		       (Dbounded' x d y e : bounded G1 x)
		       (DprecedesXY x d y e : precedes x y)))
	   %% get simplifications
	   <- can-simp A (DsimpA : simp A S)
	   <- ({x} can-simp (B x) (DsimpB x : simp (B x) T))
	   <- ({y} {e:isvar y J}
		 context-append-simp-lookup Dappend ([x] [d] Dbounded x d y e) DsimpA
		    ([x] Dsimpctx x y : simpctx (G x) (G' x y))
		    ([x] [d] Dsbounded x d y e : sbounded (G' x y) y)
		    ([x] [d] Dlookup x d y e : slookup (G' x y) x S))
	   %% weaken and simplify DofM
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 weaken-ofe (Dbounded' x d y e) DofM _ 
		    (DofM' x d y e : ofe (cons G1 x A) M A))
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 weaken-ofe'' (Dappend x) (Dbounded x d y e) (DofM' x d y e) 
		    (DofM'' x d y e : ofe (G x) M A))
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 weaken-ofe (Dbounded x d y e) (DofM'' x d y e) _
		    (DofM''' x d y e : ofe (cons (G x) y (B x)) M A))
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 ofe-simp (simpctx/cons (DsimpB x) (Dsimpctx x y)) DsimpA (DofM''' x d y e)
		    (DofM'''' x d y e : ofes (scons (G' x y) y T) M S))
	   %% weaken and simplify DofR
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 weaken-aofe (Dbounded x d y e) (DofR x d) _
		    (DofR' x d y e : aofe (cons (G x) y (B x)) (R x) (B x)))
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		    aofe-simp (simpctx/cons (DsimpB x) (Dsimpctx x y)) (DsimpB x) (DofR' x d y e)
		       (DofR'' x d y e : aofes (scons (G' x y) y T) (R x) T))
	   %% simplify DofC
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		    wfe-simp (simpctx/cons (DsimpB x) (Dsimpctx x y)) (DwfC x d y e)
		       (DwfC' x d y e : wfes (scons (G' x y) y T) (C x y)))
	   %% go
	   <- stsub-x-permute-es
	      ([x] [d:isvar x I] [y] [e:isvar y J]
		 slookup/miss (Dlookup x d y e) (Dsbounded x d y e))
	      ([x] [d] [y] [e] slookup/hit (Dsbounded x d y e))
	      DofM'''' DofR''  DwfC'
	      DsubCx DsubRx DsubCxy
	      (DsubCyx' : tsub ([x] C x (R x)) M Cxy)
	   <- tsub-fun DsubCyx' DsubCyx (Deq : tp-eq Cxy Cyx).

%worlds (var | ovar | bind) (stsub-ao-permute-e _ _ _ _ _ _ _ _ _).
%total {} (stsub-ao-permute-e _ _ _ _ _ _ _ _ _).




%%%%%  Substitution Lemma (Explicit Context)  %%%%%

aasubst-em : {T:stp}
	       simp A T
%%
	       -> ({x} append (cons G1 x A) (G2 x) (G x))
	       -> csub G M G'
	       -> ofe G1 M A
	       -> aasub R M R'
	       -> tsub B M B'
	       -> ({x} isvar x I -> aofe (G x) (R x) (B x))
%%
	       -> aofe G' R' B' -> type.
%mode aasubst-em +T +X0 +X1 +X2 +X3 +X4 +X5 +X6 -X7.

aosubst-em : {T:stp}
	       simp A T
%%
	       -> ({x} append (cons G1 x A) (G2 x) (G x))
	       -> csub G M G'
	       -> ofe G1 M A
	       -> aosub R M N
	       -> tsub B M B'
	       -> ({x} isvar x I -> aofe (G x) (R x) (B x))
%%
	       -> ofe G' N B' -> type.
%mode aosubst-em +T +X0 +X1 +X2 +X3 +X4 +X5 +X6 -X7.

subst-em : {T:stp}
	     simp A T
%%
	     -> ({x} append (cons G1 x A) (G2 x) (G x))
	     -> csub G M G'
	     -> ofe G1 M A
	     -> sub N M N'
	     -> tsub B M B'
	     -> ({x} isvar x I -> ofe (G x) (N x) (B x))
%%
	     -> ofe G' N' B' -> type.
%mode subst-em +T +X0 +X1 +X2 +X3 +X4 +X5 +X6 -X7.

tsubst-em : {T:stp}
	      simp A T
%%
	      -> ({x} append (cons G1 x A) (G2 x) (G x))
	      -> csub G M G'
	      -> ofe G1 M A
	      -> tsub B M B'
	      -> ({x} isvar x I -> wfe (G x) (B x))
%%
	      -> wfe G' B' -> type.
%mode tsubst-em +T +X0 +X1 +X2 +X3 +X4 +X5 -X6.

-closed	: aasubst-em _ _
	   (Dapp : {x} append (cons G1 x A) (G2 x) (G x))
	   (Dcsub : csub G M G')
	   (DofM : ofe G1 M A)
	   (Dsub : aasub R M Rx)
	   (Dtsub : tsub B M Bx)
	   ([x] [d:isvar x I] aofe/closed
	      (Dordered x d : ordered (G x))
	      (Dof x : aof (R x) (B x)))
	   (aofe/closed Dordered' Dof'')
	   <- csub-ordered Dordered Dcsub (Dordered' : ordered G')
	   <- aof-noassm Dof (DeqR : {x} atom-eq (R x) R') (DeqB : {x} tp-eq (B x) B')
	   <- aasub-resp DeqR term-eq/i atom-eq/i Dsub (Dsub' : aasub ([_] R') M Rx)
	   <- tsub-resp DeqB term-eq/i tp-eq/i Dtsub (Dtsub' : tsub ([_] B') M Bx)
	   <- aasub-absent R' M (Dsub'' : aasub ([_] R') M R')
	   <- tsub-absent B' M (Dtsub'' : tsub ([_] B') M B')
	   <- aasub-fun Dsub'' Dsub' (DeqR' : atom-eq R' Rx)
	   <- tsub-fun Dtsub'' Dtsub' (DeqB' : tp-eq B' Bx)
	   <- ({x} aof-resp (DeqR x) (DeqB x) (Dof x) (Dof' x : aof R' B'))
	   <- aof-resp DeqR' DeqB' (Dof' aca) (Dof'' : aof Rx Bx).

-closed	: aosubst-em _ _
	   (Dapp : {x} append (cons G1 x A) (G2 x) (G x))
	   (Dcsub : csub G M G')
	   (DofM : ofe G1 M A)
	   (Dsub : aosub R M N)
	   (Dtsub : tsub B M Bx)
	   ([x] [d:isvar x I] aofe/closed 
	      (_ : ordered (G x)) 
	      (Dof x : aof (R x) (B x)))
	   D
	   <- aof-noassm Dof (DeqR : {x} atom-eq (R x) R') _
	   <- aosub-resp DeqR term-eq/i term-eq/i Dsub (Dsub' : aosub ([-] R') M N)
	   <- aosub-absent Dsub' Dfalse
	   <- false-implies-ofe Dfalse D.

-forall	: aasubst-em T (Dsimp : simp A T)
	   (Dapp : {x} append (cons G1 x A) (G2 x) (G x))
	   (Dcsub : csub G M G')
	   (DofM : ofe G1 M A)
	   (aasub/forall (Dsub : tsub B M Bx))
	   (tsub/pi
	      ([_] tsub/t)
	      (tsub/pi
		 ([_] tsub/t)
		 (Dsub' : tsub B M Bx')))
	   ([x] [d:isvar x I] aofe/forall (Dwf x d : wfe (G x) (B x)))
	   D
	   <- tsubst-em T Dsimp Dapp Dcsub DofM Dsub Dwf (Dwf' : wfe G' Bx)
	   <- tsub-fun Dsub Dsub' (Deq : tp-eq Bx Bx')
	   <- tp-resp-tp ([a] pi (pi a ([_] t)) ([_] t)) Deq Deq'
	   <- aofe-resp ctx-eq/i atom-eq/i Deq' (aofe/forall Dwf') D.

-allcl	: aasubst-em T (Dsimp : simp A T)
	   (Dapp : {x} append (cons G1 x A) (G2 x) (G x))
	   (Dcsub : csub G M G')
	   (DofM : ofe G1 M A)
	   aasub/closed
	   (tsub/pi
	      ([_] tsub/t)
	      (tsub/pi
		 ([_] tsub/t)
		 (Dsub : tsub ([_] B) M Bx)))
	   ([x] [d:isvar x I] aofe/forall (Dwf x d : wfe (G x) B))
	   D
	   <- tsubst-em T Dsimp Dapp Dcsub DofM Dsub Dwf (Dwf' : wfe G' Bx)
	   <- tsub-absent-fun Dsub (Deq : tp-eq Bx B)
	   <- atom-resp-tp forall Deq Deq'
	   <- aofe-resp ctx-eq/i Deq' tp-eq/i (aofe/forall Dwf') D.

-allbad	: aasubst-em _ _ _ _ _ (aasub/forall _) _ ([x] [d] aofe/var _ (Dlookup x d)) D
	   <- ({x} {d:isvar x I}
		 lookup-isvar (Dlookup x d) (Disvar x : isvar (forall _) J))
	   <- ({x} isvar-forall-contra (Disvar x) Dfalse)
	   <- false-implies-aofe Dfalse D.

-var	: aasubst-em T (Dsimp : simp A T)
	   (Dapp : {x} append (cons G1 x A) (G2 x) (G x))
	   (Dcsub : csub G M G')
	   (DofM : ofe G1 M A)
	   aasub/closed
	   (DsubBx : tsub B M Bx)
	   ([x] [d] aofe/var
	      (Dwf x d : wfe (G x) (B x))
	      (Dlookup x d : lookup (G x) X (B x)))
	   (aofe/var DwfBx Dlookup')
	   <- csub-lookup Dcsub Dlookup DsubBx
	      (Dlookup' : lookup G' X Bx)
	   <- tsubst-em T Dsimp Dapp Dcsub DofM DsubBx Dwf
	      (DwfBx : wfe G' Bx).

-var	: aosubst-em _ _
	   (Dapp : {x} append (cons G1 x A) (G2 x) (G x))
	   (Dcsub : csub G M G')
	   (DofM : ofe G1 M A)
	   aosub/var
	   (Dtsub : tsub B M Bx)
	   ([x] [d:isvar x I] aofe/var _ (Dlook x d : lookup (G x) x (B x)))
	   DofM''
	   <- ({x} {d:isvar x I}
		 lookup-binder-fun (Dapp x) (Dlook x d) (Deq x : tp-eq A (B x)))
	   <- tsub-absent A M (Dtsub' : tsub ([-] A) M A)
	   <- tsub-resp Deq term-eq/i tp-eq/i Dtsub' (Dtsub'' : tsub B M A)
	   <- tsub-fun Dtsub'' Dtsub (Deq' : tp-eq A Bx)
	   <- ({x} {d:isvar x I}
		 lookup-context (Dlook x d) (Dordered x d : ordered (G x)))
	   <- weaken-ofe-csub Dapp Dordered Dcsub DofM (DofM' : ofe G' M A)
	   <- ofe-resp ctx-eq/i term-eq/i Deq' DofM' (DofM'' : ofe G' M Bx).

-app	: aasubst-em T (Dsimp : simp A T)
	   (Dapp : {x} append (cons G1 x A) (G2 x) (G x))
	   (Dcsub : csub G M G')
	   (DofM : ofe G1 M A)
	   (aasub/app
	      (DsubN' : sub N M N')
	      (DsubR' : aasub R M R'))
	   (DtsubCyx : tsub Cy M Cyx)
	   ([x] [d:isvar x I] aofe/app
	      (DwfCy x d : wfe (G x) (Cy x))
	      (DtsubCy x : tsub ([y] C x y) (N x) (Cy x))
	      (DofN x d : ofe (G x) (N x) (B x))
	      (DofR x d : aofe (G x) (R x) (pi (B x) ([y] C x y)))
	      : aofe (G x) (app (R x) (N x)) (Cy x))
	   (aofe/app DwfCyx DtsubCxy' DofN' DofR')
	   <- ({x} {d:isvar x I}
		 aofe-reg (DofR x d) (wfe/pi
					   (DwfC x d : {y} isvar y J -> wfe (cons (G x) y (B x)) (C x y))
					   (DwfB x d : wfe (G x) (B x))))
	   <- can-tsub-e Dapp DwfB DofM (DtsubBx : tsub ([x] B x) M Bx)
	   <- ({y} {e:isvar y J}
		 can-tsub-e ([x] append/cons (Dapp x)) ([x] [d] DwfC x d y e) DofM 
		    (DtsubCx y : tsub ([x] C x y) M (Cx y)))
	   <- aasubst-em T Dsimp Dapp Dcsub DofM DsubR' 
	      (tsub/pi DtsubCx DtsubBx : tsub ([x] pi (B x) ([y] C x y)) M (pi Bx ([y] Cx y)))
	      DofR
	      (DofR' : aofe G' R' (pi Bx Cx))
	   <- subst-em T Dsimp Dapp Dcsub DofM DsubN' DtsubBx DofN (DofN' : ofe G' N' Bx)
	   <- aofe-reg DofR' (wfe/pi 
				(DwfCx : {y} isvar y J' -> wfe (cons G' y Bx) (Cx y))
				(DwfBx : wfe G' Bx))
	   <- can-tsub-e ([y] append/nil) DwfCx DofN' (DtsubCxy : tsub ([y] Cx y) N' Cxy)
	   <- tsub-permute-e Dapp DofM DofN DwfC DtsubCx DsubN' DtsubCxy DtsubCy DtsubCyx (Deq : tp-eq Cxy Cyx)
	   <- tsub-resp ([-] tp-eq/i) term-eq/i Deq DtsubCxy (DtsubCxy' : tsub Cx N' Cyx)
	   <- tsubst-em T Dsimp Dapp Dcsub DofM DtsubCyx DwfCy (DwfCyx : wfe G' Cyx).

-appclo	: aasubst-em T (Dsimp : simp A T)
	   (Dapp : {x} append (cons G1 x A) (G2 x) (G x))
	   (Dcsub : csub G M G')
	   (DofM : ofe G1 M A)
	   aasub/closed
	   (DtsubCyx : tsub Cy M Cyx)
	   ([x] [d:isvar x I] aofe/app
	      (DwfCy x d : wfe (G x) (Cy x))
	      (DtsubCy x : tsub ([y] C x y) N (Cy x))
	      (DofN x d : ofe (G x) N (B x))
	      (DofR x d : aofe (G x) R (pi (B x) ([y] C x y)))
	      : aofe (G x) (app R N) (Cy x))
	   (aofe/app DwfCyx DtsubCxy' DofN' DofR')
	   <- ({x} {d:isvar x I}
		 aofe-reg (DofR x d) (wfe/pi
					   (DwfC x d : {y} isvar y J -> wfe (cons (G x) y (B x)) (C x y))
					   (DwfB x d : wfe (G x) (B x))))
	   <- can-tsub-e Dapp DwfB DofM (DtsubBx : tsub ([x] B x) M Bx)
	   <- ({y} {e:isvar y J}
		 can-tsub-e ([x] append/cons (Dapp x)) ([x] [d] DwfC x d y e) DofM 
		    (DtsubCx y : tsub ([x] C x y) M (Cx y)))
	   <- aasubst-em T Dsimp Dapp Dcsub DofM aasub/closed
	      (tsub/pi DtsubCx DtsubBx : tsub ([x] pi (B x) ([y] C x y)) M (pi Bx ([y] Cx y)))
	      DofR
	      (DofR' : aofe G' R (pi Bx Cx))
	   <- sub-absent N M
	      (DsubN' : sub ([_] N) M N)
	   <- subst-em T Dsimp Dapp Dcsub DofM DsubN' DtsubBx DofN (DofN' : ofe G' N Bx)
	   <- aofe-reg DofR' (wfe/pi 
				(DwfCx : {y} isvar y J' -> wfe (cons G' y Bx) (Cx y))
				(DwfBx : wfe G' Bx))
	   <- can-tsub-e ([y] append/nil) DwfCx DofN' (DtsubCxy : tsub ([y] Cx y) N Cxy)
	   <- tsub-permute-e Dapp DofM DofN DwfC DtsubCx DsubN' DtsubCxy DtsubCy DtsubCyx (Deq : tp-eq Cxy Cyx)
	   <- tsub-resp ([-] tp-eq/i) term-eq/i Deq DtsubCxy (DtsubCxy' : tsub Cx N Cyx)
	   <- tsubst-em T Dsimp Dapp Dcsub DofM DtsubCyx DwfCy (DwfCyx : wfe G' Cyx).

-app	: aosubst-em T (Dsimp : simp A T)
	   (Dapp : {x} append (cons G1 x A) (G2 x) (G x))
	   (Dcsub : csub G M G')
	   (DofM : ofe G1 M A)
	   (aosub/app
	      (DsubN2 : sub N1 Nx N2)
	      (DsubNx : sub N M Nx)
	      (DsubN1 : aosub R M (lam N1)))
	   (DtsubCyx : tsub Cy M Cyx)
	   ([x] [d:isvar x I] aofe/app
	      (DwfCy x d : wfe (G x) (Cy x))
	      (DtsubCy x : tsub ([y] C x y) (N x) (Cy x))
	      (DofN x d : ofe (G x) (N x) (B x))
	      (DofR x d : aofe (G x) (R x) (pi (B x) ([y] C x y)))
	      : aofe (G x) (app (R x) (N x)) (Cy x))
	   DofN2'
	   <- ({x} {d:isvar x I}
		 aofe-reg (DofR x d) (wfe/pi
					   (DwfC x d : {y} isvar y J -> wfe (cons (G x) y (B x)) (C x y))
					   (DwfB x d : wfe (G x) (B x))))
	   <- can-tsub-e Dapp DwfB DofM (DtsubBx : tsub ([x] B x) M Bx)
	   <- ({y} {e:isvar y J}
		 can-tsub-e ([x] append/cons (Dapp x)) ([x] [d] DwfC x d y e) DofM (DtsubCx y : tsub ([x] C x y) M (Cx y)))
	   <- aosubst-em T Dsimp Dapp Dcsub DofM DsubN1
	      (tsub/pi DtsubCx DtsubBx : tsub ([x] pi (B x) ([y] C x y)) M (pi Bx ([y] Cx y)))
	      DofR
	      (ofe/lam
		 (DofN1 : {y} isvar y J' -> ofe (cons G' y Bx) (N1 y) (Cx y))
		 (DwfBx : wfe G' Bx))
	   <- subst-em T Dsimp Dapp Dcsub DofM DsubNx DtsubBx DofN (DofNx : ofe G' Nx Bx)
	   <- ({y} {e:isvar y J'}
		 ofe-reg (DofN1 y e) (DwfCx y e : wfe (cons G' y Bx) (Cx y)))
	   <- can-tsub-e ([-] append/nil) DwfCx DofNx (DtsubCxy : tsub Cx Nx Cxy)
	   %% must convince Twelf that we're inducting on a smaller argument
	   <- aosub-headvar DsubN1 (Dheadvar : headvar R)
	   <- headvar-tp-size Dapp DofR Dsimp Dheadvar
	      ([x] simp/pi ([y] Dsimp2 x y : simp (C x y) T2) (Dsimp1 x : simp (B x) T1))
	      (Dleq : stp-leq (spi T1 T2) T)
	   <- tsub-preserves-simp DtsubBx Dsimp1 (Dsimp1' : simp Bx T1)
	   <- employ-stp-leq (spi T1 T2) T Dleq
	   %% Twelf now believes that (spi T1 T2) <= T, so T1 < T
	   <- subst-em T1 Dsimp1' ([_] append/nil) csub/base DofNx DsubN2 DtsubCxy DofN1
	      (DofN2 : ofe G' N2 Cxy)
	   <- tsub-permute-e Dapp DofM DofN DwfC DtsubCx DsubNx DtsubCxy DtsubCy DtsubCyx (Deq : tp-eq Cxy Cyx)
	   <- ofe-resp ctx-eq/i term-eq/i Deq DofN2 (DofN2' : ofe G' N2 Cyx).

-appbad	: aasubst-em _ _ _ _ _ (aasub/app _ _) _ ([x] [d] aofe/var _ (Dlookup x d)) D
	   <- ({x} {d:isvar x I}
		 lookup-isvar (Dlookup x d) (Disvar x : isvar (app _ _) J))
	   <- ({x} isvar-app-contra (Disvar x) Dfalse)
	   <- false-implies-aofe Dfalse D.

-appbad	: aosubst-em _ _ _ _ _ (aosub/app _ _ _) _ ([x] [d] aofe/var _ (Dlookup x d)) D
	   <- ({x} {d:isvar x I}
		 lookup-isvar (Dlookup x d) (Disvar x : isvar (app _ _) J))
	   <- ({x} isvar-app-contra (Disvar x) Dfalse)
	   <- false-implies-ofe Dfalse D.

-pi1	: aasubst-em T (Dsimp : simp A T)
	   (Dapp : {x} append (cons G1 x A) (G2 x) (G x))
	   (Dcsub : csub G M G')
	   (DofM : ofe G1 M A)
	   (aasub/pi1 (Dsub : aasub R M R'))
	   (DtsubBx : tsub B M Bx)
	   ([x] [d:isvar x I] aofe/pi1 (Dof x d : aofe (G x) (R x) (sigma (B x) ([y] C x y))))
	   (aofe/pi1 Dof')
	   <- ({x} {d:isvar x I}
		 aofe-reg (Dof x d) (wfe/sigma
				       (DwfC x d : {y} isvar y J -> wfe (cons (G x) y (B x)) (C x y))
				       (DwfB x d : wfe (G x) (B x))))
	   <- ({y} {e:isvar y J}
		 can-tsub-e ([x] append/cons (Dapp x)) ([x] [d] DwfC x d y e) DofM (DtsubCx y : tsub ([x] C x y) M (Cx y)))
	   <- aasubst-em T Dsimp Dapp Dcsub DofM Dsub 
	      (tsub/sigma DtsubCx DtsubBx : tsub ([x] sigma (B x) ([y] C x y)) M (sigma Bx ([y] Cx y)))
	      Dof 
	      (Dof' : aofe G' R' (sigma Bx ([y] Cx y))).

-pi1clo	: aasubst-em T (Dsimp : simp A T)
	   (Dapp : {x} append (cons G1 x A) (G2 x) (G x))
	   (Dcsub : csub G M G')
	   (DofM : ofe G1 M A)
	   aasub/closed
	   (DtsubBx : tsub B M Bx)
	   ([x] [d:isvar x I] 
	      aofe/pi1 
	      (Dof x d : aofe (G x) R (sigma (B x) ([y] C x y))))
	   (aofe/pi1 Dof')
	   <- ({x} {d:isvar x I}
		 aofe-reg (Dof x d) (wfe/sigma
				       (DwfC x d : {y} isvar y J -> wfe (cons (G x) y (B x)) (C x y))
				       (DwfB x d : wfe (G x) (B x))))
	   <- ({y} {e:isvar y J}
		 can-tsub-e ([x] append/cons (Dapp x)) ([x] [d] DwfC x d y e) DofM (DtsubCx y : tsub ([x] C x y) M (Cx y)))
	   <- aasubst-em T Dsimp Dapp Dcsub DofM aasub/closed
	      (tsub/sigma DtsubCx DtsubBx : tsub ([x] sigma (B x) ([y] C x y)) M (sigma Bx ([y] Cx y)))
	      Dof 
	      (Dof' : aofe G' R (sigma Bx ([y] Cx y))).

-pi1	: aosubst-em T (Dsimp : simp A T)
	   (Dapp : {x} append (cons G1 x A) (G2 x) (G x))
	   (Dcsub : csub G M G')
	   (DofM : ofe G1 M A)
	   (aosub/pi1 (Dsub : aosub R M (pair N1 N2)))
	   (DtsubBx : tsub B M Bx)
	   ([x] [d:isvar x I] aofe/pi1 (Dof x d : aofe (G x) (R x) (sigma (B x) ([y] C x y))))
	   Dof1
	   <- ({x} {d:isvar x I}
		 aofe-reg (Dof x d) (wfe/sigma
					  (DwfC x d : {y} isvar y J -> wfe (cons (G x) y (B x)) (C x y))
					  (DwfB x d : wfe (G x) (B x))))
	   <- ({y} {e:isvar y J}
		 can-tsub-e ([x] append/cons (Dapp x)) ([x] [d] DwfC x d y e) DofM (DtsubCx y : tsub ([x] C x y) M (Cx y)))
	   <- aosubst-em T Dsimp Dapp Dcsub DofM Dsub 
	      (tsub/sigma DtsubCx DtsubBx : tsub ([x] sigma (B x) ([y] C x y)) M (sigma Bx ([y] Cx y)))
	      Dof 
	      (ofe/pair _ _ _ (Dof1 : ofe G' N1 Bx)).

-pi1bad	: aasubst-em _ _ _ _ _ (aasub/pi1 _) _ ([x] [d] aofe/var _ (Dlookup x d)) D
	   <- ({x} {d:isvar x I}
		 lookup-isvar (Dlookup x d) (Disvar x : isvar (pi1 _) J))
	   <- ({x} isvar-pi1-contra (Disvar x) Dfalse)
	   <- false-implies-aofe Dfalse D.

-pi1bad	: aosubst-em _ _ _ _ _ (aosub/pi1 _) _ ([x] [d] aofe/var _ (Dlookup x d)) D
	   <- ({x} {d:isvar x I}
		 lookup-isvar (Dlookup x d) (Disvar x : isvar (pi1 _) J))
	   <- ({x} isvar-pi1-contra (Disvar x) Dfalse)
	   <- false-implies-ofe Dfalse D.

-pi2	: aasubst-em T (Dsimp : simp A T)
	   (Dapp : {x} append (cons G1 x A) (G2 x) (G x))
	   (Dcsub : csub G M G')
	   (DofM : ofe G1 M A)
	   (aasub/pi2 (Dsub : aasub R M R'))
	   (DtsubCyx : tsub ([x] C x (pi1 (R x))) M Cyx)
	   ([x] [d:isvar x I] 
	      aofe/pi2 
	      (Dof x d : aofe (G x) (R x) (sigma (B x) ([y] C x y))))
	   Dof''
	   <- ({x} {d:isvar x I}
		 aofe-reg (Dof x d) 
		    (wfe/sigma
		       (DwfC x d : {y} isvar y J -> wfe (cons (G x) y (B x)) (C x y))
		       (DwfB x d : wfe (G x) (B x))))
	   <- can-tsub-e Dapp DwfB DofM (DtsubBx : tsub ([x] B x) M Bx)
	   <- ({y} {e:isvar y J}
		 can-tsub-e ([x] append/cons (Dapp x)) ([x] [d] DwfC x d y e) DofM 
		    (DtsubCx y : tsub ([x] C x y) M (Cx y)))
	   <- aasubst-em T Dsimp Dapp Dcsub DofM Dsub 
	      (tsub/sigma DtsubCx DtsubBx : tsub ([x] sigma (B x) ([y] C x y)) M (sigma Bx ([y] Cx y)))
	      Dof 
	      (Dof' : aofe G' R' (sigma Bx ([y] Cx y)))
	   <- stsub-aa-permute-e Dapp DofM ([x] [d] aofe/pi1 (Dof x d)) DwfC DtsubCx (aasub/pi1 Dsub) DtsubCyx (Deq : tp-eq (Cx (pi1 R')) Cyx)
	   <- aofe-resp ctx-eq/i atom-eq/i Deq (aofe/pi2 Dof') (Dof'' : aofe G' (pi2 R') Cyx).

-pi2clo	: aasubst-em T (Dsimp : simp A T)
	   (Dapp : {x} append (cons G1 x A) (G2 x) (G x))
	   (Dcsub : csub G M G')
	   (DofM : ofe G1 M A)
	   aasub/closed
	   (DtsubCyx : tsub ([x] C x (pi1 R)) M Cyx)
	   ([x] [d:isvar x I] 
	      aofe/pi2 
	      (Dof x d : aofe (G x) R (sigma (B x) ([y] C x y))))
	   Dof''
	   <- ({x} {d:isvar x I}
		 aofe-reg (Dof x d) 
		    (wfe/sigma
		       (DwfC x d : {y} isvar y J -> wfe (cons (G x) y (B x)) (C x y))
		       (DwfB x d : wfe (G x) (B x))))
	   <- can-tsub-e Dapp DwfB DofM (DtsubBx : tsub ([x] B x) M Bx)
	   <- ({y} {e:isvar y J}
		 can-tsub-e ([x] append/cons (Dapp x)) ([x] [d] DwfC x d y e) DofM 
		    (DtsubCx y : tsub ([x] C x y) M (Cx y)))
	   <- aasubst-em T Dsimp Dapp Dcsub DofM aasub/closed
	      (tsub/sigma DtsubCx DtsubBx : tsub ([x] sigma (B x) ([y] C x y)) M (sigma Bx ([y] Cx y)))
	      Dof 
	      (Dof' : aofe G' R (sigma Bx ([y] Cx y)))
	   <- stsub-aa-permute-e Dapp DofM ([x] [d] aofe/pi1 (Dof x d)) DwfC DtsubCx aasub/closed DtsubCyx (Deq : tp-eq (Cx (pi1 R)) Cyx)
	   <- aofe-resp ctx-eq/i atom-eq/i Deq (aofe/pi2 Dof') (Dof'' : aofe G' (pi2 R) Cyx).

-pi2	: aosubst-em T (Dsimp : simp A T)
	   (Dapp : {x} append (cons G1 x A) (G2 x) (G x))
	   (Dcsub : csub G M G')
	   (DofM : ofe G1 M A)
	   (aosub/pi2 (Dsub : aosub R M (pair N1 N2)))
	   (DtsubCyx : tsub ([x] C x (pi1 (R x))) M Cyx)
	   ([x] [d:isvar x I] aofe/pi2 (Dof x d : aofe (G x) (R x) (sigma (B x) ([y] C x y))))
	   DofN2'
	   <- ({x} {d:isvar x I}
		 aofe-reg (Dof x d) (wfe/sigma
					  (DwfC x d : {y} isvar y J -> wfe (cons (G x) y (B x)) (C x y))
					  (DwfB x d : wfe (G x) (B x))))
	   <- can-tsub-e Dapp DwfB DofM (DtsubBx : tsub ([x] B x) M Bx)
	   <- ({y} {e:isvar y J}
		 can-tsub-e ([x] append/cons (Dapp x)) ([x] [d] DwfC x d y e) DofM (DtsubCx y : tsub ([x] C x y) M (Cx y)))
	   <- aosubst-em T Dsimp Dapp Dcsub DofM Dsub 
	      (tsub/sigma DtsubCx DtsubBx : tsub ([x] sigma (B x) ([y] C x y)) M (sigma Bx ([y] Cx y)))
	      Dof 
	      (ofe/pair
		 (DwfCx : {y} isvar y J' -> wfe (cons G' y Bx) (Cx y))
		 (DofN2 : ofe G' N2 Cxy)
		 (DtsubCxy : tsub Cx N1 Cxy)
		 (DofN1 : ofe G' N1 Bx)
		 : ofe G' (pair N1 N2) (sigma Bx ([y] Cx y)))
	   <- stsub-ao-permute-e Dapp DofM ([x] [d] aofe/pi1 (Dof x d)) DwfC DtsubCx (aosub/pi1 Dsub) DtsubCxy DtsubCyx (Deq : tp-eq Cxy Cyx)
	   <- ofe-resp ctx-eq/i term-eq/i Deq DofN2 (DofN2' : ofe G' N2 Cyx).

-pi2bad	: aasubst-em _ _ _ _ _ (aasub/pi2 _) _ ([x] [d] aofe/var _ (Dlookup x d)) D
	   <- ({x} {d:isvar x I}
		 lookup-isvar (Dlookup x d) (Disvar x : isvar (pi2 _) J))
	   <- ({x} isvar-pi2-contra (Disvar x) Dfalse)
	   <- false-implies-aofe Dfalse D.

-pi2bad	: aosubst-em _ _ _ _ _ (aosub/pi2 _) _ ([x] [d] aofe/var _ (Dlookup x d)) D
	   <- ({x} {d:isvar x I}
		 lookup-isvar (Dlookup x d) (Disvar x : isvar (pi2 _) J))
	   <- ({x} isvar-pi2-contra (Disvar x) Dfalse)
	   <- false-implies-ofe Dfalse D.

-at-a	: subst-em T (Dsimp : simp A T)
	   (Dapp : {x} append (cons G1 x A) (G2 x) (G x))
	   (Dcsub : csub G M G')
	   (DofM : ofe G1 M A)
	   (sub/aa (Dsub : aasub R M R'))
	   tsub/t
	   ([x] [d:isvar x I] ofe/at (Dof x d : aofe (G x) (R x) t))
	   (ofe/at Dof')
	   <- aasubst-em T Dsimp Dapp Dcsub DofM Dsub tsub/t Dof (Dof' : aofe G' R' t).

-at-o	: subst-em T (Dsimp : simp A T)
	   (Dapp : {x} append (cons G1 x A) (G2 x) (G x))
	   (Dcsub : csub G M G')
	   (DofM : ofe G1 M A)
	   (sub/ao (Dsub : aosub R M N))
	   tsub/t
	   ([x] [d:isvar x I] ofe/at (Dof x d : aofe (G x) (R x) t))
	   Dof'
	   <- aosubst-em T Dsimp Dapp Dcsub DofM Dsub tsub/t Dof (Dof' : ofe G' N t).

-lam	: subst-em T (Dsimp : simp A T)
	   (Dapp : {x} append (cons G1 x A) (G2 x) (G x))
	   (Dcsub : csub G M G')
	   (DofM : ofe G1 M A)
	   (sub/lam (Dsub : {y} sub ([x] N x y) M (N' y)))
	   (tsub/pi
	      (Dtsub2 : {y} tsub ([x] B2 x y) M (B2' y))
	      (Dtsub1 : tsub B1 M B1'))
	   ([x] [d:isvar x I] ofe/lam 
	      ([y] [e:isvar y J] Dof x d y e : ofe (cons (G x) y (B1 x)) (N x y) (B2 x y))
	      (Dwf x d : wfe (G x) (B1 x)))
	   (ofe/lam Dof' Dwf')
	   <- tsubst-em T Dsimp Dapp Dcsub DofM Dtsub1 Dwf (Dwf' : wfe G' B1')
	   <- ({y} {e:isvar y J}
		 subst-em T Dsimp ([x] append/cons (Dapp x)) (csub/cons Dtsub1 Dcsub) DofM (Dsub y) (Dtsub2 y) ([x] [d] Dof x d y e)
		    (Dof' y e : ofe (cons G' y B1') (N' y) (B2' y))).

-pair	: subst-em T (Dsimp : simp A T)
	   (Dapp : {x} append (cons G1 x A) (G2 x) (G x))
	   (Dcsub : csub G M Gx)
	   (DofM : ofe G1 M A)
	   (sub/pair (Dsub2 : sub N2 M N2x) (Dsub1 : sub N1 M N1x))
	   (tsub/sigma
	      (Dtsub2x : {y} tsub ([x] B2 x y) M (B2x y))
	      (Dtsub1 : tsub B1 M B1x))
	   ([x] [d:isvar x I] ofe/pair
	      ([y] [e:isvar y J] Dwf x d y e : wfe (cons (G x) y (B1 x)) (B2 x y))
	      (Dof2 x d : ofe (G x) (N2 x) (B2y x))
	      (Dtsub2y x : tsub ([y] B2 x y) (N1 x) (B2y x))
	      (Dof1 x d : ofe (G x) (N1 x) (B1 x)))
	   (ofe/pair Dwf-x Dof2x' Dtsub2xy Dof1x)
	   <- subst-em T Dsimp Dapp Dcsub DofM Dsub1 Dtsub1 Dof1 (Dof1x : ofe Gx N1x B1x)
	   <- ({y} {e:isvar y J}
		 tsubst-em T Dsimp ([x] append/cons (Dapp x)) (csub/cons Dtsub1 Dcsub) DofM (Dtsub2x y) ([x] [d] Dwf x d y e)
		    (Dwf-x y e : wfe (cons Gx y B1x) (B2x y)))
	   <- can-tsub-e ([x] append/nil) Dwf-x Dof1x (Dtsub2xy : tsub B2x N1x B2xy)
	   <- ({x} {d:isvar x I}
		 ofe-reg (Dof2 x d) (Dwf-y x d : wfe (G x) (B2y x)))
	   <- can-tsub-e Dapp Dwf-y DofM (Dtsub2yx : tsub B2y M B2yx)
	   <- subst-em T Dsimp Dapp Dcsub DofM Dsub2 Dtsub2yx Dof2 (Dof2x : ofe Gx N2x B2yx)
	   <- tsub-permute-e Dapp DofM Dof1 Dwf Dtsub2x Dsub1 Dtsub2xy Dtsub2y Dtsub2yx (Deq : tp-eq B2xy B2yx)
	   <- tp-eq-symm Deq (Deq' : tp-eq B2yx B2xy)
	   <- ofe-resp ctx-eq/i term-eq/i Deq' Dof2x (Dof2x' : ofe Gx N2x B2xy).

-sing-a	: subst-em T (Dsimp : simp A T)
	   (Dapp : {x} append (cons G1 x A) (G2 x) (G x))
	   (Dcsub : csub G M G')
	   (DofM : ofe G1 M A)
	   (sub/aa (Dsub : aasub R M R'))
	   (tsub/singa (Dsub' : aasub R M R''))
	   ([x] [d:isvar x I] ofe/sing (Dof x d : aofe (G x) (R x) t))
	   Dof''
	   <- aasubst-em T Dsimp Dapp Dcsub DofM Dsub tsub/t Dof (Dof' : aofe G' R' t)
	   <- aasub-fun Dsub Dsub' (Deq : atom-eq R' R'')
	   <- tp-resp-atom sing Deq (Deq' : tp-eq (sing R') (sing R''))
	   <- ofe-resp ctx-eq/i term-eq/i Deq' (ofe/sing Dof') (Dof'' : ofe G' (at R') (sing R'')).

-sing-o	: subst-em T (Dsimp : simp A T)
	   (Dapp : {x} append (cons G1 x A) (G2 x) (G x))
	   (Dcsub : csub G M G')
	   (DofM : ofe G1 M A)
	   (sub/ao (Dsub : aosub R M L))
	   (tsub/singo (Dsub' : aosub R M (at R')))
	   ([x] [d:isvar x I] ofe/sing (Dof x d : aofe (G x) (R x) t))
	   Dof''
	   <- aosubst-em T Dsimp Dapp Dcsub DofM Dsub' tsub/t Dof (ofe/at (Dof' : aofe G' R' t))
	   <- aosub-fun Dsub' Dsub (Deq : term-eq (at R') L)
	   <- ofe-resp ctx-eq/i Deq tp-eq/i (ofe/sing Dof') (Dof'' : ofe G' L (sing R')).

-sing-x : subst-em
	   _ _ _ _ _
	   (sub/ao (Dsub : aosub R M _))
	   (tsub/singa (Dsub' : aasub R M _))
	   _
	   D
	   <- aasub-aosub-contra Dsub' Dsub Dfalse
	   <- false-implies-ofe Dfalse D.

-sing-x : subst-em
	   _ _ _ _ _
	   (sub/aa (Dsub : aasub R M _))
	   (tsub/singo (Dsub' : aosub R M _))
	   _
	   D
	   <- aasub-aosub-contra Dsub Dsub' Dfalse
	   <- false-implies-ofe Dfalse D.

-t	: tsubst-em T (Dsimp : simp A T)
	   (Dapp : {x} append (cons G1 x A) (G2 x) (G x))
	   (Dcsub : csub G M G')
	   (DofM : ofe G1 M A)
	   tsub/t
	   ([x] [d] wfe/t (Dordered x d))
	   (wfe/t Dordered')
	   <- csub-ordered Dordered Dcsub Dordered'.

-pi	: tsubst-em T (Dsimp : simp A T)
	   (Dapp : {x} append (cons G1 x A) (G2 x) (G x))
	   (Dcsub : csub G M G')
	   (DofM : ofe G1 M A)
	   (tsub/pi
	      (Dtsub2 : {y} tsub ([x] B2 x y) M (B2' y))
	      (Dtsub1 : tsub B1 M B1'))
	   ([x] [d:isvar x I] wfe/pi
	      (Dwf2 x d : {y} isvar y J -> wfe (cons (G x) y (B1 x)) (B2 x y))
	      (Dwf1 x d : wfe (G x) (B1 x)))
	   (wfe/pi Dwf2' Dwf1')
	   <- tsubst-em T Dsimp Dapp Dcsub DofM Dtsub1 Dwf1 (Dwf1' : wfe G' B1')
	   <- ({y} {e:isvar y J}
		 tsubst-em T Dsimp ([x] append/cons (Dapp x)) (csub/cons Dtsub1 Dcsub) DofM (Dtsub2 y) ([x] [d] Dwf2 x d y e) (Dwf2' y e : wfe (cons G' y B1') (B2' y))).

-sigma	: tsubst-em T (Dsimp : simp A T)
	   (Dapp : {x} append (cons G1 x A) (G2 x) (G x))
	   (Dcsub : csub G M G')
	   (DofM : ofe G1 M A)
	   (tsub/sigma
	      (Dtsub2 : {y} tsub ([x] B2 x y) M (B2' y))
	      (Dtsub1 : tsub B1 M B1'))
	   ([x] [d:isvar x I] wfe/sigma
	      (Dwf2 x d : {y} isvar y J -> wfe (cons (G x) y (B1 x)) (B2 x y))
	      (Dwf1 x d : wfe (G x) (B1 x)))
	   (wfe/sigma Dwf2' Dwf1')
	   <- tsubst-em T Dsimp Dapp Dcsub DofM Dtsub1 Dwf1 (Dwf1' : wfe G' B1')
	   <- ({y} {e:isvar y J}
		 tsubst-em T Dsimp ([x] append/cons (Dapp x)) (csub/cons Dtsub1 Dcsub) DofM (Dtsub2 y) ([x] [d] Dwf2 x d y e) (Dwf2' y e : wfe (cons G' y B1') (B2' y))).

-singa	: tsubst-em T (Dsimp : simp A T)
	   (Dapp : {x} append (cons G1 x A) (G2 x) (G x))
	   (Dcsub : csub G M G')
	   (DofM : ofe G1 M A)
	   (tsub/singa (Daasub : aasub R M R'))
	   ([x] [d] wfe/sing (Daof x d : aofe (G x) (R x) t))
	   (wfe/sing Daof')
	   <- aasubst-em T Dsimp Dapp Dcsub DofM Daasub tsub/t Daof (Daof' : aofe G' R' t).

-singo	: tsubst-em T (Dsimp : simp A T)
	   (Dapp : {x} append (cons G1 x A) (G2 x) (G x))
	   (Dcsub : csub G M G')
	   (DofM : ofe G1 M A)
	   (tsub/singo (Daosub : aosub R M (at R')))
	   ([x] [d] wfe/sing (Daof x d : aofe (G x) (R x) t))
	   (wfe/sing Daof')
	   <- aosubst-em T Dsimp Dapp Dcsub DofM Daosub tsub/t Daof (ofe/at (Daof' : aofe G' R' t)).

%worlds (bind | ovar | var) (aasubst-em _ _ _ _ _ _ _ _ _) (aosubst-em _ _ _ _ _ _ _ _ _) (subst-em _ _ _ _ _ _ _ _ _) (tsubst-em _ _ _ _ _ _ _ _).
%total {(T1 T2 T3 T4) (D1 D2 D3 D4)} (aasubst-em T1 _ _ _ _ _ _ D1 _) (aosubst-em T2 _ _ _ _ _ _ D2 _) (subst-em T3 _ _ _ _ _ _ D3 _) (tsubst-em T4 _ _ _ _ _ D4 _).



aasubst-e   : ({x} append (cons G1 x A) (G2 x) (G x))
	       -> csub G M G'
	       -> ofe G1 M A
	       -> aasub R M R'
	       -> tsub B M B'
	       -> ({x} isvar x I -> aofe (G x) (R x) (B x))
%%
	       -> aofe G' R' B' -> type.
%mode aasubst-e +X1 +X2 +X3 +X4 +X5 +X6 -X7.

-	: aasubst-e Dapp Dcsub Dof Dsub Dtsub Daof D
	   <- can-simp _ Dsimp
	   <- aasubst-em _ Dsimp Dapp Dcsub Dof Dsub Dtsub Daof D.

%worlds (bind | ovar | var) (aasubst-e _ _ _ _ _ _ _).
%total {} (aasubst-e _ _ _ _ _ _ _).



aosubst-e   : ({x} append (cons G1 x A) (G2 x) (G x))
	       -> csub G M G'
	       -> ofe G1 M A
	       -> aosub R M N
	       -> tsub B M B'
	       -> ({x} isvar x I -> aofe (G x) (R x) (B x))
%%
	       -> ofe G' N B' -> type.
%mode aosubst-e +X1 +X2 +X3 +X4 +X5 +X6 -X7.

-	: aosubst-e Dapp Dcsub Dof Dsub Dtsub Daof D
	   <- can-simp _ Dsimp
	   <- aosubst-em _ Dsimp Dapp Dcsub Dof Dsub Dtsub Daof D.

%worlds (bind | ovar | var) (aosubst-e _ _ _ _ _ _ _).
%total {} (aosubst-e _ _ _ _ _ _ _).



subst-e     : ({x} append (cons G1 x A) (G2 x) (G x))
	       -> csub G M G'
	       -> ofe G1 M A
	       -> sub N M N'
	       -> tsub B M B'
	       -> ({x} isvar x I -> ofe (G x) (N x) (B x))
%%
	       -> ofe G' N' B' -> type.
%mode subst-e +X1 +X2 +X3 +X4 +X5 +X6 -X7.

-	: subst-e Dapp Dcsub Dof Dsub Dtsub Dof' D
	   <- can-simp _ Dsimp
	   <- subst-em _ Dsimp Dapp Dcsub Dof Dsub Dtsub Dof' D.

%worlds (bind | ovar | var) (subst-e _ _ _ _ _ _ _).
%total {} (subst-e _ _ _ _ _ _ _).



tsubst-e    : ({x} append (cons G1 x A) (G2 x) (G x))
	       -> csub G M G'
	       -> ofe G1 M A
	       -> tsub B M B'
	       -> ({x} isvar x I -> wfe (G x) (B x))
%%
	       -> wfe G' B' -> type.
%mode tsubst-e +X1 +X2 +X3 +X4 +X5 -X6.

-	: tsubst-e Dapp Dcsub Dof Dsub Dwf D
	   <- can-simp _ Dsimp
	   <- tsubst-em _ Dsimp Dapp Dcsub Dof Dsub Dwf D.

%worlds (bind | ovar | var) (tsubst-e _ _ _ _ _ _).
%total {} (tsubst-e _ _ _ _ _ _).




%%%%%  Substitution Lemma (Implicit Context)  %%%%%

subst : sub ([x] M x) N Mx 
	   -> tsub ([x] B x) N Bx
	   -> ({x} vof x A -> of (M x) (B x))
	   -> of N A
%%
	   -> of Mx Bx -> type.
%mode subst +X1 +X2 +X3 +X4 -X5.

-	: subst 
	   (Dsub : sub ([x] M x) N Mx)
	   (Dtsub : tsub ([x] B x) N Bx)
	   (DofM : {x} vof x A -> of (M x) (B x))
	   (DofN : of N A)
%%
	   Dof
	   <- of1-to-ofe 0 DofM
	      (DofeM : {x} isvar x 0 -> ofe (cons nil x A) (M x) (B x))
	   <- of-to-ofe DofN
	      (DofeN : ofe nil N A)
	   <- subst-e ([x] append/nil) csub/base DofeN Dsub Dtsub DofeM
	      (Dofe : ofe nil Mx Bx)
	   <- ofe-to-of Dofe (Dof : of Mx Bx).

%worlds (bind | var) (subst _ _ _ _ _).
%total {} (subst _ _ _ _ _).



subst' : sub ([x] M x) N Mx
	  -> ({x} vof x A -> of (M x) B)
	  -> of N A
%%
	  -> of Mx B -> type.
%mode subst' +X1 +X2 +X3 -X4.

-	: subst' Dsub DofM DofN DofMx
	   <- tsub-absent B N (Dtsub : tsub ([_] B) N B)
	   <- subst Dsub Dtsub DofM DofN DofMx.

%worlds (bind | var) (subst' _ _ _ _).
%total {} (subst' _ _ _ _).



aosubst : aosub ([x] R x) N LRx
	   -> tsub ([x] B x) N Bx
	   -> ({x} vof x A -> aof (R x) (B x))
	   -> of N A
%%
	   -> of LRx Bx -> type.
%mode aosubst +X1 +X2 +X3 +X4 -X5.

-	: aosubst 
	   (Dsub : aosub ([x] R x) N LRx)
	   (Dtsub : tsub ([x] B x) N Bx)
	   (DofR : {x} vof x A -> aof (R x) (B x))
	   (DofN : of N A)
%%
	   Dof
	   <- aof1-to-aofe 0 DofR
	      (DaofeR : {x} isvar x 0 -> aofe (cons nil x A) (R x) (B x))
	   <- of-to-ofe DofN
	      (DofeN : ofe nil N A)
	   <- aosubst-e ([x] append/nil) csub/base DofeN Dsub Dtsub DaofeR
	      (Dofe : ofe nil LRx Bx)
	   <- ofe-to-of Dofe (Dof : of LRx Bx).

%worlds (bind | var) (aosubst _ _ _ _ _).
%total {} (aosubst _ _ _ _ _).



aasubst : aasub ([x] R x) N Rx
	   -> tsub ([x] B x) N Bx
	   -> ({x} vof x A -> aof (R x) (B x))
	   -> of N A
%%
	   -> aof Rx Bx -> type.
%mode aasubst +X1 +X2 +X3 +X4 -X5.

-	: aasubst 
	   (Dsub : aasub ([x] R x) N Rx)
	   (Dtsub : tsub ([x] B x) N Bx)
	   (DofR : {x} vof x A -> aof (R x) (B x))
	   (DofN : of N A)
%%
	   Daof
	   <- aof1-to-aofe 0 DofR
	      (DaofeR : {x} isvar x 0 -> aofe (cons nil x A) (R x) (B x))
	   <- of-to-ofe DofN
	      (DofeN : ofe nil N A)
	   <- aasubst-e ([x] append/nil) csub/base DofeN Dsub Dtsub DaofeR
	      (Daofe : aofe nil Rx Bx)
	   <- aofe-to-aof Daofe (Daof : aof Rx Bx).

%worlds (bind | var) (aasubst _ _ _ _ _).
%total {} (aasubst _ _ _ _ _).



tsubst : tsub ([x] B x) N Bx
	   -> ({x} vof x A -> wf (B x))
	   -> of N A
%%
	   -> wf Bx -> type.
%mode tsubst +X1 +X2 +X3 -X4.

-	: tsubst 
	   (Dsub : tsub ([x] B x) N Bx)
	   (DwfB : {x} vof x A -> wf (B x))
	   (DofN : of N A)
%%
	   Dwf
	   <- wf1-to-wfe 0 DwfB
	      (DwfeB : {x} isvar x 0 -> wfe (cons nil x A) (B x))
	   <- of-to-ofe DofN
	      (DofeN : ofe nil N A)
	   <- tsubst-e ([x] append/nil) csub/base DofeN Dsub DwfeB
	      (Dwfe : wfe nil Bx)
	   <- wfe-to-wf Dwfe (Dwf : wf Bx).

%worlds (bind | var | ovar) (tsubst _ _ _ _).
%total {} (tsubst _ _ _ _).




%%%%%  Substitution Permutation (Implicit Context)  %%%%%

sub-permute : of M A
	       -> ({x} vof x A -> of (N x) (B x))
	       -> ({x} vof x A -> {y} vof y (B x) -> of (O x y) (C x y))
%%
	       -> ({y} sub ([x] O x y) M (Ox y))
	       -> sub N M Nx
	       -> sub ([y] Ox y) Nx Oxy
	       -> ({x} sub ([y] O x y) (N x) (Oy x))
	       -> sub ([x] Oy x) M Oyx
%%
	       -> term-eq Oxy Oyx -> type.
%mode sub-permute +X1 +X2 +X3 +X4 +X5 +X6 +X7 +X8 -X9.

-	: sub-permute DofM DofN DofO DsubOx DsubNx DsubOxy DsubOy DsubOyx Deq
	   <- of-to-ofe DofM 
	      (DofeM : ofe nil M A)
	   <- of1-to-ofe 0 DofN 
	      (DofeN : {x} isvar x 0 -> ofe (cons nil x A) (N x) (B x))
	   <- of2-to-ofe lt/z DofO
	      (DofeO : {x} isvar x 0 -> {y} isvar y (s 0) -> ofe (cons (cons nil x A) y (B x)) (O x y) (C x y))
	   <- sub-permute-e ([_] append/nil) DofeM DofeN DofeO DsubOx DsubNx DsubOxy DsubOy DsubOyx Deq.

%worlds (bind) (sub-permute _ _ _ _ _ _ _ _ _).
%total {} (sub-permute _ _ _ _ _ _ _ _ _).



aasub-permute : of M A
		 -> ({x} vof x A -> of (N x) (B x))
		 -> ({x} vof x A -> {y} vof y (B x) -> aof (R x y) (C x y))
%%
		 -> ({y} aasub ([x] R x y) M (Rx y))
		 -> sub N M Nx
		 -> aasub ([y] Rx y) Nx Rxy
		 -> ({x} aasub ([y] R x y) (N x) (Ry x))
		 -> aasub ([x] Ry x) M Ryx
%%
		 -> atom-eq Rxy Ryx -> type.
%mode aasub-permute +X1 +X2 +X3 +X4 +X5 +X6 +X7 +X8 -X9.

-	: aasub-permute DofM DofN DaofR DsubRx DsubNx DsubRxy DsubRy DsubRyx Deq
	   <- of-to-ofe DofM 
	      (DofeM : ofe nil M A)
	   <- of1-to-ofe 0 DofN 
	      (DofeN : {x} isvar x 0 -> ofe (cons nil x A) (N x) (B x))
	   <- aof2-to-aofe lt/z DaofR
	      (DaofeR : {x} isvar x 0 -> {y} isvar y (s 0) -> aofe (cons (cons nil x A) y (B x)) (R x y) (C x y))
	   <- aasub-permute-e ([_] append/nil) DofeM DofeN DaofeR DsubRx DsubNx DsubRxy DsubRy DsubRyx Deq.

%worlds (bind) (aasub-permute _ _ _ _ _ _ _ _ _).
%total {} (aasub-permute _ _ _ _ _ _ _ _ _).



aasub-aosub-permute : of M A
		 -> ({x} vof x A -> of (N x) (B x))
		 -> ({x} vof x A -> {y} vof y (B x) -> aof (R x y) (C x y))
%%
		 -> ({y} aosub ([x] R x y) M (LRx y))
		 -> sub N M Nx
		 -> sub ([y] LRx y) Nx LRxy
		 -> ({x} aasub ([y] R x y) (N x) (Ry x))
		 -> aosub ([x] Ry x) M LRyx
%%
		 -> term-eq LRxy LRyx -> type.
%mode aasub-aosub-permute +X1 +X2 +X3 +X4 +X5 +X6 +X7 +X8 -X9.

-	: aasub-aosub-permute DofM DofN DaofR DsubRx DsubNx DsubRxy DsubRy DsubRyx Deq
	   <- of-to-ofe DofM 
	      (DofeM : ofe nil M A)
	   <- of1-to-ofe 0 DofN 
	      (DofeN : {x} isvar x 0 -> ofe (cons nil x A) (N x) (B x))
	   <- aof2-to-aofe lt/z DaofR
	      (DaofeR : {x} isvar x 0 -> {y} isvar y (s 0) -> aofe (cons (cons nil x A) y (B x)) (R x y) (C x y))
	   <- aasub-aosub-permute-e ([_] append/nil) DofeM DofeN DaofeR DsubRx DsubNx DsubRxy DsubRy DsubRyx Deq.

%worlds (bind) (aasub-aosub-permute _ _ _ _ _ _ _ _ _).
%total {} (aasub-aosub-permute _ _ _ _ _ _ _ _ _).



aosub-permute : of M A
		 -> ({x} vof x A -> of (N x) (B x))
		 -> ({x} vof x A -> {y} vof y (B x) -> aof (R x y) (C x y))
%%
		 -> ({y} aasub ([x] R x y) M (Rx y))
		 -> sub N M Nx
		 -> aosub ([y] Rx y) Nx LRxy
		 -> ({x} aosub ([y] R x y) (N x) (LRy x))
		 -> sub ([x] LRy x) M LRyx
%%
		 -> term-eq LRxy LRyx -> type.
%mode aosub-permute +X1 +X2 +X3 +X4 +X5 +X6 +X7 +X8 -X9.

-	: aosub-permute DofM DofN DaofR DsubRx DsubNx DsubRxy DsubRy DsubRyx Deq
	   <- of-to-ofe DofM 
	      (DofeM : ofe nil M A)
	   <- of1-to-ofe 0 DofN 
	      (DofeN : {x} isvar x 0 -> ofe (cons nil x A) (N x) (B x))
	   <- aof2-to-aofe lt/z DaofR
	      (DaofeR : {x} isvar x 0 -> {y} isvar y (s 0) -> aofe (cons (cons nil x A) y (B x)) (R x y) (C x y))
	   <- aosub-permute-e ([_] append/nil) DofeM DofeN DaofeR DsubRx DsubNx DsubRxy DsubRy DsubRyx Deq.

%worlds (bind) (aosub-permute _ _ _ _ _ _ _ _ _).
%total {} (aosub-permute _ _ _ _ _ _ _ _ _).



tsub-permute : of M A
	       -> ({x} vof x A -> of (N x) (B x))
	       -> ({x} vof x A -> {y} vof y (B x) -> wf (C x y))
%%
	       -> ({y} tsub ([x] C x y) M (Cx y))
	       -> sub N M Nx
	       -> tsub ([y] Cx y) Nx Cxy
	       -> ({x} tsub ([y] C x y) (N x) (Cy x))
	       -> tsub ([x] Cy x) M Cyx
%%
	       -> tp-eq Cxy Cyx -> type.
%mode tsub-permute +X1 +X2 +X3 +X4 +X5 +X6 +X7 +X8 -X9.

-	: tsub-permute DofM DofN DwfC DsubOx DsubNx DsubOxy DsubOy DsubOyx Deq
	   <- of-to-ofe DofM 
	      (DofeM : ofe nil M A)
	   <- of1-to-ofe 0 DofN 
	      (DofeN : {x} isvar x 0 -> ofe (cons nil x A) (N x) (B x))
	   <- wf2-to-wfe lt/z DwfC
	      (DwfeC : {x} isvar x 0 -> {y} isvar y (s 0) -> wfe (cons (cons nil x A) y (B x)) (C x y))
	   <- tsub-permute-e ([_] append/nil) DofeM DofeN DwfeC DsubOx DsubNx DsubOxy DsubOy DsubOyx Deq.

%worlds (bind) (tsub-permute _ _ _ _ _ _ _ _ _).
%total {} (tsub-permute _ _ _ _ _ _ _ _ _).



ssub-ao-permute : of M A
		   -> ({x} vof x A -> aof (R x) (B x))
		   -> ({x} vof x A -> {y} vof y (B x) -> of (N x y) (C x y))
%%
		   -> ({y} sub ([x] N x y) M (Nx y))
		   -> aosub R M LRx
		   -> sub ([y] Nx y) LRx Nxy
		   -> sub ([x] N x (R x)) M Nyx
%%
		   -> term-eq Nxy Nyx -> type.
%mode ssub-ao-permute +X1 +X2 +X3 +X4 +X5 +X6 +X7 -X8.

-	: ssub-ao-permute DofM DofR DofN DsubNx DsubRx DsubNxy DsubNyx Deq
	   <- of-to-ofe DofM DofeM
	   <- aof1-to-aofe 0 DofR DofeR
	   <- of2-to-ofe (lt/z : lt 0 (s 0)) DofN DofeN
	   <- ssub-ao-permute-e ([_] append/nil) DofeM DofeR DofeN DsubNx DsubRx DsubNxy DsubNyx Deq.

%worlds (bind) (ssub-ao-permute _ _ _ _ _ _ _ _).
%total {} (ssub-ao-permute _ _ _ _ _ _ _ _).




%%%%%  Inhabitation  %%%%%

inhabitation-e : wfe G A -> ofe G M A -> type.
%mode inhabitation-e +X1 -X2.

-t	: inhabitation-e (wfe/t Dordered) (ofe/at (aofe/closed Dordered (aof/const wf/t (kof/i topen/t ckof/unit)))).

-pi	: inhabitation-e (wfe/pi DwfB DwfA) (ofe/lam DofM DwfA)
	   <- ({x} {d:isvar x I}
		 inhabitation-e (DwfB x d) (DofM x d)).

-sigma	: inhabitation-e (wfe/sigma DwfB DwfA) (ofe/pair DwfB DofNx DsubBx DofM)
	   <- inhabitation-e DwfA DofM
	   <- ({x} {d:isvar x I}
		 inhabitation-e (DwfB x d) (DofN x d))
	   <- can-tsub-e ([_] append/nil) DwfB DofM DsubBx
	   <- can-sub-e ([_] append/nil) DofN DofM DsubNx
	   <- subst-e ([_] append/nil) csub/base DofM DsubNx DsubBx DofN DofNx.

-sing	: inhabitation-e (wfe/sing Daof) (ofe/sing Daof).

%worlds (var | bind | ovar) (inhabitation-e _ _).
%total D (inhabitation-e D _).



inhabitation : wf A -> of M A -> type.
%mode inhabitation +X1 -X2.

-	: inhabitation Dwf Dof
	   <- wf-to-wfe Dwf Dwfe
	   <- inhabitation-e Dwfe Dofe
	   <- ofe-to-of Dofe Dof.

%worlds (var | bind) (inhabitation _ _).
%total {} (inhabitation _ _).



inhabitsub-e : wfe G A -> ({x} isvar x I -> ofe (cons G x A) M B) -> ofe G M B -> type.
%mode inhabitsub-e +X1 +X2 -X3.

-	: inhabitsub-e DwfA DofM DofM'
	   <- inhabitation-e DwfA DofN
	   <- sub-absent M N
	      (DsubM : sub ([_] M) N M)
	   <- tsub-absent B N
	      (DsubB : tsub ([_] B) N B)
	   <- subst-e ([_] append/nil) csub/base DofN DsubM DsubB DofM
	      (DofM' : ofe G M B).

%worlds (var | bind | ovar) (inhabitsub-e _ _ _).
%total {} (inhabitsub-e _ _ _).



tinhabitsub-e : wfe G A -> ({x} isvar x I -> wfe (cons G x A) B) -> wfe G B -> type.
%mode tinhabitsub-e +X1 +X2 -X3.

-	: tinhabitsub-e DwfA DwfB DwfB'
	   <- inhabitation-e DwfA DofN
	   <- tsub-absent B N
	      (DsubB : tsub ([_] B) N B)
	   <- tsubst-e ([_] append/nil) csub/base DofN DsubB DwfB
	      (DwfB' : wfe G B).

%worlds (var | bind | ovar) (tinhabitsub-e _ _ _).
%total {} (tinhabitsub-e _ _ _).



tinhabitsub : wf A -> ({x} vof x A -> wf B) -> wf B -> type.
%mode tinhabitsub +X1 +X2 -X3.

-	: tinhabitsub DwfA DwfB D
	   <- inhabitation DwfA DofM
	   <- tsub-absent B N DsubN
	   <- tsubst DsubN DwfB DofM D.

%worlds (bind) (tinhabitsub _ _ _).
%total {} (tinhabitsub _ _ _).




%%%%%  Corollaries  %%%%%

compose-sub : of MA A
	       -> ({x} vof x A -> of (OAB x) B)
	       -> ({x} vof x B -> of (OBC x) C)
%%
	       -> sub OAB MA MB
	       -> sub OBC MB MC
	       -> ({x} sub OBC (OAB x) (OAC x))
%%
	       -> sub OAC MA MC -> type.
%mode compose-sub +X1 +X2 +X3 +X4 +X5 +X6 -X7.

-	: compose-sub 
	   (DofMA : of MA A)
	   (DofOAB : {x} vof x A -> of (OAB x) B)
	   (DofOBC : {x} vof x B -> of (OBC x) C)
	   (DsubAB : sub OAB MA MB)
	   (DsubBC : sub OBC MB MC)
	   (DsubOAC : {x} sub OBC (OAB x) (OAC x))
%%
	   DsubAC'
	   <- ({x} {d:vof x A}
		 subst' (DsubOAC x) DofOBC (DofOAB x d)
		 (DofOAC x d : of (OAC x) C))
	   <- can-sub DofOAC DofMA
	      (DsubAC : sub OAC MA MC')
	   <- ({x}
		 sub-absent (OBC x) MA
		 (DsubOBCabs x : sub ([_] OBC x) MA (OBC x)))
	   <- sub-permute DofMA DofOAB ([_] [_] DofOBC)
	      DsubOBCabs DsubAB DsubBC DsubOAC DsubAC
	      (Deq : term-eq MC MC')
	   <- term-eq-symm Deq
	      (Deq' : term-eq MC' MC)
	   <- sub-resp ([_] term-eq/i) term-eq/i Deq' DsubAC
	      (DsubAC' : sub OAC MA MC).

%worlds (bind) (compose-sub _ _ _ _ _ _ _).
%total {} (compose-sub _ _ _ _ _ _ _).



subst1 : ({y} sub ([x] N x y) M (Nx y))
	   -> ({y} tsub ([x] C x y) M (Cx y))
	   -> tsub ([x] B x) M Bx
	   -> ({x} vof x A -> {y} vof y (B x) -> of (N x y) (C x y))
	   -> of M A
%%
	   -> ({y} vof y Bx -> of (Nx y) (Cx y)) -> type.
%mode subst1 +X1 +X2 +X3 +X4 +X5 -X6.

-	: subst1
	   (DsubNx : {y} sub ([x] N x y) M (Nx y))
	   (DsubCx : {y} tsub ([x] C x y) M (Cx y))
	   (DsubBx : tsub ([x] B x) M Bx)
	   (DofN : {x} vof x A -> {y} vof y (B x) -> of (N x y) (C x y))
	   (DofM : of M A)
%%
	   DofNx
	   <- of2-to-ofe (lt/z : lt 0 (s 0)) DofN
	      (DofeN : {x} isvar x 0 -> {y} isvar y (s 0) -> ofe (cons (cons nil x A) y (B x)) (N x y) (C x y))
	   <- of-to-ofe DofM
	      (DofeM : ofe nil M A)
	   <- ({y} {e:isvar y (s 0)}
		 subst-e ([_] append/cons append/nil) (csub/cons DsubBx csub/base) DofeM (DsubNx y) (DsubCx y) ([x] [d] DofeN x d y e)
		    (DofeNx y e : ofe (cons nil y Bx) (Nx y) (Cx y)))
	   <- ofe-to-of1 DofeNx
	      (DofNx : {y} vof y Bx -> of (Nx y) (Cx y)).

%worlds (bind) (subst1 _ _ _ _ _ _).
%total {} (subst1 _ _ _ _ _ _).



tsubst1 : ({y} tsub ([x] C x y) M (Cx y))
	   -> tsub ([x] B x) M Bx
	   -> ({x} vof x A -> {y} vof y (B x) -> wf (C x y))
	   -> of M A
%%
	   -> ({y} vof y Bx -> wf (Cx y)) -> type.
%mode tsubst1 +X1 +X2 +X3 +X4 -X5.

-	: tsubst1
	   (DsubCx : {y} tsub ([x] C x y) M (Cx y))
	   (DsubBx : tsub ([x] B x) M Bx)
	   (DwfC : {x} vof x A -> {y} vof y (B x) -> wf (C x y))
	   (DofM : of M A)
%%
	   DwfCx
	   <- wf2-to-wfe (lt/z : lt 0 (s 0)) DwfC
	      (DwfeC : {x} isvar x 0 -> {y} isvar y (s 0) -> wfe (cons (cons nil x A) y (B x)) (C x y))
	   <- of-to-ofe DofM
	      (DofeM : ofe nil M A)
	   <- ({y} {e:isvar y (s 0)}
		 tsubst-e ([_] append/cons append/nil) (csub/cons DsubBx csub/base) DofeM (DsubCx y) ([x] [d] DwfeC x d y e)
		    (DwfeCx y e : wfe (cons nil y Bx) (Cx y)))
	   <- wfe-to-wf1 DwfeCx
	      (DwfCx : {y} vof y Bx -> wf (Cx y)).

%worlds (bind) (tsubst1 _ _ _ _ _).
%total {} (tsubst1 _ _ _ _ _).



subst-context-e : ({x} isvar x I -> ofe (cons G x A) (M x) B)
		    -> ({y} isvar y J -> ofe (cons G y B) (N y) (C y))
		    -> ({x} sub ([y] N y) (M x) (Ny x))
		    -> ({x} tsub ([y] C y) (M x) (Cy x))
%%
		    -> ({x} isvar x I -> ofe (cons G x A) (Ny x) (Cy x)) -> type.
%mode subst-context-e +X1 +X2 +X3 +X4 -X5.

-	: subst-context-e
	   (DofM : {x} isvar x I -> ofe (cons G x A) (M x) B)
	   (DofN : {y} isvar y J -> ofe (cons G y B) (N y) (C y))
	   (DsubNy : {x} sub ([y] N y) (M x) (Ny x))
	   (DsubCy : {x} tsub ([y] C y) (M x) (Cy x))
%%
	   DofN'''
	   <- ({x} {d:isvar x I}
		 ofe-context (DofM x d)
		    (ordered/cons
		       (DboundedGx x d : bounded G x)
		       : ordered (cons G x A)))
	   <- ({x} {d:isvar x I}
		 following-var d
		    ([y] [e:isvar y J']
		       (Dprec x d y e : precedes x y)))
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J'}
		 bounded-increase-bound (DboundedGx x d) (Dprec x d y e)
		    (DboundedGy x d y e : bounded G y))
	   <- ({x} {d:isvar x I}
		 bump-ofe DofN ([y] [e:isvar y J'] ordered/cons (DboundedGy x d y e))
		 ([y] [e:isvar y J'] DofN' x d y e : ofe (cons G y B) (N y) (C y)))
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J'}
		 weakeng-ofe (append/cons append/nil) (append/cons append/nil) (ordered/cons (bounded/cons (DboundedGx x d) (Dprec x d y e))) (DofN' x d y e)
		 (DofN'' x d y e : ofe (cons (cons G x A) y B) (N y) (C y)))
	   <- ({x} {d:isvar x I}
		 subst-e ([_] append/nil) csub/base (DofM x d) (DsubNy x) (DsubCy x) ([y] [e:isvar y J'] DofN'' x d y e)
		 (DofN''' x d : ofe (cons G x A) (Ny x) (Cy x))).

%worlds (var | bind | ovar) (subst-context-e _ _ _ _ _).
%total {} (subst-context-e _ _ _ _ _).



tsubst-context-e : ({x} isvar x I -> ofe (cons G x A) (M x) B)
		    -> ({y} isvar y J -> wfe (cons G y B) (C y))
		    -> ({x} tsub ([y] C y) (M x) (Cy x))
%%
		    -> ({x} isvar x I -> wfe (cons G x A) (Cy x)) -> type.
%mode tsubst-context-e +X1 +X2 +X3 -X4.

-	: tsubst-context-e
	   (Dof : {x} isvar x I -> ofe (cons G x A) (M x) B)
	   (Dwf : {y} isvar y J -> wfe (cons G y B) (C y))
	   (Dsub : {x} tsub ([y] C y) (M x) (Cy x))
%%
	   Dwf'''
	   <- ({x} {d:isvar x I}
		 ofe-context (Dof x d)
		    (ordered/cons
		       (DboundedGx x d : bounded G x)
		       : ordered (cons G x A)))
	   <- ({x} {d:isvar x I}
		 following-var d
		    ([y] [e:isvar y J']
		       (Dprec x d y e : precedes x y)))
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J'}
		 bounded-increase-bound (DboundedGx x d) (Dprec x d y e)
		    (DboundedGy x d y e : bounded G y))
	   <- ({x} {d:isvar x I}
		 bump-wfe Dwf ([y] [e:isvar y J'] ordered/cons (DboundedGy x d y e))
		    ([y] [e:isvar y J'] Dwf' x d y e : wfe (cons G y B) (C y)))
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J'}
		 weakeng-wfe (append/cons append/nil) (append/cons append/nil) (ordered/cons (bounded/cons (DboundedGx x d) (Dprec x d y e))) (Dwf' x d y e)
		    (Dwf'' x d y e : wfe (cons (cons G x A) y B) (C y)))
	   <- ({x} {d:isvar x I}
		 tsubst-e ([_] append/nil) csub/base (Dof x d) (Dsub x) ([y] [e:isvar y J'] Dwf'' x d y e)
		    (Dwf''' x d : wfe (cons G x A) (Cy x))).

%worlds (bind | ovar | var) (tsubst-context-e _ _ _ _).
%total {} (tsubst-context-e _ _ _ _).



ssubst-context-e : ({x} isvar x I -> aofe (cons G x A) (R x) B)
		     -> ({y} isvar y J -> ofe (cons G y B) (N y) (C y))
%%
		     -> ({x} isvar x I -> ofe (cons G x A) (N (R x)) (C (R x))) -> type.
%mode ssubst-context-e +X1 +X2 -X3.

-	: ssubst-context-e Daof Dof D
	   <- ({x} {d}
		 aofe-context (Daof x d)
		 (ordered/cons (Dbound x d)))
	   <- weaken-ofe-insert1 Dof Dbound  _ Dof'
	   <- ({x} {d}
		 ssubst-e ([_] append/nil) append/nil (Dof' x d) (Daof x d) (D x d)).

%worlds (var | bind | ovar) (ssubst-context-e _ _ _).
%total {} (ssubst-context-e _ _ _).



ssubst-context2-e : ({x} isvar x I -> aofe (cons G x A) (Q x) B)
		     -> ({x} isvar x I -> aofe (cons G x A) (R x) (C (Q x)))
		     -> ({y} isvar y J -> {z} isvar z K -> ofe (cons (cons G y B) z (C y)) (N y z) (D y z))
%%
		     -> ({x} isvar x I -> ofe (cons G x A) (N (Q x) (R x)) (D (Q x) (R x))) -> type.
%mode ssubst-context2-e +X1 +X2 +X3 -X4.

-	: ssubst-context2-e Daof1 Daof2 Dof Dof'''
	   <- ({x} {d}
		 aofe-context (Daof1 x d)
		 (ordered/cons (Dbound x d)))
	   <- weaken-ofe-insert2 Dof Dbound _ Dof'
	   <- ({x} {d} {z} {f}
		 ssubst-e ([_] append/cons append/nil) (append/cons append/nil) 
		 ([y] [e] Dof' x d y e z f) (Daof1 x d)
		 (Dof'' x d z f))
	   <- ({x} {d}
		 ssubst-e ([_] append/nil) append/nil
		 ([z] [f] Dof'' x d z f) (Daof2 x d)
		 (Dof''' x d)).
		 
%worlds (var | bind | ovar) (ssubst-context2-e _ _ _ _).
%total {} (ssubst-context2-e _ _ _ _).



subst-simult-pair-e : ({x} isvar x I -> {y} isvar y J -> ofe (cons (cons G x A) y B) (O x y) (C x y))
		       -> ofe G M A
		       -> ofe G N B
		       -> sub ([z] O (pi1 z) (pi2 z)) (pair M N) P
		       -> ({y} sub ([x] O x y) M (Ox y))
%%
		       -> sub ([y] Ox y) N P -> type.
%mode subst-simult-pair-e +X1 +X2 +X3 +X4 +X5 -X6.

-	: subst-simult-pair-e
	   (DofO : {x} isvar x I -> {y} isvar y J -> ofe (cons (cons G x A) y B) (O x y) (C x y))
	   (DofM : ofe G M A)
	   (DofN : ofe G N B)
	   (Dsub : sub ([z] O (pi1 z) (pi2 z)) (pair M N) P)
	   (DsubOx : {y} sub ([x] O x y) M (Ox y))
	   DsubOxy'
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 ofe-context (DofO x d y e)
		    (ordered/cons (bounded/cons 
				     (Dbounded x d y e : bounded G x)
				     (DprecIJ x d y e : precedes x y))))
	   <- ({x} {d:isvar x I}
		 strengthen-bounded ([y] [e] Dbounded x d y e)
		    (Dbounded' x d : bounded G x))
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 ofe-reg (DofO x d y e)
		    (DwfC x d y e : wfe (cons (cons G x A) y B) (C x y)))
	   <- ({y} {e:isvar y J}
		 can-tsub-e ([_] append/cons append/nil) ([x] [d] DwfC x d y e) DofM
		    (DsubCx y : tsub ([x] C x y) M (Cx y)))
	   <- tsub-absent B M
	      (DsubB : tsub ([_] B) M B)
	   <- ({y} {e:isvar y J}
		 subst-e ([_] append/cons append/nil) (csub/cons DsubB csub/base)
		    DofM (DsubOx y) (DsubCx y) ([x] [d] DofO x d y e)
		    (DofOx y e : ofe (cons G y B) (Ox y) (Cx y)))
	   <- can-sub-e ([_] append/nil) DofOx DofN
	      (DsubOxy : sub ([y] Ox y) N Oxy)
	   <- ({x} {d:isvar x I}
		 weaken-ofe (Dbounded' x d) DofN _
		    (DofN' x d : ofe (cons G x A) N B))
	   <- ({x} {d:isvar x I}
		 can-sub-e ([_] append/nil) ([y] [e] DofO x d y e) (DofN' x d)
		    (DsubOy x : sub ([y] O x y) N (Oy x)))
	   <- ({x} {d:isvar x I}
		 can-tsub-e ([_] append/nil) ([y] [e] DwfC x d y e) (DofN' x d)
		    (DsubCy x : tsub ([y] C x y) N (Cy x)))
	   <- ({x} {d:isvar x I}
		 subst-e ([_] append/nil) csub/base
		    (DofN' x d) (DsubOy x) (DsubCy x) ([y] [e] DofO x d y e)
		    (DofOy x d : ofe (cons G x A) (Oy x) (Cy x)))
	   <- can-sub-e ([_] append/nil) DofOy DofM
	      (DsubOyx : sub ([x] Oy x) M Oyx)
	   <- ({x} {y}
		 sub-absent (O x y) (pair M N)
		 (DsubOz x y : sub ([z] O x y) (pair M N) (O x y)))
	   %% time for fun with stamps
	   <- ({y} {e:isvar y J}
		 following-var e
		    (DprecJK y e : {z} isvar z K -> precedes y z))
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 {z} {f:isvar z K}
		 precedes-trans (DprecIJ x d y e) (DprecJK y e z f)
		    (DprecIK x d y e z f : precedes x z))
	   <- ({x} {d:isvar x I}
		 {z} {f:isvar z K}
		 strengthen-precedes ([y] [e] DprecIK x d y e z f)
		    (DprecIK' x d z f : precedes x z))
	   <- ({x} {d:isvar x I}
		 {y} {e:isvar y J}
		 bounded-increase-bound (Dbounded' x d) (DprecIJ x d y e)
		    (DboundedJ x d y e : bounded G y))
	   <- ({y} {e:isvar y J}
		 strengthen-bounded ([x] [d] DboundedJ x d y e)
		    (DboundedJ' y e : bounded G y))
	   %% shift stamps by one
	   <- bump2-ofe DofO 
	      ([x] [d:isvar x I] [y] [e:isvar y K] ordered/cons (bounded/cons (Dbounded' x d) (DprecIK' x d y e)))
	      ([x] [d:isvar x J] [y] [e:isvar y K] ordered/cons (bounded/cons (DboundedJ' x d) (DprecJK x d y e)))
	      (DofO' : {x} isvar x J -> {y} isvar y K -> ofe (cons (cons G x A) y B) (O x y) (C x y))
	   <- ({z} {f:isvar z I}
		 {x} {d:isvar x J}
		 {y} {e:isvar y K}
		 weakeng-ofe (append/cons (append/cons append/nil)) (append/cons (append/cons append/nil))
		    (ordered/cons
		       (bounded/cons
			  (bounded/cons
			     (Dbounded' z f)
			     (DprecIJ z f x d))
			  (DprecJK x d y e)))
		    (DofO' x d y e)
		    (DofO'' z f x d y e : ofe (cons (cons (cons G z (sigma A ([_] B))) x A) y B) (O x y) (C x y)))
	   %% back to work
	   <- ofe-reg DofM
	      (DwfA : wfe G A)
	   <- ofe-reg DofN
	      (DwfB : wfe G B)
	   <- ({x} {d:isvar x I}
		 weaken-wfe (Dbounded' x d) DwfB _
		    (DwfB' x d : wfe (cons G x A) B))
	   <- ({z} {f:isvar z I}
		 weaken-wfe (Dbounded' z f) (wfe/sigma DwfB' DwfA) _
		    (DwfAB z f : wfe (cons G z (sigma A ([_] B))) (sigma A ([_] B))))
	   <- ({z} {f:isvar z I}
		 {x} {d:isvar x J}
		 weaken-wfe (bounded/cons (Dbounded' z f) (DprecIJ z f x d)) (DwfAB z f) _
		    (DwfAB' z f x d : wfe (cons (cons G z (sigma A ([_] B))) x A) (sigma A ([_] B))))
	   <- ({z} {f:isvar z I}
		 {x} {d:isvar x J}
		 ssubst-e ([_] append/nil) append/nil ([y] [e] DofO'' z f x d y e)
		    (aofe/pi2 (aofe/var (DwfAB' z f x d) 
				 (lookup/miss 
				    (lookup/hit (Dbounded' z f)) 
				    (bounded/cons (Dbounded' z f) (DprecIJ z f x d))))
		       : aofe (cons (cons G z (sigma A ([_] B))) x A) (pi2 z) B)
		    (DofOypi2 z f x d : ofe (cons (cons G z (sigma A ([_] B))) x A) (O x (pi2 z)) (C x (pi2 z))))
	   <- ({x} {d:isvar x J}
		 can-sub-e ([_] append/cons append/nil) ([z] [f] DofOypi2 z f x d) (ofe/pair DwfB' DofN DsubB DofM)
		    (DsubOyz x : sub ([z] O x (pi2 z)) (pair M N) (Oyz x)))
	   <- ({x} {d:isvar x J}
		 ssub-ao-permute-e ([_] append/cons append/nil)
		    (ofe/pair DwfB' DofN DsubB DofM : ofe G (pair M N) (sigma A ([_] B)))
		    ([z] [f:isvar z I]
		       aofe/pi2 (aofe/var (DwfAB' z f x d) 
				   (lookup/miss 
				      (lookup/hit (Dbounded' z f)) 
				      (bounded/cons (Dbounded' z f) (DprecIJ z f x d))))
		       : aofe (cons (cons G z (sigma A ([_] B))) x A) (pi2 z) B)
		    ([z] [f:isvar z I] [y] [e:isvar y K] DofO'' z f x d y e)
		    ([y] DsubOz x y : sub ([z] O x y) (pair M N) (O x y))
		    (aosub/pi2 aosub/var : aosub ([z] pi2 z) (pair M N) N)
		    (DsubOy x)
		    (DsubOyz x)
		    (DeqOyz x : term-eq (Oy x) (Oyz x)))
	   <- ({x}
		 term-eq-symm (DeqOyz x)
		 (DeqOyz' x : term-eq (Oyz x) (Oy x)))
	   <- ({x}
		 sub-resp ([_] term-eq/i) term-eq/i (DeqOyz' x) (DsubOyz x)
		 (DsubOyz' x : sub ([z] O x (pi2 z)) (pair M N) (Oy x)))
	   <- ssub-ao-permute-e ([_] append/nil)
	      (ofe/pair DwfB' DofN DsubB DofM : ofe G (pair M N) (sigma A ([_] B)))
	      ([z] [f:isvar z I]
		 aofe/pi1 (aofe/var (DwfAB z f) (lookup/hit (Dbounded' z f)))
		 : aofe (cons G z (sigma A ([_] B))) (pi1 z) A)
	      ([z] [f:isvar z I] [x] [d:isvar x J] DofOypi2 z f x d)
	      DsubOyz'
	      (aosub/pi1 aosub/var : aosub ([z] pi1 z) (pair M N) M)
	      DsubOyx
	      Dsub
	      (DeqOyx : term-eq Oyx P)
	   <- sub-resp ([_] term-eq/i) term-eq/i DeqOyx DsubOyx
	      (DsubOyx' : sub ([x] Oy x) M P)
	   %% this is almost what we want, except we want Oxy, not Oyx
	   <- sub-absent N M
	      (DsubNx : sub ([_] N) M N)
	   <- sub-permute-e ([_] append/nil) DofM DofN' DofO
	      DsubOx DsubNx DsubOxy DsubOy DsubOyx'
	      (DeqOxy : term-eq Oxy P)
	   <- sub-resp ([_] term-eq/i) term-eq/i DeqOxy DsubOxy
	      (DsubOxy' : sub ([y] Ox y) N P).
	      
%worlds (bind | ovar) (subst-simult-pair-e _ _ _ _ _ _).
%total {} (subst-simult-pair-e _ _ _ _ _ _).



tsubst-context-permute-e : ({x} isvar x I -> ofe (cons G x A) (M x) B)
			    -> ({x} isvar x J -> ofe (cons G x B) (N x) C)
			    -> ({x} isvar x K -> wfe (cons G x C) (D x))
			    -> ({x} sub N (M x) (NM x))
			    -> ({x} tsub D (N x) (Db x))
			    -> ({x} tsub D (NM x) (Dc x))
%%
			    -> ({x} tsub Db (M x) (Dc x)) -> type.
%mode tsubst-context-permute-e +X1 +X2 +X3 +X4 +X5 +X6 -X7.

-	: tsubst-context-permute-e
	   (DofM : {x} isvar x I -> ofe (cons G x A) (M x) B)
	   (DofN : {y} isvar y J -> ofe (cons G y B) (N y) C)
	   (DwfD : {z} isvar z K -> wfe (cons G z C) (D z))
	   (DsubNM : {x} sub N (M x) (NM x))
	   (DsubDb : {y} tsub D (N y) (Db y))
	   (DsubDc : {x} tsub D (NM x) (Dc x))
	   DsubDc''
	   <- tsubst-context-e DofN DwfD DsubDb 
	      (DwfDb : {y} isvar y J -> wfe (cons G y B) (Db y))
	   <- can-tsub-context-e DofM DwfDb
	      (DsubDc' : {x} tsub Db (M x) (Dc' x))
	   <- ({x} {z}
		 tsub-absent (D z) (M x)
		 (DsubDabs x z : tsub ([y] D z) (M x) (D z)))
	   <- ({x} {d:isvar x I}
		 ofe-context (DofM x d)
		 (ordered/cons
		    (DboundI x d : bounded G x)))
	   <- weaken-ofe-insert1 DofN DboundI _
	      (DofN' : {x} isvar x I -> {y} isvar y J' -> ofe (cons (cons G x A) y B) (N y) C)
	   <- ({x} {d:isvar x I} {y} {e:isvar y J'}
		 ofe-context (DofN' x d y e)
		 (ordered/cons
		    (bounded/cons
		       _
		       (DprecIJ x d y e : precedes x y))))
	   <- weaken-wfe-insert1 DwfD DboundI _
	      (DwfD' : {x} isvar x I -> {z} isvar z K' -> wfe (cons (cons G x A) z C) (D z))
	   <- ({x} {d}
		 weaken-wfe-insert1 (DwfD' x d) ([y] [e] bounded/cons (DboundI x d) (DprecIJ x d y e)) _
		 (DwfD'' x d : {y} isvar y J' -> {z} isvar z K'' -> wfe (cons (cons (cons G x A) y B) z C) (D z)))
	   <- ({x} {d}
		 tsub-permute-e ([_] append/nil) (DofM x d) (DofN' x d) (DwfD'' x d)
		 (DsubDabs x) (DsubNM x) (DsubDc x) DsubDb (DsubDc' x)
		 (Deq x : tp-eq (Dc x) (Dc' x)))
	   <- ({x}
		 tp-eq-symm (Deq x)
		 (Deq' x : tp-eq (Dc' x) (Dc x)))
	   <- ({x}
		 tsub-resp ([_] tp-eq/i) term-eq/i (Deq' x) (DsubDc' x)
		 (DsubDc'' x : tsub Db (M x) (Dc x))).

%worlds (var | bind | ovar) (tsubst-context-permute-e _ _ _ _ _ _ _).
%total {} (tsubst-context-permute-e _ _ _ _ _ _ _).



aasub-into-sub-e : ofe G M A
		    -> ({x} isvar x I -> aofe (cons G x A) (R x) (B x))
		    -> ({x} isvar x I' -> {y} isvar y J -> ofe (cons (cons G x A) y (B x)) (O x y) (C x y))
		    -> ({y} sub ([x] O x y) M (Ox y))
		    -> aasub ([x] R x) M Rx
%%
		    -> sub ([x] O x (R x)) M (Ox Rx) -> type.
%mode aasub-into-sub-e +X1 +X2 +X3 +X4 +X5 -X6.

-	: aasub-into-sub-e DofM DofR DofO DsubOx DsubRx DsubOyx'
	   <- ({x} {d}
		 aofe-context (DofR x d) (Dord x d))
	   <- bump-ofe-under DofO Dord DofO'
	   <- ({x} {d}
		 ssubst-e ([_] append/nil) append/nil (DofO' x d) (DofR x d)
		 (DofOy x d))
	   <- can-sub-e ([_] append/nil) DofOy DofM
	      DsubOyx
	   <- ssub-aa-permute-e ([_] append/nil) DofM DofR DofO' DsubOx DsubRx DsubOyx
	      Deq
	   <- term-eq-symm Deq Deq'
	   <- sub-resp ([_] term-eq/i) term-eq/i Deq' DsubOyx DsubOyx'.

%worlds (var | bind | ovar) (aasub-into-sub-e _ _ _ _ _ _).
%total {} (aasub-into-sub-e _ _ _ _ _ _).



aosub-into-ssub-e : ofe G M A
		     -> ({x} isvar x I -> aofe (cons G x A) (R x) B)
		     -> ({y} isvar y J -> ofe (cons G y B) (N y) (C y))
		     -> aosub ([x] R x) M LRx
		     -> sub ([y] N y) LRx Ny
%%
		     -> sub ([x] N (R x)) M Ny -> type.
%mode aosub-into-ssub-e +X1 +X2 +X3 +X4 +X5 -X6.

-	: aosub-into-ssub-e DofM DofR DofN DsubRx DsubNxy DsubNyx'
	   <- ssubst-context-e DofR DofN DofNy
	   <- can-sub-e ([_] append/nil) DofNy DofM 
	      DsubNyx
	   <- ({x} {d}
		 aofe-context (DofR x d)
		 (ordered/cons
		    (Dbound x d)))
	   <- weaken-ofe-insert1 DofN Dbound _ DofN'
	   <- ({y} 
		 sub-absent (N y) M (DsubNabs y))
	   <- ssub-ao-permute-e ([_] append/nil) DofM DofR DofN' DsubNabs DsubRx DsubNxy DsubNyx
	      Deq
	   <- term-eq-symm Deq Deq'
	   <- sub-resp ([_] term-eq/i) term-eq/i Deq' DsubNyx DsubNyx'.

%worlds (var | bind | ovar) (aosub-into-ssub-e _ _ _ _ _ _).
%total {} (aosub-into-ssub-e _ _ _ _ _ _).



aosub-into-ssub-e' : ({z} isvar z K -> ofe (cons G z D) (M z) A)
		     -> ({x} isvar x I -> aofe (cons G x A) (R x) B)
		     -> ({y} isvar y J -> ofe (cons G y B) (N y) (C y))
		     -> ({z} aosub ([x] R x) (M z) (LRx z))
		     -> ({z} sub ([y] N y) (LRx z) (Ny z))
%%
		     -> ({z} sub ([x] N (R x)) (M z) (Ny z)) -> type.
%mode aosub-into-ssub-e' +X1 +X2 +X3 +X4 +X5 -X6.

-	: aosub-into-ssub-e' DofM DofR DofN DsubRx DsubNxy DsubNyx
	   <- ({z} {f}
		 ofe-context (DofM z f)
		 (ordered/cons
		    (Dbound z f)))
	   <- weaken-aofe-insert1 DofR Dbound _ DofR'
	   <- weaken-ofe-insert1 DofN Dbound _ DofN'
	   <- ({z} {f}
		 aosub-into-ssub-e (DofM z f) (DofR' z f) (DofN' z f) (DsubRx z) (DsubNxy z) (DsubNyx z)).

%worlds (var | bind | ovar) (aosub-into-ssub-e' _ _ _ _ _ _).
%total {} (aosub-into-ssub-e' _ _ _ _ _ _).



aosub-into-ssub-e'' : ofe G M A
		       -> ({x} isvar x I -> aofe (cons G x A) (Q x) B)
		       -> ({x} isvar x J -> aofe (cons G x A) (R x) (C (Q x)))
		       -> ({x} isvar x K -> {y} isvar y K' -> ofe (cons (cons G x B) y (C x)) (N x y) (D x y))
		       -> aosub ([x] Q x) M LQx
		       -> aosub ([x] R x) M LRx
		       -> ({y} sub ([x] N x y) LQx (Nx y))
		       -> sub Nx LRx Nxy
%%
		       -> sub ([x] N (Q x) (R x)) M Nxy -> type.
%mode aosub-into-ssub-e'' +X1 +X2 +X3 +X4 +X5 +X6 +X7 +X8 -X9.

-	: aosub-into-ssub-e'' 
	   (DofM : ofe G M A)
	   (DofQ : {x} isvar x I -> aofe (cons G x A) (Q x) B)
	   (DofR : {x} isvar x I' -> aofe (cons G x A) (R x) (C (Q x)))
	   (DofN : {y} isvar y J -> {z} isvar z K -> ofe (cons (cons G y B) z (C y)) (N y z) (D y z))
	   (DsubQx : aosub Q M LQx)
	   (DsubRx : aosub R M LRx)
	   (DsubNy : {z} sub ([y] N y z) LQx (Ny z))
	   (DsubNyz : sub Ny LRx Nyz)
	   DsubNyzx'
	   <- ({x} {d:isvar x I}
		 aofe-context (DofQ x d)
		 (ordered/cons
		    (Dbound x d : bounded G x)))
	   <- weaken-ofe-insert2 DofN Dbound _ 
	      (DofN' : {x} isvar x I
			-> {y} isvar y J'
			-> {z} isvar z K'
			-> ofe (cons (cons (cons G x A) y B) z (C y)) (N y z) (D y z))
	   <- ({x} {d:isvar x I} {z} {f:isvar z K'}
		 ssubst-e ([_] append/cons append/nil) (append/cons append/nil) 
		 ([y] [e] DofN' x d y e z f) (DofQ x d)
		 (DofNy x d z f : ofe (cons (cons G x A) z (C (Q x))) (N (Q x) z) (D (Q x) z)))
	   <- ({z} {f}
		 can-sub-e ([_] append/cons append/nil) ([x] [d] DofNy x d z f) DofM 
		 (DsubNyx z : sub ([x] N (Q x) z) M (Nyx z)))
	   <- ({y} {z}
		 sub-absent (N y z) M
		 (DsubNabs y z : sub ([x] N y z) M (N y z)))
	   <- ({z} {f}
		 ssub-ao-permute2-e ([_] append/nil) DofM DofQ ([x] [d] [y] [e] DofN' x d y e z f)
		 ([y] DsubNabs y z) DsubQx (DsubNy z) (DsubNyx z)
		 (Deq1 z : term-eq (Ny z) (Nyx z)))
	   <- ({z}
		 term-eq-symm (Deq1 z)
		 (Deq1' z : term-eq (Nyx z) (Ny z)))
	   <- ({z}
		  sub-resp ([_] term-eq/i) term-eq/i (Deq1' z) (DsubNyx z)
		  (DsubNyx' z : sub ([x] N (Q x) z) M (Ny z)))
	   <- bump-aofe DofR ([x] [d] ordered/cons (Dbound x d))
	      (DofR' : {x} isvar x I -> aofe (cons G x A) (R x) (C (Q x)))
	   <- ({x} {d:isvar x I}
		 ssubst-e ([_] append/nil) append/nil
		 ([z] [f] DofNy x d z f) (DofR' x d)
		 (DofNyz x d : ofe (cons G x A) (N (Q x) (R x)) (D (Q x) (R x))))
	   <- can-sub-e ([_] append/nil) DofNyz DofM
	      (DsubNyzx : sub ([x] N (Q x) (R x)) M Nyzx)
	   <- ssub-ao-permute-e ([_] append/nil) DofM DofR' DofNy
	      DsubNyx' DsubRx DsubNyz DsubNyzx
	      (Deq2 : term-eq Nyz Nyzx)
	   <- term-eq-symm Deq2
	      (Deq2' : term-eq Nyzx Nyz)
	   <- sub-resp ([_] term-eq/i) term-eq/i Deq2' DsubNyzx
	      (DsubNyzx' : sub ([x] N (Q x) (R x)) M Nyz).

%worlds (var | bind | ovar) (aosub-into-ssub-e'' _ _ _ _ _ _ _ _ _).
%total {} (aosub-into-ssub-e'' _ _ _ _ _ _ _ _ _).



aosub-into-ssub-e''' : ({z} isvar z L -> ofe (cons G z E) (M z) A)
			-> ({x} isvar x I -> aofe (cons G x A) (Q x) B)
			-> ({x} isvar x J -> aofe (cons G x A) (R x) (C (Q x)))
			-> ({x} isvar x K -> {y} isvar y K' -> ofe (cons (cons G x B) y (C x)) (N x y) (D x y))
			-> ({z} aosub ([x] Q x) (M z) (LQx z))
			-> ({z} aosub ([x] R x) (M z) (LRx z))
			-> ({z} {y} sub ([x] N x y) (LQx z) (Nx z y))
			-> ({z} sub ([y] Nx z y) (LRx z) (Nxy z))
%%
			-> ({z} sub ([x] N (Q x) (R x)) (M z) (Nxy z)) -> type.
%mode aosub-into-ssub-e''' +X1 +X2 +X3 +X4 +X5 +X6 +X7 +X8 -X9.

-	: aosub-into-ssub-e''' DofM DofQ DofR DofN DsubQx DsubRx DsubNxy1 DsubNxy2 DsubNyx
	   <- ({z} {f}
		 ofe-context (DofM z f)
		 (ordered/cons
		    (Dbound z f)))
	   <- weaken-aofe-insert1 DofQ Dbound _ DofQ'
	   <- weaken-aofe-insert1 DofR Dbound _ DofR'
	   <- weaken-ofe-insert2 DofN Dbound _ DofN'
	   <- ({z} {f}
		 aosub-into-ssub-e'' (DofM z f) (DofQ' z f) (DofR' z f) (DofN' z f) (DsubQx z) (DsubRx z) (DsubNxy1 z) (DsubNxy2 z) (DsubNyx z)).

%worlds (var | bind | ovar) (aosub-into-ssub-e''' _ _ _ _ _ _ _ _ _).
%total {} (aosub-into-ssub-e''' _ _ _ _ _ _ _ _ _).