:: CLASSES1 semantic presentation

definition
let c1 be set ;
attr a1 is subset-closed means :Def1: :: CLASSES1:def 1
for b1, b2 being set st b1 in a1 & b2 c= b1 holds
b2 in a1;
end;

:: deftheorem Def1 defines subset-closed CLASSES1:def 1 :
for b1 being set holds
( b1 is subset-closed iff for b2, b3 being set st b2 in b1 & b3 c= b2 holds
b3 in b1 );

definition
let c1 be set ;
attr a1 is being_Tarski-Class means :Def2: :: CLASSES1:def 2
( a1 is subset-closed & ( for b1 being set st b1 in a1 holds
bool b1 in a1 ) & ( for b1 being set holds
( not b1 c= a1 or b1,a1 are_equipotent or b1 in a1 ) ) );
end;

:: deftheorem Def2 defines being_Tarski-Class CLASSES1:def 2 :
for b1 being set holds
( b1 is being_Tarski-Class iff ( b1 is subset-closed & ( for b2 being set st b2 in b1 holds
bool b2 in b1 ) & ( for b2 being set holds
( not b2 c= b1 or b2,b1 are_equipotent or b2 in b1 ) ) ) );

notation
let c1 be set ;
synonym c1 is_Tarski-Class for being_Tarski-Class c1;
end;

definition
let c1, c2 be set ;
pred c2 is_Tarski-Class_of c1 means :Def3: :: CLASSES1:def 3
( a1 in a2 & a2 is_Tarski-Class );
end;

:: deftheorem Def3 defines is_Tarski-Class_of CLASSES1:def 3 :
for b1, b2 being set holds
( b2 is_Tarski-Class_of b1 iff ( b1 in b2 & b2 is_Tarski-Class ) );

definition
let c1 be set ;
func Tarski-Class c1 -> set means :Def4: :: CLASSES1:def 4
( a2 is_Tarski-Class_of a1 & ( for b1 being set st b1 is_Tarski-Class_of a1 holds
a2 c= b1 ) );
existence
ex b1 being set st
( b1 is_Tarski-Class_of c1 & ( for b2 being set st b2 is_Tarski-Class_of c1 holds
b1 c= b2 ) )
proof end;
uniqueness
for b1, b2 being set st b1 is_Tarski-Class_of c1 & ( for b3 being set st b3 is_Tarski-Class_of c1 holds
b1 c= b3 ) & b2 is_Tarski-Class_of c1 & ( for b3 being set st b3 is_Tarski-Class_of c1 holds
b2 c= b3 ) holds
b1 = b2
proof end;
end;

:: deftheorem Def4 defines Tarski-Class CLASSES1:def 4 :
for b1, b2 being set holds
( b2 = Tarski-Class b1 iff ( b2 is_Tarski-Class_of b1 & ( for b3 being set st b3 is_Tarski-Class_of b1 holds
b2 c= b3 ) ) );

registration
let c1 be set ;
cluster Tarski-Class a1 -> non empty ;
coherence
not Tarski-Class c1 is empty
proof end;
end;

theorem Th1: :: CLASSES1:1
canceled;

