Nuprl Lemma : defined-by-rec-comb-program
[Info:Type]. 
[B:{B:Type| valueall-type(B)} ]. 
[Ps:eclass-program{i:l}(Info) List].
  
[F:k:
||Ps|| 
 bag(eclass-program-type(Ps[k])) 
 bag(B) 
 bag(B)]
    defined-class(rec-comb-program(F;B;Ps)) = F|
k.defined-class(Ps[k]),(self)'| 
    supposing 
buf:bag(B). ((F (
k.{}) buf) = {}) 
  supposing 0 < ||Ps||
Proof not projected
Definitions occuring in Statement : 
rec-comb-program: rec-comb-program(F;B;Ps), 
defined-class: defined-class(prg), 
eclass-program-type: eclass-program-type(prg), 
eclass-program: eclass-program{i:l}(Info), 
rec-combined-class: f|X,(self)'|, 
eclass: EClass(A[eo; e]), 
select: l[i], 
length: ||as||, 
int_seg: {i..j
}, 
uimplies: b supposing a, 
uall:
[x:A]. B[x], 
all:
x:A. B[x], 
less_than: a < b, 
set: {x:A| B[x]} , 
apply: f a, 
lambda:
x.A[x], 
function: x:A 
 B[x], 
list: type List, 
natural_number: $n, 
universe: Type, 
equal: s = t, 
empty-bag: {}, 
bag: bag(T), 
valueall-type: valueall-type(T)
Definitions : 
pi1: fst(t), 
fpf-dom: x 
 dom(f), 
fpf-cap: f(x)?z, 
mk_fpf: mk_fpf(L;f), 
false: False, 
not:
A, 
prop:
, 
le: A 
 B, 
so_lambda: 
x.t[x], 
and: P 
 Q, 
exists:
x:A. B[x], 
implies: P 
 Q, 
member: t 
 T, 
rec-comb-program: rec-comb-program(F;B;Ps), 
defined-class: defined-class(prg), 
all:
x:A. B[x], 
uimplies: b supposing a, 
uall:
[x:A]. B[x], 
so_lambda: 
x y.t[x; y], 
true: True, 
squash:
T, 
ifthenelse: if b then t else f fi , 
btrue: tt, 
bfalse: ff, 
eclass-program-type: eclass-program-type(prg), 
rec-combined-class: f|X,(self)'|, 
nat:
, 
ge: i 
 j , 
ycomb: Y, 
eclass: EClass(A[eo; e]), 
dataflow-set-class: dataflow-set-class(x.P[x]), 
map: map(f;as), 
dataflow-history-val: dataflow-history-val(es;e;x.P[x]), 
es-le-before:
loc(e), 
top: Top, 
subtype: S 
 T, 
length: ||as||, 
select: l[i], 
last: last(L), 
null: null(as), 
lt_int: i <z j, 
assert:
b, 
le_int: i 
z j, 
bnot: 
b, 
data-stream: data-stream(P;L), 
append: as @ bs, 
filter: filter(P;l), 
reduce: reduce(f;k;as), 
better-feedback-dataflow: better-feedback-dataflow(n;ds;F;s;x.P[x]), 
dataflow-out: dataflow-out(df;a), 
pi2: snd(t), 
guard: {T}, 
rev_implies: P 
 Q, 
iff: P 

 Q, 
es-le: e 
loc e' , 
or: P 
 Q, 
compose: f o g, 
lelt: i 
 j < k, 
