Nuprl Lemma : vr_base4

Nuprl Lemma : vr_base4

n:

.

L:

4 List. (n =

(4^i * L[i] | i < ||L||))

Proof not projected

Definitions occuring in Statement : select: l[i], length: ||as||, int_seg: {i..j

}, nat:

, all:

x:A. B[x], exists:

x:A. B[x], list: type List, multiply: n * m, natural_number: $n, int:

, equal: s = t, sum:

(f[x] | x < k), exp: i^n
Definitions : all:

x:A. B[x], function: x:A

B[x], exists:

x:A. B[x], product: x:A

B[x], nat:

, member: t

T, equal: s = t, void: Void, less_than: a < b, subtract: n - m, add: n + m, minus: -n, natural_number: $n, not:

A, false: False, int:

, list: type List, int_seg: {i..j

}, prop:

, implies: P

Q, uall:

[x:A]. B[x], isect:

x:A. B[x], ge: i

j , le: A

B, set: {x:A| B[x]} , nil: [], limited-type: LimitedType, universe: Type, sum:

(f[x] | x < k), so_lambda:

x.t[x], lambda:

x.A[x], length: ||as||, top: Top, subtype: S

T, rationals:

, real:

, multiply: n * m, exp: i^n, nat_plus:

, int_nzero:

, lelt: i

j < k, and: P

Q, select: l[i], uimplies: b supposing a, subtype_rel: A

r B, sq_type: SQType(T), guard: {T}, cons: [car / cdr], uiff: uiff(P;Q), strong-subtype: strong-subtype(A;B), p-outcome: Outcome, hd: hd(l), tl: tl(l), fpf: a:A fp-> B[a], pair: <a, b>, eclass: EClass(A[eo; e]), exp0: exp0{exp0_compseq_tag_def:o}(i), iff: P

Q, rev_implies: P

Q, lg-edge: lg-edge(g;a;b), decidable: Dec(P), apply: f a, infix_ap: x f y, ses-action: Action(e), ses-legal-sequence: Legal(pas) given prvt, path-goes-thru: x-f*-y thru i, cut-order: a

(X;f) b, collect-event: collect-event(es;X;n;v.num[v];L.P[L];e), same-thread: same-thread(es;p;e;e'), es-r-immediate-pred: es-r-immediate-pred(es;R;e';e), es-fset-loc: i

locs(s), existse-between3:

e

(e1,e2].P[e], existse-between2:

e

[e1,e2].P[e], alle-between2:

e

[e1,e2].P[e], existse-between1:

e

[e1,e2).P[e], alle-between1:

e

[e1,e2).P[e], alle-le:

e

e'.P[e], alle-lt:

e<e'.P[e], existse-le:

e

e'.P[e], existse-before:

e<e'.P[e], es-causle: e c

e', es-le: e

loc e' , es-locl: (e <loc e'), es-causl: (e < e'), cs-precondition: state s may consider v in inning i, cs-archive-blocked: in state s, ws' blocks ws from archiving v in inning i, cs-inning-committable: in state s, inning i could commit v , cs-inning-committed: in state s, inning i has committed v, cs-passed: by state s, a passed inning i without archiving a value, cs-archived: by state s, a archived v in inning i, cs-not-completed: in state s, a has not completed inning i, l_disjoint: l_disjoint(T;l1;l2), fset-closed: (s closed under fs), f-subset: xs

ys, fset-member: a

s, i-closed: i-closed(I), i-finite: i-finite(I), sq_exists:

x:{A| B[x]}, q-rel: q-rel(r;x), qless: r < s, qle: r

s, fun-connected: y is f*(x), l_all: (

x

L.P[x]), l_exists: (

x

L. P[x]), squash:

T, prime: prime(a), reducible: reducible(a), inject: Inj(A;B;f), cmp-le: cmp-le(cmp;x;y), l_contains: A

B, l_member: (x

l), cand: A c

B, grp_lt: a < b, set_lt: a <p b, set_leq: a

b, assoced: a ~ b, divides: b | a, assert:

b, or: P

Q, union: left + right
Lemmas : decidable__lt, add_functionality_wrt_eq, exp1, exp_add, sum_scalar_mult, iff_wf, rev_implies_wf, sum_functionality, select_cons_tl, sum_split, length_cons, non_neg_length, int_seg_properties, false_wf, not_wf, int_subtype_base, set_subtype_base, subtype_base_sq, length_wf, member_wf, select_wf, le_wf, exp_wf2, top_wf, length_wf_nat, sum_wf, nat_ind_tp, nat_properties, ge_wf, int_seg_wf, nat_wf

\mforall{}n:\mBbbN{}. \mexists{}L:\mBbbN{}4 List. (n = \mSigma{}(4\^{}i * L[i] | i < ||L||)) Date html generated: 2012_02_20-PM-03_31_08 Last ObjectModification: 2012_02_02-PM-01_54_45 Home Index