{ mlt_inning_val()   
   
   
   List 
 List   
   
   (
 (  + (
 + (  
   
   
   
  ))
))
                     
  (?
 (?  
   
   
   
   + (
 + (  
   
  )) }
)) }
{ Proof }
Definitions occuring in Statement : 
mlt_inning_val: mlt_inning_val(), 
nat:  , 
unit: Unit, 
member: t 
, 
unit: Unit, 
member: t   T, 
function: x:A 
 T, 
function: x:A 
  B[x], 
product: x:A 
 B[x], 
product: x:A   B[x], 
union: left + right, 
list: type List, 
int:
 B[x], 
union: left + right, 
list: type List, 
int:  
Definitions : 
int:  , 
member: t 
, 
member: t   T, 
equal: s = t, 
nat:
 T, 
equal: s = t, 
nat:  , 
product: x:A 
, 
product: x:A   B[x], 
union: left + right, 
list: type List, 
unit: Unit, 
pair: <a, b>, 
universe: Type, 
inr: inr x , 
inl: inl x , 
cons: [car / cdr], 
function: x:A 
 B[x], 
union: left + right, 
list: type List, 
unit: Unit, 
pair: <a, b>, 
universe: Type, 
inr: inr x , 
inl: inl x , 
cons: [car / cdr], 
function: x:A 
  B[x], 
all:
 B[x], 
all:  x:A. B[x], 
strict-majority-or-max: strict-majority-or-max(L), 
l_member: (x 
x:A. B[x], 
strict-majority-or-max: strict-majority-or-max(L), 
l_member: (x   l), 
prop:
 l), 
prop:  , 
set: {x:A| B[x]} , 
eq_int: (i =
, 
set: {x:A| B[x]} , 
eq_int: (i =  j), 
bool:
 j), 
bool:  , 
bnot:
, 
bnot: 
 b, 
lambda:
b, 
lambda:  x.A[x], 
so_lambda:
x.A[x], 
so_lambda: 
 x.t[x], 
bl-exists: (
x.t[x], 
bl-exists: ( x
x L.P[x])_b, 
ifthenelse: if b then t else f fi , 
le: A 
L.P[x])_b, 
ifthenelse: if b then t else f fi , 
le: A   B, 
ge: i 
 B, 
ge: i   j , 
le_int: i 
 j , 
le_int: i  z j, 
spread: spread def, 
natural_number: $n, 
less_than: a < b, 
void: Void, 
implies: P 
z j, 
spread: spread def, 
natural_number: $n, 
less_than: a < b, 
void: Void, 
implies: P 
  Q, 
false: False, 
not:
 Q, 
false: False, 
not:  A, 
p-outcome: Outcome, 
subtype_rel: A 
A, 
p-outcome: Outcome, 
subtype_rel: A  r B, 
strong-subtype: strong-subtype(A;B), 
rationals:
r B, 
strong-subtype: strong-subtype(A;B), 
rationals:  , 
subtype: S 
, 
subtype: S   T, 
real:
 T, 
real:  , 
decide: case b of inl(x) => s[x] | inr(y) => t[y], 
spreadn: spread3, 
fpf: a:A fp-> B[a], 
guard: {T}, 
sq_type: SQType(T), 
sqequal: s ~ t, 
true: True, 
squash:
, 
decide: case b of inl(x) => s[x] | inr(y) => t[y], 
spreadn: spread3, 
fpf: a:A fp-> B[a], 
guard: {T}, 
sq_type: SQType(T), 
sqequal: s ~ t, 
true: True, 
squash:  T, 
assert:
T, 
assert:  b, 
and: P 
b, 
and: P   Q, 
iff: P 
 Q, 
iff: P 

  Q, 
rev_implies: P 
 Q, 
rev_implies: P 
  Q, 
apply: f a, 
so_apply: x[s], 
or: P 
 Q, 
apply: f a, 
so_apply: x[s], 
or: P   Q, 
pi2: snd(t), 
limited-type: LimitedType, 
pi1: fst(t), 
bfalse: ff, 
btrue: tt, 
length: ||as||, 
isect:
 Q, 
pi2: snd(t), 
limited-type: LimitedType, 
pi1: fst(t), 
bfalse: ff, 
btrue: tt, 
length: ||as||, 
isect:  x:A. B[x], 
top: Top, 
nil: [], 
add: n + m, 
mlt_inning_val: mlt_inning_val()
x:A. B[x], 
top: Top, 
nil: [], 
add: n + m, 
mlt_inning_val: mlt_inning_val()
Lemmas : 
length_wf1, 
top_wf, 
false_wf, 
length_wf_nat, 
non_neg_length, 
btrue_wf, 
bfalse_wf, 
bool_wf, 
decide_wf, 
pi1_wf, 
pi2_wf, 
cons_one_one, 
assert_wf, 
guard_wf, 
nat_sq, 
int_sq, 
member_wf, 
le_wf, 
le_int_wf, 
nat_properties, 
ifthenelse_wf, 
bl-exists_wf, 
bnot_wf, 
eq_int_wf, 
l_member_wf, 
strict-majority-or-max_wf, 
unit_wf, 
nat_wf
mlt\_inning\_val()  \mmember{}  \mBbbN{}  \mtimes{}  \mBbbZ{}  List  \mtimes{}  \mBbbN{}  \mtimes{}  (\mBbbZ{}  +  (\mBbbN{}  \mtimes{}  \mBbbN{}  \mtimes{}  \mBbbZ{}))  {}\mrightarrow{}  (?\mBbbN{}  \mtimes{}  \mBbbN{}  \mtimes{}  \mBbbZ{}  +  (\mBbbN{}  \mtimes{}  \mBbbZ{}))
 Date html generated: 
2010_08_27-PM-08_31_01
 Last ObjectModification: 
2010_06_23-PM-11_58_58
Home
Index