Nuprl Lemma : RankEx2_ind_wf
∀[S,T,A:Type]. ∀[R:A ⟶ RankEx2(S;T) ⟶ ℙ]. ∀[v:RankEx2(S;T)]. ∀[LeafT:leaft:T ⟶ {x:A| R[x;RankEx2_LeafT(leaft)]} ].
∀[LeafS:leafs:S ⟶ {x:A| R[x;RankEx2_LeafS(leafs)]} ]. ∀[Prod:prod:(RankEx2(S;T) × S × T)
⟶ let u,u1 = prod
in let u1,u2 = u
in {x:A| R[x;u1]}
⟶ {x:A| R[x;RankEx2_Prod(prod)]} ].
∀[Union:union:(S × RankEx2(S;T) + RankEx2(S;T))
⟶ case union of inl(u) => let u1,u2 = u in {x:A| R[x;u2]} | inr(u1) => {x:A| R[x;u1]}
⟶ {x:A| R[x;RankEx2_Union(union)]} ]. ∀[ListProd:listprod:((S × RankEx2(S;T)) List)
⟶ (∀u∈listprod.let u1,u2 = u
in {x:A| R[x;u2]} )
⟶ {x:A| R[x;RankEx2_ListProd(listprod)]} ].
∀[UnionList:unionlist:(T + (RankEx2(S;T) List))
⟶ case unionlist of inl(u) => True | inr(u1) => (∀u∈u1.{x:A| R[x;u]} )
⟶ {x:A| R[x;RankEx2_UnionList(unionlist)]} ].
(RankEx2_ind(v;
RankEx2_LeafT(leaft)⇒ LeafT[leaft];
RankEx2_LeafS(leafs)⇒ LeafS[leafs];
RankEx2_Prod(prod)⇒ rec1.Prod[prod;rec1];
RankEx2_Union(union)⇒ rec2.Union[union;rec2];
RankEx2_ListProd(listprod)⇒ rec3.ListProd[listprod;rec3];
RankEx2_UnionList(unionlist)⇒ rec4.UnionList[unionlist;rec4]) ∈ {x:A| R[x;v]} )
Proof
Definitions occuring in Statement :
RankEx2_ind: RankEx2_ind,
RankEx2_UnionList: RankEx2_UnionList(unionlist),
RankEx2_ListProd: RankEx2_ListProd(listprod),
RankEx2_Union: RankEx2_Union(union),
RankEx2_Prod: RankEx2_Prod(prod),
RankEx2_LeafS: RankEx2_LeafS(leafs),
RankEx2_LeafT: RankEx2_LeafT(leaft),
RankEx2: RankEx2(S;T),
l_all: (∀x∈L.P[x]),
list: T List,
uall: ∀[x:A]. B[x],
prop: ℙ,
so_apply: x[s1;s2],
so_apply: x[s],
true: True,
member: t ∈ T,
set: {x:A| B[x]} ,
function: x:A ⟶ B[x],
spread: spread def,
product: x:A × B[x],
decide: case b of inl(x) => s[x] | inr(y) => t[y],
union: left + right,
universe: Type
Definitions unfolded in proof :
uall: ∀[x:A]. B[x],
member: t ∈ T,
RankEx2_ind: RankEx2_ind,
so_apply: x[s1;s2],
so_apply: x[s],
RankEx2-definition,
RankEx2-induction,
uniform-comp-nat-induction,
RankEx2-ext,
eq_atom: x =a y,
bool_cases_sqequal,
eqff_to_assert,
any: any x,
btrue: tt,
bfalse: ff,
it: ⋅,
top: Top,
all: ∀x:A. B[x],
implies: P ⇒ Q,
has-value: (a)↓,
so_lambda: so_lambda(x,y,z,w.t[x; y; z; w]),
so_apply: x[s1;s2;s3;s4],
so_lambda: λ2x.t[x],
uimplies: b supposing a,
strict4: strict4(F),
and: P ∧ Q,
prop: ℙ,
guard: {T},
or: P ∨ Q,
squash: ↓T,
so_lambda: λ2x y.t[x; y],
subtype_rel: A ⊆r B
Lemmas referenced :
RankEx2-definition,
RankEx2-induction,
uniform-comp-nat-induction,
RankEx2-ext,
bool_cases_sqequal,
eqff_to_assert,
guard_wf,
subtype_rel-equal,
all_wf,
RankEx2_UnionList_wf,
true_wf,
RankEx2_ListProd_wf,
set_wf,
l_member_wf,
l_all_wf2,
list_wf,
RankEx2_Union_wf,
RankEx2_Prod_wf,
RankEx2_LeafS_wf,
RankEx2_LeafT_wf,
RankEx2_wf,
lifting-strict-spread,
base_wf,
lifting-strict-atom_eq,
is-exception_wf,
has-value_wf_base,
top_wf
Rules used in proof :
sqequalSubstitution,
sqequalTransitivity,
computationStep,
sqequalReflexivity,
isect_memberFormation,
introduction,
cut,
sqequalRule,
isect_memberEquality,
voidElimination,
voidEquality,
thin,
lemma_by_obid,
hypothesis,
lambdaFormation,
because_Cache,
sqequalSqle,
divergentSqle,
callbyvalueDecide,
sqequalHypSubstitution,
unionEquality,
unionElimination,
sqleReflexivity,
equalityEquality,
equalityTransitivity,
equalitySymmetry,
hypothesisEquality,
dependent_functionElimination,
independent_functionElimination,
decideExceptionCases,
axiomSqleEquality,
exceptionSqequal,
baseApply,
closedConclusion,
baseClosed,
isectElimination,
independent_isectElimination,
independent_pairFormation,
inrFormation,
imageMemberEquality,
imageElimination,
inlFormation,
callbyvalueApply,
applyExceptionCases,
instantiate,
extract_by_obid,
applyEquality,
lambdaEquality,
isectEquality,
universeEquality,
functionEquality,
cumulativity,
setEquality,
productEquality,
productElimination,
independent_pairEquality,
setElimination,
rename,
axiomEquality,
spreadEquality,
decideEquality
Latex:
\mforall{}[S,T,A:Type]. \mforall{}[R:A {}\mrightarrow{} RankEx2(S;T) {}\mrightarrow{} \mBbbP{}]. \mforall{}[v:RankEx2(S;T)].
\mforall{}[LeafT:leaft:T {}\mrightarrow{} \{x:A| R[x;RankEx2\_LeafT(leaft)]\} ].
\mforall{}[LeafS:leafs:S {}\mrightarrow{} \{x:A| R[x;RankEx2\_LeafS(leafs)]\} ]. \mforall{}[Prod:prod:(RankEx2(S;T) \mtimes{} S \mtimes{} T)
{}\mrightarrow{} let u,u1 = prod
in let u1,u2 = u
in \{x:A| R[x;u1]\}
{}\mrightarrow{} \{x:A| R[x;RankEx2\_Prod(prod)]\} ].
\mforall{}[Union:union:(S \mtimes{} RankEx2(S;T) + RankEx2(S;T))
{}\mrightarrow{} case union of inl(u) => let u1,u2 = u in \{x:A| R[x;u2]\} | inr(u1) => \{x:A| R[x;u1]\}
{}\mrightarrow{} \{x:A| R[x;RankEx2\_Union(union)]\} ]. \mforall{}[ListProd:listprod:((S \mtimes{} RankEx2(S;T)) List)
{}\mrightarrow{} (\mforall{}u\mmember{}listprod.let u1,u2 = u
in \{x:A| R[x;u2]\} )
{}\mrightarrow{} \{x:A| R[x;RankEx2\_ListProd(listprod)]\} ]\000C.
\mforall{}[UnionList:unionlist:(T + (RankEx2(S;T) List))
{}\mrightarrow{} case unionlist of inl(u) => True | inr(u1) => (\mforall{}u\mmember{}u1.\{x:A| R[x;u]\} )
{}\mrightarrow{} \{x:A| R[x;RankEx2\_UnionList(unionlist)]\} ].
(RankEx2\_ind(v;
RankEx2\_LeafT(leaft){}\mRightarrow{} LeafT[leaft];
RankEx2\_LeafS(leafs){}\mRightarrow{} LeafS[leafs];
RankEx2\_Prod(prod){}\mRightarrow{} rec1.Prod[prod;rec1];
RankEx2\_Union(union){}\mRightarrow{} rec2.Union[union;rec2];
RankEx2\_ListProd(listprod){}\mRightarrow{} rec3.ListProd[listprod;rec3];
RankEx2\_UnionList(unionlist){}\mRightarrow{} rec4.UnionList[unionlist;rec4]) \mmember{} \{x:A| R[x;v]\} )
Date html generated:
2016_05_16-AM-09_02_43
Last ObjectModification:
2016_01_17-AM-09_45_12
Theory : C-semantics
Home
Index