so_apply: x[s], 
int_seg: {i..j
}, 
so_apply: x[s1;s2], 
bool:
, 
unit: Unit, 
sq_stable: SqStable(P), 
eclass-program: eclass-program{i:l}(Info), 
decidable: Dec(P), 
strongwellfounded: SWellFounded(R[x; y]), 
es-locl: (e <loc e'), 
uiff: uiff(P;Q), 
rev_uimplies: rev_uimplies(P;Q), 
sq_type: SQType(T), 
fpf-domain: fpf-domain(f), 
it:
, 
!hyp_hide: x
Lemmas : 
less_than_wf, 
length_wf, 
int_seg_wf, 
valueall-type_wf, 
empty-bag_wf, 
equal_wf, 
bag_wf, 
all_wf, 
union-list2_wf, 
top_wf, 
Id_wf, 
l_member_wf, 
and_wf, 
eclass-program_wf, 
select_member, 
select_wf, 
member_map, 
fpf_wf, 
eclass-program-type_wf, 
df-program-type_wf, 
dataflow-program_wf, 
fpf-trivial-subtype-top, 
eclass-program-flows_wf, 
fpf-domain_wf, 
map_wf, 
id-deq_wf, 
member-union-list2, 
event-ordering+_wf, 
event-ordering+_inc, 
es-E_wf, 
eclass_wf, 
true_wf, 
squash_wf, 
deq-member_wf, 
bool_wf, 
iff_transitivity, 
assert_wf, 
iff_weakening_uiff, 
eqtt_to_assert, 
assert-deq-member, 
bnot_wf, 
not_wf, 
eqff_to_assert, 
assert_of_bnot, 
not_functionality_wrt_iff, 
fpf-ap_wf, 
member-fpf-dom, 
null-df-program_wf, 
sq_stable__valueall-type, 
dataflow_wf, 
df-program-meaning_wf, 
df-program-meaning_wf_null, 
subtype_rel_self, 
subtype_rel_bag, 
sq_stable__subtype_rel, 
subtype_rel_weakening, 
ext-eq_weakening, 
dataflow_subtype, 
eclass-ext, 
dataflow-set-class_wf, 
ifthenelse_wf, 
better-feedback-dataflow_wf, 
length_wf_nat, 
lt_int_wf, 
bag-size_wf, 
nat_wf, 
constant-dataflow_wf, 
rec-combined-class_wf, 
es-loc_wf, 
decidable__l_member, 
decidable__equal_Id, 
es-causl-swellfnd, 
nat_properties, 
ge_wf, 
le_wf, 
es-causl_wf, 
primed-class-equal, 
es-locl_wf, 
prior-dataflow-set-class, 
map_append_sq, 
es-before_wf3, 
es-info_wf, 
es-before_wf, 
data-stream-append, 
data-stream-cons, 
last_append, 
upto_wf, 
eval-parallel-dataflow-property, 
pi2_wf, 
dataflow-ap_wf, 
pi1_wf_top, 
dataflow-out_wf, 
false_wf, 
iterate-dataflow_wf, 
rec-dataflow_wf, 
eval-parallel-dataflow_wf, 
uiff_transitivity, 
assert_of_lt_int, 
data-stream_wf, 
le_int_wf, 
assert_functionality_wrt_uiff, 
bnot_of_lt_int, 
assert_of_le_int, 
filter_wf, 
last-cons, 
null_wf3, 
assert_of_null, 
not_functionality_wrt_uiff, 
last_wf, 
append_wf, 
es-le-before_wf, 
null-data-stream, 
null-map, 
es-le-before_wf2, 
es-le_wf, 
es-le-before-not-null, 
subtype_base_sq, 
bool_subtype_base, 
bfalse_wf, 
length-data-stream, 
length-map, 
non_null_iff_length, 
subtype_rel_list, 
length_nil, 
non_neg_length, 
length_wf_nil, 
length_cons, 
length_append, 
data-stream-null-df-program, 
last-map, 
primed-class-cases, 
es-interface-top, 
es-first_wf, 
es-pred_wf, 
es-pred-causl, 
es-causle_weakening_locl, 
es-causl_transitivity2, 
es-pred-locl, 
es-locl_transitivity2, 
es-le_weakening, 
es-le-loc, 
es-loc-pred, 
constant-data-stream, 
length_upto, 
map-map, 
length-map-sq, 
list_extensionality
\mforall{}[Info:Type].  \mforall{}[B:\{B:Type|  valueall-type(B)\}  ].  \mforall{}[Ps:eclass-program\{i:l\}(Info)  List].
    \mforall{}[F:k:\mBbbN{}||Ps||  {}\mrightarrow{}  bag(eclass-program-type(Ps[k]))  {}\mrightarrow{}  bag(B)  {}\mrightarrow{}  bag(B)]
        defined-class(rec-comb-program(F;B;Ps))  =  F|\mlambda{}k.defined-class(Ps[k]),(self)'| 
        supposing  \mforall{}buf:bag(B).  ((F  (\mlambda{}k.\{\})  buf)  =  \{\}) 
    supposing  0  <  ||Ps||
Date html generated:
2012_01_23-PM-12_33_44
Last ObjectModification:
2012_01_06-AM-11_11_15
Home
Index