{ 
[E:Type]. 
[dom:E 
 
]. 
[l:E 
 Id]. 
[R:E 
 E 
 
]. 
[a:
e1,e2:E.
                                                                  ((e1 = e2)
                                                                  
 (
(e1
                                                                    = e2)))].
  
[b:
f:E 
 
. 
x,y:E.  ((x R y) 
 ((f x) < (f y)))]. 
[c:
e1,e2:E.
                                                               ((e1 R e2)
                                                               
 (
(e1 R e2)))].
  
[d:
x,y,z:E.  ((x R y) 
 (y R z) 
 (x R z))]. 
[e:
x:E
                                                         
L:E List
                                                          
z:E
                                                            ((z R x)
                                                            
 (z 
 L))].
  
[f:
e1,e2:E.  (e1 = e2) 
 (e1 R e2) 
 (e2 R e1) supposing (l e1) = (l e2)].
    (mk-eo(E;dom;l;R;a;b;c;d;e;f) 
 EO) }
{ Proof }
Definitions occuring in Statement : 
mk-eo: mk-eo(E;dom;l;R;a;b;c;d;e;f), 
event_ordering: EO, 
Id: Id, 
bool:
, 
nat:
, 
uimplies: b supposing a, 
uall:
[x:A]. B[x], 
prop:
, 
infix_ap: x f y, 
all:
x:A. B[x], 
exists:
x:A. B[x], 
not:
A, 
implies: P 
 Q, 
or: P 
 Q, 
member: t 
 T, 
less_than: a < b, 
apply: f a, 
function: x:A 
 B[x], 
list: type List, 
universe: Type, 
equal: s = t, 
l_member: (x 
 l)
Definitions : 
rec_select_update: rec_select_update{rec_select_update_compseq_tag_def:o}(y; v; x; r), 
guard: {T}, 
sq_type: SQType(T), 
lt_int: i <z j, 
le_int: i 
z j, 
bfalse: ff, 
btrue: tt, 
iff: P 

 Q, 
null: null(as), 
set_blt: a <
 b, 
grp_blt: a <
 b, 
dcdr-to-bool: [d]
, 
bl-all: (
x
L.P[x])_b, 
bl-exists: (
x
L.P[x])_b, 
b-exists: (
i<n.P[i])_b, 
eq_type: eq_type(T;T'), 
eq_atom: eq_atom$n(x;y), 
qeq: qeq(r;s), 
q_less: q_less(r;s), 
q_le: q_le(r;s), 
deq-member: deq-member(eq;x;L), 
deq-disjoint: deq-disjoint(eq;as;bs), 
deq-all-disjoint: deq-all-disjoint(eq;ass;bs), 
eq_str: Error :eq_str, 
eq_id: a = b, 
eq_lnk: a = b, 
bimplies: p 

 q, 
band: p 
 q, 
bor: p 
q, 
assert:
b, 
bnot: 
b, 
unit: Unit, 
void: Void, 
record-update: r[x := v], 
token: "$token", 
eq_atom: x =a y, 
top: Top, 
ifthenelse: if b then t else f fi , 
lambda:
x.A[x], 
atom: Atom, 
record+: record+, 
record-select: r.x, 
limited-type: LimitedType, 
set: {x:A| B[x]} , 
real:
, 
grp_car: |g|, 
subtype: S 
 T, 
int:
, 
fpf: a:A fp-> B[a], 
strong-subtype: strong-subtype(A;B), 
le: A 
 B, 
ge: i 
 j , 
and: P 
 Q, 
uiff: uiff(P;Q), 
subtype_rel: A 
r B, 
axiom: Ax, 
mk-eo: mk-eo(E;dom;l;R;a;b;c;d;e;f), 
event_ordering: EO, 
uimplies: b supposing a, 
list: type List, 
l_member: (x 
 l), 
nat:
, 
apply: f a, 
infix_ap: x f y, 
less_than: a < b, 
implies: P 
 Q, 
product: x:A 
 B[x], 
exists:
x:A. B[x], 
not:
A, 
union: left + right, 
or: P 
 Q, 
equal: s = t, 
bool:
, 
Id: Id, 
prop:
, 
universe: Type, 
uall:
[x:A]. B[x], 
isect:
x:A. B[x], 
member: t 
 T, 
all:
x:A. B[x], 
function: x:A 
 B[x], 
record: record(x.T[x])
Lemmas : 
bnot_wf, 
assert_wf, 
not_wf, 
bool_wf, 
assert_of_eq_atom, 
not_functionality_wrt_uiff, 
assert_of_bnot, 
uiff_transitivity, 
eqff_to_assert, 
iff_weakening_uiff, 
eqtt_to_assert, 
top_wf, 
eq_atom_wf, 
ifthenelse_wf, 
Id_wf, 
nat_wf, 
l_member_wf, 
event_ordering_wf, 
member_wf, 
subtype_base_sq, 
atom_subtype_base
\mforall{}[E:Type].  \mforall{}[dom:E  {}\mrightarrow{}  \mBbbB{}].  \mforall{}[l:E  {}\mrightarrow{}  Id].  \mforall{}[R:E  {}\mrightarrow{}  E  {}\mrightarrow{}  \mBbbP{}].
\mforall{}[a:\mforall{}e1,e2:E.    ((e1  =  e2)  \mvee{}  (\mneg{}(e1  =  e2)))].  \mforall{}[b:\mexists{}f:E  {}\mrightarrow{}  \mBbbN{}.  \mforall{}x,y:E.    ((x  R  y)  {}\mRightarrow{}  ((f  x)  <  (f  y)))].
\mforall{}[c:\mforall{}e1,e2:E.    ((e1  R  e2)  \mvee{}  (\mneg{}(e1  R  e2)))].  \mforall{}[d:\mforall{}x,y,z:E.    ((x  R  y)  {}\mRightarrow{}  (y  R  z)  {}\mRightarrow{}  (x  R  z))].
\mforall{}[e:\mforall{}x:E.  \mexists{}L:E  List.  \mforall{}z:E.  ((z  R  x)  {}\mRightarrow{}  (z  \mmember{}  L))].  \mforall{}[f:\mforall{}e1,e2:E.
                                                                                                                (e1  =  e2)  \mvee{}  (e1  R  e2)  \mvee{}  (e2  R  e1) 
                                                                                                                supposing  (l  e1)  =  (l  e2)].
    (mk-eo(E;dom;l;R;a;b;c;d;e;f)  \mmember{}  EO)
Date html generated:
2011_08_16-AM-10_19_57
Last ObjectModification:
2011_06_18-AM-09_08_12
Home
Index