Nuprl Definition : union-ss
ss1 + ss2 ==
  Point=Point(ss1) + Point(ss2) #=λp,q. union-sep(ss1;ss2;p;q) cotrans=λx,y,z,sep. case x
                                                                               of inl(a) =>
                                                                               case y
                                                                                of inl(a') =>
                                                                                case z
                                                                                 of inl(a'') =>
                                                                                 ss1."#or" a a' a'' sep
                                                                                 | inr(_) =>
                                                                                 inl Ax
                                                                                | inr(b') =>
                                                                                case z
                                                                                 of inl(_) =>
                                                                                 inr Ax 
                                                                                 | inr(_) =>
                                                                                 inl Ax
                                                                               | inr(b) =>
                                                                               case y
                                                                                of inl(a') =>
                                                                                case z
                                                                                 of inl(_) =>
                                                                                 inl Ax
                                                                                 | inr(_) =>
                                                                                 inr Ax 
                                                                                | inr(b') =>
                                                                                case z
                                                                                 of inl(_) =>
                                                                                 inl Ax
                                                                                 | inr(b'') =>
                                                                                 ss2."#or" b b' b'' sep
Definitions occuring in Statement : 
union-sep: union-sep(ss1;ss2;p;q)
, 
mk-ss: Point=P #=Sep cotrans=C
, 
ss-point: Point(ss)
, 
apply: f a
, 
lambda: λx.A[x]
, 
decide: case b of inl(x) => s[x] | inr(y) => t[y]
, 
inr: inr x 
, 
inl: inl x
, 
union: left + right
, 
token: "$token"
, 
axiom: Ax
, 
record-select: r.x
Definitions occuring in definition : 
mk-ss: Point=P #=Sep cotrans=C
, 
union: left + right
, 
ss-point: Point(ss)
, 
union-sep: union-sep(ss1;ss2;p;q)
, 
lambda: λx.A[x]
, 
inr: inr x 
, 
decide: case b of inl(x) => s[x] | inr(y) => t[y]
, 
inl: inl x
, 
axiom: Ax
, 
apply: f a
, 
record-select: r.x
, 
token: "$token"
FDL editor aliases : 
union-ss
Latex:
ss1  +  ss2  ==
    Point=Point(ss1)  +  Point(ss2)  \#=\mlambda{}p,q.  union-sep(ss1;ss2;p;q)  cotrans=\mlambda{}x,y,z,sep.  case  x
                                                                                                                                                              of  inl(a)  =>
                                                                                                                                                              case  y
                                                                                                                                                                of  inl(a')  =>
                                                                                                                                                                case  z
                                                                                                                                                                  of  inl(a'')  =>
                                                                                                                                                                  ss1."\#or"  a  a'  a'' 
                                                                                                                                                                  sep
                                                                                                                                                                  |  inr($_\mbackslash{}ff\000C7b}$)  =>
                                                                                                                                                                  inl  Ax
                                                                                                                                                                |  inr(b')  =>
                                                                                                                                                                case  z
                                                                                                                                                                  of  inl($_\mbackslash{}f\000Cf7b}$)  =>
                                                                                                                                                                  inr  Ax 
                                                                                                                                                                  |  inr($_\mbackslash{}ff\000C7b}$)  =>
                                                                                                                                                                  inl  Ax
                                                                                                                                                              |  inr(b)  =>
                                                                                                                                                              case  y
                                                                                                                                                                of  inl(a')  =>
                                                                                                                                                                case  z
                                                                                                                                                                  of  inl($_\mbackslash{}f\000Cf7b}$)  =>
                                                                                                                                                                  inl  Ax
                                                                                                                                                                  |  inr($_\mbackslash{}ff\000C7b}$)  =>
                                                                                                                                                                  inr  Ax 
                                                                                                                                                                |  inr(b')  =>
                                                                                                                                                                case  z
                                                                                                                                                                  of  inl($_\mbackslash{}f\000Cf7b}$)  =>
                                                                                                                                                                  inl  Ax
                                                                                                                                                                  |  inr(b'')  =>
                                                                                                                                                                  ss2."\#or"  b  b'  b'' 
                                                                                                                                                                  sep
Date html generated:
2019_10_31-AM-07_27_00
Last ObjectModification:
2019_09_19-PM-04_10_46
Theory : constructive!algebra
Home
Index