{ 
[S:LimitedType]. 
[T:Type]. 
[x:Id]. 
[P:S 
 
]. 
[f:Id
                                                         
 T
                                                         
 {v:S| 
P[v]} ].
  
[g:T 
 (Id List)]. 
[hdr:Name].
    (prop-rule-realizer-out(S;x;f;g;hdr)
    
 T + Top 
 LabeledDAG(Id 
 pCom(P.Message))) }
{ Proof }
Definitions occuring in Statement : 
prop-rule-realizer-out: prop-rule-realizer-out(T;x;f;g;hdr), 
Message: Message, 
pCom: pCom(P.M[P]), 
ldag: LabeledDAG(T), 
Id: Id, 
name: Name, 
assert:
b, 
bool:
, 
uall:
[x:A]. B[x], 
top: Top, 
so_apply: x[s], 
member: t 
 T, 
set: {x:A| B[x]} , 
function: x:A 
 B[x], 
product: x:A 
 B[x], 
union: left + right, 
list: type List, 
universe: Type, 
limited-type: LimitedType
Definitions : 
lg-nil: lg-nil(), 
make-lg: make-lg(L), 
l_member: (x 
 l), 
atom: Atom, 
listp: A List
, 
combination: Combination(n;T), 
token: "$token", 
pair: <a, b>, 
map: map(f;as), 
lambda:
x.A[x], 
prop:
, 
apply: f a, 
so_apply: x[s], 
strong-subtype: strong-subtype(A;B), 
le: A 
 B, 
ge: i 
 j , 
not:
A, 
less_than: a < b, 
and: P 
 Q, 
uiff: uiff(P;Q), 
axiom: Ax, 
prop-rule-realizer-out: prop-rule-realizer-out(T;x;f;g;hdr), 
pCom: pCom(P.M[P]), 
ldag: LabeledDAG(T), 
top: Top, 
union: left + right, 
name: Name, 
list: type List, 
assert:
b, 
fpf: a:A fp-> B[a], 
subtype: S 
 T, 
es-E-interface: E(X), 
uimplies: b supposing a, 
subtype_rel: A 
r B, 
eclass: EClass(A[eo; e]), 
isect:
x:A. B[x], 
product: x:A 
 B[x], 
exists:
x:A. B[x], 
intensional-universe: IType, 
set: {x:A| B[x]} , 
atom: Atom$n, 
all:
x:A. B[x], 
uall:
[x:A]. B[x], 
function: x:A 
 B[x], 
bool:
, 
limited-type: LimitedType, 
Id: Id, 
equal: s = t, 
Auto: Error :Auto, 
CollapseTHEN: Error :CollapseTHEN, 
ORELSE: Error :ORELSE, 
D: Error :D, 
CollapseTHENA: Error :CollapseTHENA, 
Message: Message, 
so_lambda: 
x.t[x], 
parameter: parm{i}, 
MaAuto: Error :MaAuto, 
universe: Type, 
member: t 
 T, 
AssertBY: Error :AssertBY, 
tactic: Error :tactic, 
Com: Com(P.M[P]), 
mData: mData, 
pMsg: pMsg(P.M[P]), 
rev_implies: P 
 Q, 
or: P 
 Q, 
implies: P 
 Q, 
iff: P 

 Q, 
true: True, 
type-monotone: Monotone(T.F[T]), 
Process: Process(P.M[P]), 
mk-tagged: mk-tagged(tg;x)
Lemmas : 
pMsg_wf, 
Process_wf, 
subtype_rel_self, 
uall_wf, 
type-monotone_wf, 
mk-tagged_wf_pCom_msg, 
make-lg_wf_dag, 
subtype_rel_wf, 
name_wf, 
assert_wf, 
member_wf, 
Id_wf, 
map_wf, 
top_wf, 
Message_wf, 
pCom_wf, 
bool_wf, 
ldag_wf, 
intensional-universe_wf, 
limited-type_wf, 
lg-nil_wf_dag
\mforall{}[S:LimitedType].  \mforall{}[T:Type].  \mforall{}[x:Id].  \mforall{}[P:S  {}\mrightarrow{}  \mBbbB{}].  \mforall{}[f:Id  {}\mrightarrow{}  T  {}\mrightarrow{}  \{v:S|  \muparrow{}P[v]\}  ].
\mforall{}[g:T  {}\mrightarrow{}  (Id  List)].  \mforall{}[hdr:Name].
    (prop-rule-realizer-out(S;x;f;g;hdr)  \mmember{}  T  +  Top  {}\mrightarrow{}  LabeledDAG(Id  \mtimes{}  pCom(P.Message)))
Date html generated:
2011_08_17-PM-04_17_28
Last ObjectModification:
2011_06_18-AM-11_33_38
Home
Index