Nuprl Lemma : bind-class-locally-programmable
[Info:{Info:Type| 
Info} ]
  
A,B:{T:Type| valueall-type(T)} .
    
[X:EClass(A)]. 
[Y:A 
 EClass(B)].
      (NormalLProgrammable(A;X) 
 (
a:A. NormalLProgrammable(B;Y[a])) 
 NormalLProgrammable(B;X >a> Y[a]))
Proof not projected
Definitions occuring in Statement : 
normal-locally-programmable: NormalLProgrammable(A;X), 
bind-class: X >x> Y[x], 
eclass: EClass(A[eo; e]), 
uall:
[x:A]. B[x], 
so_apply: x[s], 
all:
x:A. B[x], 
squash:
T, 
implies: P 
 Q, 
set: {x:A| B[x]} , 
function: x:A 
 B[x], 
universe: Type, 
valueall-type: valueall-type(T)
Definitions : 
so_lambda: 
x y.t[x; y], 
true: True, 
and: P 
 Q, 
so_lambda: 
x.t[x], 
prop:
, 
member: t 
 T, 
exists:
x:A. B[x], 
local-program-at: local-program-at{i:l}(Info;A;X;dfp;x), 
sq_exists:
x:{A| B[x]}, 
so_apply: x[s], 
normal-locally-programmable: NormalLProgrammable(A;X), 
implies: P 
 Q, 
all:
x:A. B[x], 
squash:
T, 
uall:
[x:A]. B[x], 
ifthenelse: if b then t else f fi , 
bfalse: ff, 
top: Top, 
assert:
b, 
not:
A, 
subtype: S 
 T, 
spreadn: spread4, 
pi1: fst(t), 
df-program-type: df-program-type(dfp), 
bind-df-program: bind-df-program, 
bind-class: X >x> Y[x], 
rev_implies: P 
 Q, 
iff: P 

 Q, 
es-le-before:
loc(e), 
suptype: suptype(S; T), 
false: False, 
le: A 
 B, 
let: let, 
bind-dataflow-aux: bind-dataflow-aux(P;dfs;a.Q[a]), 
pi2: snd(t), 
guard: {T}, 
or: P 
 Q, 
es-le: e 
loc e' , 
rev_subtype_rel: A 
r B, 
rev_uimplies: rev_uimplies(P;Q), 
nat:
, 
ycomb: Y, 
bag-map: bag-map(f;bs), 
bag-combine:
x
bs.f[x], 
map: map(f;as), 
reduce: reduce(f;k;as), 
concat: concat(ll), 
bag-union: bag-union(bbs), 
btrue: tt, 
es-before: before(e), 
compose: f o g, 
lt_int: i <z j, 
le_int: i 
z j, 
select: l[i], 
bnot: 
b, 
length: ||as||, 
null: null(as), 
last: last(L), 
so_apply: x[s1;s2], 
sq_stable: SqStable(P), 
uimplies: b supposing a, 
sq_type: SQType(T), 
dataflow-program: DataflowProgram(A), 
lelt: i 
 j < k, 
int_seg: {i..j
}, 
uiff: uiff(P;Q), 
unit: Unit, 
bool:
, 
eclass: EClass(A[eo; e]), 
single-bag: {x}, 
bag-append: as + bs, 
empty-bag: {}, 
it:
Lemmas : 
squash_wf, 
valueall-type_wf, 
event-ordering+_wf, 
eclass_wf, 
normal-locally-programmable_wf, 
bind-class_wf, 
df-program-type_wf, 
subtype_rel-equal, 
sq_stable__valueall-type, 
bind-df-program_wf, 
equal_wf, 
es-E_wf, 
event-ordering+_inc, 
es-loc_wf, 
local-program-at_wf, 
all_wf, 
dataflow-program_wf, 
Id_wf, 
sq_exists_wf, 
bfalse_wf, 
false_wf, 
bool_subtype_base, 
bool_wf, 
subtype_base_sq, 
es-le-before-not-null, 
es-le_wf, 
es-le-before_wf2, 
null-map, 
top_wf, 
null-data-stream, 
es-le-before_wf, 
es-info_wf, 
map_wf, 
bag_wf, 
last_wf, 
not_wf, 
assert_wf, 
null_wf3, 
data-stream_wf, 
true_wf, 
dataflow_wf, 
bind-df-program-meaning, 
dataflow_subtype, 
df-program-meaning_wf, 
decidable__es-le, 
sq_stable_from_decidable, 
member-eo-forward-E, 
eo-forward_wf, 
es-le-loc, 
bag-combine_wf, 
subtype_rel_self, 
list-subtype-bag, 
eo-forward-loc, 
bind-dataflow_wf, 
eo-forward-info, 
iterate-bind-dataflow, 
eo-forward-E-subtype, 
iterate-dataflow_wf, 
dataflow-ap_wf, 
pi2_wf, 
es-before_wf, 
select_wf, 
firstn_wf, 
nth_tl_wf, 
bag_qinc, 
upto_wf, 
length_wf, 
int_seg_wf, 
bag-map_wf, 
bag-map-append, 
and_wf, 
es-locl_wf, 
es-le_weakening, 
subtype_rel_dep_function, 
bag-combine-append-left, 
subtype_rel_sets, 
subtype_rel_bag, 
es-before_wf3, 
ext-eq_weakening, 
ext-eq_inversion, 
subtype_rel_weakening, 
subtype_rel_functionality_wrt_implies, 
bag-append_wf, 
length_wf_nat, 
map_length, 
non_neg_length, 
map-as-map-upto, 
map-id, 
bag-combine-map, 
decidable__es-locl, 
firstn-before, 
le_wf, 
firstn_map, 
select-map, 
eo-forward-before, 
nth_tl-es-before, 
es-ble_wf, 
filter_wf, 
select_member, 
member-es-before, 
nth_tl_map, 
length-map, 
bag-combine-assoc, 
assert_of_bnot, 
eqff_to_assert, 
bnot_wf, 
uiff_transitivity, 
eqtt_to_assert, 
eo-forward-first-trivial, 
btrue_wf, 
bag-append-empty, 
bag-map-map, 
last_append, 
not_functionality_wrt_uiff, 
append_is_nil, 
assert_of_null, 
append_wf, 
last-data-stream, 
map_append_sq, 
assert_of_lt_int, 
bnot_of_le_int, 
assert_functionality_wrt_uiff, 
less_than_wf, 
lt_int_wf, 
firstn_all, 
assert_of_le_int, 
le_int_wf, 
firstn-append, 
length_append
\mforall{}[Info:\{Info:Type|  \mdownarrow{}Info\}  ]
    \mforall{}A,B:\{T:Type|  valueall-type(T)\}  .
        \mforall{}[X:EClass(A)].  \mforall{}[Y:A  {}\mrightarrow{}  EClass(B)].
            (NormalLProgrammable(A;X)
            {}\mRightarrow{}  (\mforall{}a:A.  NormalLProgrammable(B;Y[a]))
            {}\mRightarrow{}  NormalLProgrammable(B;X  >a>  Y[a]))
Date html generated:
2012_01_23-PM-12_32_18
Last ObjectModification:
2012_01_06-AM-10_23_01
Home
Index