theorem Th2: :: CLASSES1:2
for b1 being set holds
( b1 is_Tarski-Class iff ( b1 is subset-closed & ( for b2 being set st b2 in b1 holds
bool b2 in b1 ) & ( for b2 being set st b2 c= b1 & Card b2 <` Card b1 holds
b2 in b1 ) ) )
proof end;

theorem Th3: :: CLASSES1:3
canceled;

theorem Th4: :: CLASSES1:4
canceled;

theorem Th5: :: CLASSES1:5
for b1 being set holds b1 in Tarski-Class b1
proof end;

theorem Th6: :: CLASSES1:6
for b1, b2, b3 being set st b1 in Tarski-Class b2 & b3 c= b1 holds
b3 in Tarski-Class b2
proof end;

theorem Th7: :: CLASSES1:7
for b1, b2 being set st b1 in Tarski-Class b2 holds
bool b1 in Tarski-Class b2
proof end;

theorem Th8: :: CLASSES1:8
for b1, b2 being set holds
( not b1 c= Tarski-Class b2 or b1, Tarski-Class b2 are_equipotent or b1 in Tarski-Class b2 )
proof end;

theorem Th9: :: CLASSES1:9
for b1, b2 being set st b1 c= Tarski-Class b2 & Card b1 <` Card (Tarski-Class b2) holds
b1 in Tarski-Class b2
proof end;

definition
let c1 be set ;
let c2 be Ordinal;
func Tarski-Class c1,c2 -> set means :Def5: :: CLASSES1:def 5
ex b1 being T-Sequence st
( a3 = last b1 & dom b1 = succ a2 & b1 . {} = {a1} & ( for b2 being Ordinal st succ b2 in succ a2 holds
b1 . (succ b2) = ({ b3 where B is Element of Tarski-Class a1 : ex b1 being Element of Tarski-Class a1 st
( b4 in b1 . b2 & b3 c= b4 )
}
\/ { (bool b3) where B is Element of Tarski-Class a1 : b3 in b1 . b2 }
)
\/ ((bool (b1 . b2)) /\ (Tarski-Class a1)) ) & ( for b2 being Ordinal st b2 in succ a2 & b2 <> {} & b2 is_limit_ordinal holds
b1 . b2 = (union (rng (b1 | b2))) /\ (Tarski-Class a1) ) );
correctness
existence
ex b1 being set ex b2 being T-Sequence st
( b1 = last b2 & dom b2 = succ c2 & b2 . {} = {c1} & ( for b3 being Ordinal st succ b3 in succ c2 holds
b2 . (succ b3) = ({ b4 where B is Element of Tarski-Class c1 : ex b1 being Element of Tarski-Class c1 st
( b5 in b2 . b3 & b4 c= b5 )
}
\/ { (bool b4) where B is Element of Tarski-Class c1 : b4 in b2 . b3 }
)
\/ ((bool (b2 . b3)) /\ (Tarski-Class c1)) ) & ( for b3 being Ordinal st b3 in succ c2 & b3 <> {} & b3 is_limit_ordinal holds
b2 . b3 = (union (rng (b2 | b3))) /\ (Tarski-Class c1) ) )
;
uniqueness
for b1, b2 being set st ex b3 being T-Sequence st
( b1 = last b3 & dom b3 = succ c2 & b3 . {} = {c1} & ( for b4 being Ordinal st succ b4 in succ c2 holds
b3 . (succ b4) = ({ b5 where B is Element of Tarski-Class c1 : ex b1 being Element of Tarski-Class c1 st
( b6 in b3 . b4 & b5 c= b6 )
}
\/ { (bool b5) where B is Element of Tarski-Class c1 : b5 in b3 . b4 }
)
\/ ((bool (b3 . b4)) /\ (Tarski-Class c1)) ) & ( for b4 being Ordinal st b4 in succ c2 & b4 <> {} & b4 is_limit_ordinal holds
b3 . b4 = (union (rng (b3 | b4))) /\ (Tarski-Class c1) ) ) & ex b3 being T-Sequence st
( b2 = last b3 & dom b3 = succ c2 & b3 . {} = {c1} & ( for b4 being Ordinal st succ b4 in succ c2 holds
b3 . (succ b4) = ({ b5 where B is Element of Tarski-Class c1 : ex b1 being Element of Tarski-Class c1 st
( b6 in b3 . b4 & b5 c= b6 )
}
\/ { (bool b5) where B is Element of Tarski-Class c1 : b5 in b3 . b4 }
)
\/ ((bool (b3 . b4)) /\ (Tarski-Class c1)) ) & ( for b4 being Ordinal st b4 in succ c2 & b4 <> {} & b4 is_limit_ordinal holds
b3 . b4 = (union (rng (b3 | b4))) /\ (Tarski-Class c1) ) ) holds
b1 = b2
;
proof end;
end;

:: deftheorem Def5 defines Tarski-Class CLASSES1:def 5 :
for b1 being set
for b2 being Ordinal
for b3 being set holds
( b3 = Tarski-Class b1,b2 iff ex b4 being T-Sequence st
( b3 = last b4 & dom b4 = succ b2 & b4 . {} = {b1} & ( for b5 being Ordinal st succ b5 in succ b2 holds
b4 . (succ b5) = ({ b6 where B is Element of Tarski-Class b1 : ex b1 being Element of Tarski-Class b1 st
( b7 in b4 . b5 & b6 c= b7 )
}
\/ { (bool b6) where B is Element of Tarski-Class b1 : b6 in b4 . b5 }
)
\/ ((bool (b4 . b5)) /\ (Tarski-Class b1)) ) & ( for b5 being Ordinal st b5 in succ b2 & b5 <> {} & b5 is_limit_ordinal holds
b4 . b5 = (union (rng (b4 | b5))) /\ (Tarski-Class b1) ) ) );

E10: now
let c1 be set ;
deffunc H1( Ordinal) -> set = Tarski-Class c1,a1;
deffunc H2( Ordinal, set ) -> set = ({ b1 where B is Element of Tarski-Class c1 : ex b1 being Element of Tarski-Class c1 st
( b2 in a2 & b1 c= b2 )
}
\/ { (bool b1) where B is Element of Tarski-Class c1 : b1 in a2 }
)
\/ ((bool a2) /\ (Tarski-Class c1));
deffunc H3( Ordinal, T-Sequence) -> set = (union (rng a2)) /\ (Tarski-Class c1);
E11: for b1 being Ordinal
for b2 being set holds
( b2 = H1(b1) iff ex b3 being T-Sequence st
( b2 = last b3 & dom b3 = succ b1 & b3 . {} = {c1} & ( for b4 being Ordinal st succ b4 in succ b1 holds
b3 . (succ b4) = H2(b4,b3 . b4) ) & ( for b4 being Ordinal st b4 in succ b1 & b4 <> {} & b4 is_limit_ordinal holds
b3 . b4 = H3(b4,b3 | b4) ) ) ) by Def5;
thus H1( {} ) = {c1} from ORDINAL2:sch 8(E11);
thus for b1 being Ordinal holds H1( succ b1) = H2(b1,H1(b1)) from ORDINAL2:sch 9(E11);
thus for b1 being Ordinal
for b2 being T-Sequence st b1 <> {} & b1 is_limit_ordinal & dom b2 = b1 & ( for b3 being Ordinal st b3 in b1 holds
b2 . b3 = Tarski-Class c1,b3 ) holds
Tarski-Class c1,b1 = (union (rng b2)) /\ (Tarski-Class c1)
proof
let c2 be Ordinal;
let c3 be T-Sequence;
assume that
E12: ( c2 <> {} & c2 is_limit_ordinal ) and
E13: dom c3 = c2 and
E14: for b1 being Ordinal st b1 in c2 holds
c3 . b1 = H1(b1) ;
thus H1(c2) = H3(c2,c3) from ORDINAL2:sch 10(E11, E12, E13, E14);
end;
end;

definition
let c1 be set ;
let c2 be Ordinal;
redefine func Tarski-Class as Tarski-Class c1,c2 -> Subset of (Tarski-Class a1);
coherence
Tarski-Class c1,c2 is Subset of (Tarski-Class c1)
proof end;
end;

theorem Th10: :: CLASSES1:10
for b1 being set holds Tarski-Class b1,{} = {b1} by Lemma10;

theorem Th11: :: CLASSES1:11
for b1 being set
for b2 being Ordinal holds Tarski-Class b1,(succ b2) = ({ b3 where B is Element of Tarski-Class b1 : ex b1 being Element of Tarski-Class b1 st
( b4 in Tarski-Class b1,b2 & b3 c= b4 )
}
\/ { (bool b3) where B is Element of Tarski-Class b1 : b3 in Tarski-Class b1,b2 }
)
\/ ((bool (Tarski-Class b1,b2)) /\ (Tarski-Class b1)) by Lemma10;

theorem Th12: :: CLASSES1:12
for b1 being set
for b2 being Ordinal st b2 <> {} & b2 is_limit_ordinal holds
Tarski-Class b1,b2 = { b3 where B is Element of Tarski-Class b1 : ex b1 being Ordinal st
( b4 in b2 & b3 in Tarski-Class b1,b4 )
}
proof end;

theorem Th13: :: CLASSES1:13
for b1, b2 being set
for b3 being Ordinal holds
( b1 in Tarski-Class b2,(succ b3) iff ( ( b1 c= Tarski-Class b2,b3 & b1 in Tarski-Class b2 ) or ex b4 being set st
( b4 in Tarski-Class b2,b3 & ( b1 c= b4 or b1 = bool b4 ) ) ) )
proof end;

theorem Th14: :: CLASSES1:14
for b1, b2, b3 being set
for b4 being Ordinal st b1 c= b2 & b2 in Tarski-Class b3,b4 holds
b1 in Tarski-Class b3,(succ b4) by Th13;

theorem Th15: :: CLASSES1:15
for b1, b2 being set
for b3 being Ordinal st b1 in Tarski-Class b2,b3 holds
bool b1 in Tarski-Class b2,(succ b3) by Th13;

theorem Th16: :: CLASSES1:16
for b1, b2 being set
for b3 being Ordinal st b3 <> {} & b3 is_limit_ordinal holds
( b2 in Tarski-Class b1,b3 iff ex b4 being Ordinal st
( b4 in b3 & b2 in Tarski-Class b1,b4 ) )
proof end;

theorem Th17: :: CLASSES1:17
for b1, b2, b3 being set
for b4 being Ordinal st b4 <> {} & b4 is_limit_ordinal & b1 in Tarski-Class b2,b4 & ( b3 c= b1 or b3 = bool b1 ) holds
b3 in Tarski-Class b2,b4
proof end;

theorem Th18: :: CLASSES1:18
for b1 being set
for b2 being Ordinal holds Tarski-Class b1,b2 c= Tarski-Class b1,(succ b2)
proof end;

theorem Th19: :: CLASSES1:19
for b1 being set
for b2, b3 being Ordinal st b2 c= b3 holds
Tarski-Class b1,b2 c= Tarski-Class b1,b3
proof end;

theorem Th20: :: CLASSES1:20
for b1 being set ex b2 being Ordinal st Tarski-Class b1,b2 = Tarski-Class b1,(succ b2)
proof end;

theorem Th21: :: CLASSES1:21
for b1 being set
for b2 being Ordinal st Tarski-Class b1,b2 = Tarski-Class b1,(succ b2) holds
Tarski-Class b1,b2 = Tarski-Class b1
proof end;

theorem Th22: :: CLASSES1:22
for b1 being set ex b2 being Ordinal st Tarski-Class b1,b2 = Tarski-Class b1
proof end;

theorem Th23: :: CLASSES1:23
for b1 being set ex b2 being Ordinal st
( Tarski-Class b1,b2 = Tarski-Class b1 & ( for b3 being Ordinal st b3 in b2 holds
Tarski-Class b1,b3 <> Tarski-Class b1 ) )
proof end;

theorem Th24: :: CLASSES1:24
for b1, b2 being set st b1 <> b2 & b1 in Tarski-Class b2 holds
ex b3 being Ordinal st
( not b1 in Tarski-Class b2,b3 & b1 in Tarski-Class b2,(succ b3) )
proof end;

theorem Th25: :: CLASSES1:25
for b1 being set st b1 is epsilon-transitive holds
for b2 being Ordinal st b2 <> {} holds
Tarski-Class b1,b2 is epsilon-transitive
proof end;

theorem Th26: :: CLASSES1:26
for b1 being set holds
( Tarski-Class b1,{} in Tarski-Class b1,one & Tarski-Class b1,{} <> Tarski-Class b1,one )
proof end;

theorem Th27: :: CLASSES1:27
for b1 being set st b1 is epsilon-transitive holds
Tarski-Class b1 is epsilon-transitive
proof end;

theorem Th28: :: CLASSES1:28
for b1, b2 being set st b1 in Tarski-Class b2 holds
Card b1 <` Card (Tarski-Class b2)
proof end;

theorem Th29: :: CLASSES1:29
for b1, b2 being set st b1 in Tarski-Class b2 holds
not b1, Tarski-Class b2 are_equipotent
proof end;

theorem Th30: :: CLASSES1:30
for b1, b2, b3 being set st b2 in Tarski-Class b1 & b3 in Tarski-Class b1 holds
( {b2} in Tarski-Class b1 & {b2,b3} in Tarski-Class b1 )
proof end;

theorem Th31: :: CLASSES1:31
for b1, b2, b3 being set st b2 in Tarski-Class b1 & b3 in Tarski-Class b1 holds
[b2,b3] in Tarski-Class b1
proof end;

theorem Th32: :: CLASSES1:32
for b1, b2, b3 being set st b1 c= Tarski-Class b2 & b3 c= Tarski-Class b2 holds
[:b1,b3:] c= Tarski-Class b2
proof end;

definition
let c1 be Ordinal;
func Rank c1 -> set means :Def6: :: CLASSES1:def 6
ex b1 being T-Sequence st
( a2 = last b1 & dom b1 = succ a1 & b1 . {} = {} & ( for b2 being Ordinal st succ b2 in succ a1 holds
b1 . (succ b2) = bool (b1 . b2) ) & ( for b2 being Ordinal st b2 in succ a1 & b2 <> {} & b2 is_limit_ordinal holds
b1 . b2 = union (rng (b1 | b2)) ) );
correctness
existence
ex b1 being set ex b2 being T-Sequence st
( b1 = last b2 & dom b2 = succ c1 & b2 . {} = {} & ( for b3 being Ordinal st succ b3 in succ c1 holds
b2 . (succ b3) = bool (b2 . b3) ) & ( for b3 being Ordinal st b3 in succ c1 & b3 <> {} & b3 is_limit_ordinal holds
b2 . b3 = union (rng (b2 | b3)) ) )
;
uniqueness
for b1, b2 being set st ex b3 being T-Sequence st
( b1 = last b3 & dom b3 = succ c1 & b3 . {} = {} & ( for b4 being Ordinal st succ b4 in succ c1 holds
b3 . (succ b4) = bool (b3 . b4) ) & ( for b4 being Ordinal st b4 in succ c1 & b4 <> {} & b4 is_limit_ordinal holds
b3 . b4 = union (rng (b3 | b4)) ) ) & ex b3 being T-Sequence st
( b2 = last b3 & dom b3 = succ c1 & b3 . {} = {} & ( for b4 being Ordinal st succ b4 in succ c1 holds
b3 . (succ b4) = bool (b3 . b4) ) & ( for b4 being Ordinal st b4 in succ c1 & b4 <> {} & b4 is_limit_ordinal holds
b3 . b4 = union (rng (b3 | b4)) ) ) holds
b1 = b2
;
proof end;
end;

:: deftheorem Def6 defines Rank CLASSES1:def 6 :
for b1 being Ordinal
for b2 being set holds
( b2 = Rank b1 iff ex b3 being T-Sequence st
( b2 = last b3 & dom b3 = succ b1 & b3 . {} = {} & ( for b4 being Ordinal st succ b4 in succ b1 holds
b3 . (succ b4) = bool (b3 . b4) ) & ( for b4 being Ordinal st b4 in succ b1 & b4 <> {} & b4 is_limit_ordinal holds
b3 . b4 = union (rng (b3 | b4)) ) ) );

deffunc H1( Ordinal) -> set = Rank a1;

E26: now
deffunc H2( Ordinal, set ) -> set = bool a2;
deffunc H3( Ordinal, T-Sequence) -> set = union (rng a2);
E27: for b1 being Ordinal
for b2 being set holds
( b2 = H1(b1) iff ex b3 being T-Sequence st
( b2 = last b3 & dom b3 = succ b1 & b3 . {} = {} & ( for b4 being Ordinal st succ b4 in succ b1 holds
b3 . (succ b4) = H2(b4,b3 . b4) ) & ( for b4 being Ordinal st b4 in succ b1 & b4 <> {} & b4 is_limit_ordinal holds
b3 . b4 = H3(b4,b3 | b4) ) ) ) by Def6;
thus H1( {} ) = {} from ORDINAL2:sch 8(E27);
thus for b1 being Ordinal holds H1( succ b1) = H2(b1,H1(b1)) from ORDINAL2:sch 9(E27);
thus for b1 being Ordinal
for b2 being T-Sequence st b1 <> {} & b1 is_limit_ordinal & dom b2 = b1 & ( for b3 being Ordinal st b3 in b1 holds
b2 . b3 = Rank b3 ) holds
Rank b1 = union (rng b2)
proof
let c1 be Ordinal;
let c2 be T-Sequence;
assume that
E28: ( c1 <> {} & c1 is_limit_ordinal ) and
E29: dom c2 = c1 and
E30: for b1 being Ordinal st b1 in c1 holds
c2 . b1 = H1(b1) ;
thus H1(c1) = H3(c1,c2) from ORDINAL2:sch 10(E27, E28, E29, E30);
end;
end;

theorem Th33: :: CLASSES1:33
Rank {} = {} by Lemma26;

theorem Th34: :: CLASSES1:34
for b1 being Ordinal holds Rank (succ b1) = bool (Rank b1) by Lemma26;

theorem Th35: :: CLASSES1:35
for b1 being Ordinal st b1 <> {} & b1 is_limit_ordinal holds
for b2 being set holds
( b2 in Rank b1 iff ex b3 being Ordinal st
( b3 in b1 & b2 in Rank b3 ) )
proof end;

theorem Th36: :: CLASSES1:36
for b1 being set
for b2 being Ordinal holds
( b1 c= Rank b2 iff b1 in Rank (succ b2) )
proof end;

theorem Th37: :: CLASSES1:37
for b1 being Ordinal holds Rank b1 is epsilon-transitive
proof end;

theorem Th38: :: CLASSES1:38
for b1 being set
for b2 being Ordinal st b1 in Rank b2 holds
b1 c= Rank b2
proof end;

theorem Th39: :: CLASSES1:39
for b1 being Ordinal holds Rank b1 c= Rank (succ b1)
proof end;

theorem Th40: :: CLASSES1:40
for b1 being Ordinal holds union (Rank b1) c= Rank b1
proof end;

theorem Th41: :: CLASSES1:41
for b1 being set
for b2 being Ordinal st b1 in Rank b2 holds
union b1 in Rank b2
proof end;

theorem Th42: :: CLASSES1:42
for b1, b2 being Ordinal holds
( b1 in b2 iff Rank b1 in Rank b2 )
proof end;

theorem Th43: :: CLASSES1:43
for b1, b2 being Ordinal holds
( b1 c= b2 iff Rank b1 c= Rank b2 )
proof end;

theorem Th44: :: CLASSES1:44
for b1 being Ordinal holds b1 c= Rank b1
proof end;

theorem Th45: :: CLASSES1:45
for b1 being Ordinal
for b2 being set st b2 in Rank b1 holds
( not b2, Rank b1 are_equipotent & Card b2 <` Card (Rank b1) )
proof end;

theorem Th46: :: CLASSES1:46
for b1 being set
for b2 being Ordinal holds
( b1 c= Rank b2 iff bool b1 c= Rank (succ b2) )
proof end;

theorem Th47: :: CLASSES1:47
for b1, b2 being set
for b3 being Ordinal st b1 c= b2 & b2 in Rank b3 holds
b1 in Rank b3
proof end;

theorem Th48: :: CLASSES1:48
for b1 being set
for b2 being Ordinal holds
( b1 in Rank b2 iff bool b1 in Rank (succ b2) )
proof end;

theorem Th49: :: CLASSES1:49
for b1 being set
for b2 being Ordinal holds
( b1 in Rank b2 iff {b1} in Rank (succ b2) )
proof end;

theorem Th50: :: CLASSES1:50
for b1, b2 being set
for b3 being Ordinal holds
( ( b1 in Rank b3 & b2 in Rank b3 ) iff {b1,b2} in Rank (succ b3) )
proof end;

theorem Th51: :: CLASSES1:51
for b1, b2 being set
for b3 being Ordinal holds
( ( b1 in Rank b3 & b2 in Rank b3 ) iff [b1,b2] in Rank (succ (succ b3)) )
proof end;

theorem Th52: :: CLASSES1:52
for b1 being set
for b2 being Ordinal st b1 is epsilon-transitive & (Rank b2) /\ (Tarski-Class b1) = (Rank (succ b2)) /\ (Tarski-Class b1) holds
Tarski-Class b1 c= Rank b2
proof end;

theorem Th53: :: CLASSES1:53
for b1 being set st b1 is epsilon-transitive holds
ex b2 being Ordinal st Tarski-Class b1 c= Rank b2
proof end;

theorem Th54: :: CLASSES1:54
for b1 being set st b1 is epsilon-transitive holds
union b1 c= b1
proof end;

theorem Th55: :: CLASSES1:55
for b1, b2 being set st b1 is epsilon-transitive & b2 is epsilon-transitive holds
b1 \/ b2 is epsilon-transitive
proof end;

theorem Th56: :: CLASSES1:56
for b1, b2 being set st b1 is epsilon-transitive & b2 is epsilon-transitive holds
b1 /\ b2 is epsilon-transitive
proof end;

deffunc H2( set , set ) -> set = union a2;

definition
let c1 be set ;
func the_transitive-closure_of c1 -> set means :Def7: :: CLASSES1:def 7
for b1 being set holds
( b1 in a2 iff ex b2 being Functionex b3 being Nat st
( b1 in b2 . b3 & dom b2 = NAT & b2 . 0 = a1 & ( for b4 being Nat holds b2 . (b4 + 1) = union (b2 . b4) ) ) );
existence
ex b1 being set st
for b2 being set holds
( b2 in b1 iff ex b3 being Functionex b4 being Nat st
( b2 in b3 . b4 & dom b3 = NAT & b3 . 0 = c1 & ( for b5 being Nat holds b3 . (b5 + 1) = union (b3 . b5) ) ) )
proof end;
uniqueness
for b1, b2 being set st ( for b3 being set holds
( b3 in b1 iff ex b4 being Functionex b5 being Nat st
( b3 in b4 . b5 & dom b4 = NAT & b4 . 0 = c1 & ( for b6 being Nat holds b4 . (b6 + 1) = union (b4 . b6) ) ) ) ) & ( for b3 being set holds
( b3 in b2 iff ex b4 being Functionex b5 being Nat st
( b3 in b4 . b5 & dom b4 = NAT & b4 . 0 = c1 & ( for b6 being Nat holds b4 . (b6 + 1) = union (b4 . b6) ) ) ) ) holds
b1 = b2
proof end;
end;

:: deftheorem Def7 defines the_transitive-closure_of CLASSES1:def 7 :
for b1, b2 being set holds
( b2 = the_transitive-closure_of b1 iff for b3 being set holds
( b3 in b2 iff ex b4 being Functionex b5 being Nat st
( b3 in b4 . b5 & dom b4 = NAT & b4 . 0 = b1 & ( for b6 being Nat holds b4 . (b6 + 1) = union (b4 . b6) ) ) ) );

theorem Th57: :: CLASSES1:57
canceled;

theorem Th58: :: CLASSES1:58
for b1 being set holds the_transitive-closure_of b1 is epsilon-transitive
proof end;

theorem Th59: :: CLASSES1:59
for b1 being set holds b1 c= the_transitive-closure_of b1
proof end;

theorem Th60: :: CLASSES1:60
for b1, b2 being set st b1 c= b2 & b2 is epsilon-transitive holds
the_transitive-closure_of b1 c= b2
proof end;

theorem Th61: :: CLASSES1:61
for b1, b2 being set st ( for b3 being set st b1 c= b3 & b3 is epsilon-transitive holds
b2 c= b3 ) & b1 c= b2 & b2 is epsilon-transitive holds
the_transitive-closure_of b1 = b2
proof end;

theorem Th62: :: CLASSES1:62
for b1 being set st b1 is epsilon-transitive holds
the_transitive-closure_of b1 = b1
proof end;

theorem Th63: :: CLASSES1:63
the_transitive-closure_of {} = {} by Th62;

theorem Th64: :: CLASSES1:64
for b1 being Ordinal holds the_transitive-closure_of b1 = b1 by Th62;

theorem Th65: :: CLASSES1:65
for b1, b2 being set st b1 c= b2 holds
the_transitive-closure_of b1 c= the_transitive-closure_of b2
proof end;

theorem Th66: :: CLASSES1:66
for b1 being set holds the_transitive-closure_of (the_transitive-closure_of b1) = the_transitive-closure_of b1
proof end;

theorem Th67: :: CLASSES1:67
for b1, b2 being set holds the_transitive-closure_of (b1 \/ b2) = (the_transitive-closure_of b1) \/ (the_transitive-closure_of b2)
proof end;

theorem Th68: :: CLASSES1:68
for b1, b2 being set holds the_transitive-closure_of (b1 /\ b2) c= (the_transitive-closure_of b1) /\ (the_transitive-closure_of b2)
proof end;

theorem Th69: :: CLASSES1:69
for b1 being set ex b2 being Ordinal st b1 c= Rank b2
proof end;

definition
let c1 be set ;
func the_rank_of c1 -> Ordinal means :Def8: :: CLASSES1:def 8
( a1 c= Rank a2 & ( for b1 being Ordinal st a1 c= Rank b1 holds
a2 c= b1 ) );
existence
ex b1 being Ordinal st
( c1 c= Rank b1 & ( for b2 being Ordinal st c1 c= Rank b2 holds
b1 c= b2 ) )
proof end;
uniqueness
for b1, b2 being Ordinal st c1 c= Rank b1 & ( for b3 being Ordinal st c1 c= Rank b3 holds
b1 c= b3 ) & c1 c= Rank b2 & ( for b3 being Ordinal st c1 c= Rank b3 holds
b2 c= b3 ) holds
b1 = b2
proof end;
end;

:: deftheorem Def8 defines the_rank_of CLASSES1:def 8 :
for b1 being set
for b2 being Ordinal holds
( b2 = the_rank_of b1 iff ( b1 c= Rank b2 & ( for b3 being Ordinal st b1 c= Rank b3 holds
b2 c= b3 ) ) );

theorem Th70: :: CLASSES1:70
canceled;

theorem Th71: :: CLASSES1:71
for b1 being set holds the_rank_of (bool b1) = succ (the_rank_of b1)
proof end;

theorem Th72: :: CLASSES1:72
for b1 being Ordinal holds the_rank_of (Rank b1) = b1
proof end;

theorem Th73: :: CLASSES1:73
for b1 being set
for b2 being Ordinal holds
( b1 c= Rank b2 iff the_rank_of b1 c= b2 )
proof end;

theorem Th74: :: CLASSES1:74
for b1 being set
for b2 being Ordinal holds
( b1 in Rank b2 iff the_rank_of b1 in b2 )
proof end;

theorem Th75: :: CLASSES1:75
for b1, b2 being set st b1 c= b2 holds
the_rank_of b1 c= the_rank_of b2
proof end;

theorem Th76: :: CLASSES1:76
for b1, b2 being set st b1 in b2 holds
the_rank_of b1 in the_rank_of b2
proof end;

theorem Th77: :: CLASSES1:77
for b1 being set
for b2 being Ordinal holds
( the_rank_of b1 c= b2 iff for b3 being set st b3 in b1 holds
the_rank_of b3 in b2 )
proof end;

theorem Th78: :: CLASSES1:78
for b1 being set
for b2 being Ordinal holds
( b2 c= the_rank_of b1 iff for b3 being Ordinal st b3 in b2 holds
ex b4 being set st
( b4 in b1 & b3 c= the_rank_of b4 ) )
proof end;

theorem Th79: :: CLASSES1:79
for b1 being set holds
( the_rank_of b1 = {} iff b1 = {} )
proof end;

theorem Th80: :: CLASSES1:80
for b1 being set
for b2 being Ordinal st the_rank_of b1 = succ b2 holds
ex b3 being set st
( b3 in b1 & the_rank_of b3 = b2 )
proof end;

theorem Th81: :: CLASSES1:81
for b1 being Ordinal holds the_rank_of b1 = b1
proof end;

theorem Th82: :: CLASSES1:82
for b1 being set holds
( the_rank_of (Tarski-Class b1) <> {} & the_rank_of (Tarski-Class b1) is_limit_ordinal )
proof end;