:: Maximal Anti-Discrete Subspaces of Topological Spaces
:: by Zbigniew Karno
::
:: Received July 26, 1994
:: Copyright (c) 1994-2011 Association of Mizar Users


begin

registration
let X be non empty TopSpace;
let A be non empty Subset of X;
cluster Cl A -> non empty ;
coherence
not Cl A is empty
by PCOMPS_1:2;
end;

registration
let X be TopSpace;
let A be empty Subset of X;
cluster Cl A -> empty ;
coherence
Cl A is empty
by PRE_TOPC:52;
end;

registration
let X be non empty TopSpace;
let A be non proper Subset of X;
cluster Cl A -> non proper ;
coherence
not Cl A is proper
proof end;
end;

registration
let X be non empty non trivial TopSpace;
let A be non empty non trivial Subset of X;
cluster Cl A -> non trivial ;
coherence
not Cl A is trivial
by PRE_TOPC:48, TEX_2:1;
end;

theorem Th1: :: TEX_4:1
for X being non empty TopSpace
for A being Subset of X holds Cl A = meet { F where F is Subset of X : ( F is closed & A c= F ) }
proof end;

theorem Th2: :: TEX_4:2
for X being non empty TopSpace
for x being Point of X holds Cl {x} = meet { F where F is Subset of X : ( F is closed & x in F ) }
proof end;

registration
let X be non empty TopSpace;
let A be non proper Subset of X;
cluster Int A -> non proper ;
coherence
not Int A is proper
proof end;
end;

registration
let X be non empty TopSpace;
let A be proper Subset of X;
cluster Int A -> proper ;
coherence
Int A is proper
proof end;
end;

registration
let X be non empty TopSpace;
let A be empty Subset of X;
cluster Int A -> empty ;
coherence
Int A is empty
;
end;

theorem :: TEX_4:3
canceled;

theorem :: TEX_4:4
for X being non empty TopSpace
for A being Subset of X holds Int A = union { G where G is Subset of X : ( G is open & G c= A ) }
proof end;

begin

definition
let Y be TopStruct ;
let IT be Subset of Y;
attr IT is anti-discrete means :Def1: :: TEX_4:def 1
for x being Point of Y
for G being Subset of Y st G is open & x in G & x in IT holds
IT c= G;
end;

:: deftheorem Def1 defines anti-discrete TEX_4:def 1 :
for Y being TopStruct
for IT being Subset of Y holds
( IT is anti-discrete iff for x being Point of Y
for G being Subset of Y st G is open & x in G & x in IT holds
IT c= G );

definition
let Y be non empty TopStruct ;
let A be Subset of Y;
redefine attr A is anti-discrete means :Def2: :: TEX_4:def 2
for x being Point of Y
for F being Subset of Y st F is closed & x in F & x in A holds
A c= F;
compatibility
( A is anti-discrete iff for x being Point of Y
for F being Subset of Y st F is closed & x in F & x in A holds
A c= F )
proof end;
end;

:: deftheorem Def2 defines anti-discrete TEX_4:def 2 :
for Y being non empty TopStruct
for A being Subset of Y holds
( A is anti-discrete iff for x being Point of Y
for F being Subset of Y st F is closed & x in F & x in A holds
A c= F );

definition
let Y be TopStruct ;
let A be Subset of Y;
redefine attr A is anti-discrete means :Def3: :: TEX_4:def 3
for G being Subset of Y holds
( not G is open or A misses G or A c= G );
compatibility
( A is anti-discrete iff for G being Subset of Y holds
( not G is open or A misses G or A c= G ) )
proof end;
end;

:: deftheorem Def3 defines anti-discrete TEX_4:def 3 :
for Y being TopStruct
for A being Subset of Y holds
( A is anti-discrete iff for G being Subset of Y holds
( not G is open or A misses G or A c= G ) );

definition
let Y be TopStruct ;
let A be Subset of Y;
redefine attr A is anti-discrete means :Def4: :: TEX_4:def 4
for F being Subset of Y holds
( not F is closed or A misses F or A c= F );
compatibility
( A is anti-discrete iff for F being Subset of Y holds
( not F is closed or A misses F or A c= F ) )
proof end;
end;

:: deftheorem Def4 defines anti-discrete TEX_4:def 4 :
for Y being TopStruct
for A being Subset of Y holds
( A is anti-discrete iff for F being Subset of Y holds
( not F is closed or A misses F or A c= F ) );

theorem :: TEX_4:5
canceled;

theorem Th6: :: TEX_4:6
for Y0, Y1 being TopStruct
for D0 being Subset of Y0
for D1 being Subset of Y1 st TopStruct(# the carrier of Y0, the topology of Y0 #) = TopStruct(# the carrier of Y1, the topology of Y1 #) & D0 = D1 & D0 is anti-discrete holds
D1 is anti-discrete
proof end;

theorem Th7: :: TEX_4:7
for Y being non empty TopStruct
for A, B being Subset of Y st B c= A & A is anti-discrete holds
B is anti-discrete
proof end;

theorem Th8: :: TEX_4:8
for Y being non empty TopStruct
for x being Point of Y holds {x} is anti-discrete
proof end;

theorem Th9: :: TEX_4:9
for Y being non empty TopStruct
for A being empty Subset of Y holds A is anti-discrete
proof end;

definition
let Y be TopStruct ;
let IT be Subset-Family of Y;
attr IT is anti-discrete-set-family means :Def5: :: TEX_4:def 5
for A being Subset of Y st A in IT holds
A is anti-discrete ;
end;

:: deftheorem Def5 defines anti-discrete-set-family TEX_4:def 5 :
for Y being TopStruct
for IT being Subset-Family of Y holds
( IT is anti-discrete-set-family iff for A being Subset of Y st A in IT holds
A is anti-discrete );

theorem Th10: :: TEX_4:10
for Y being non empty TopStruct
for F being Subset-Family of Y st F is anti-discrete-set-family & meet F <> {} holds
union F is anti-discrete
proof end;

theorem :: TEX_4:11
for Y being non empty TopStruct
for F being Subset-Family of Y st F is anti-discrete-set-family holds
meet F is anti-discrete
proof end;

definition
let Y be TopStruct ;
let x be Point of Y;
func MaxADSF x -> Subset-Family of Y equals :: TEX_4:def 6
{ A where A is Subset of Y : ( A is anti-discrete & x in A ) } ;
coherence
{ A where A is Subset of Y : ( A is anti-discrete & x in A ) } is Subset-Family of Y
proof end;
end;

:: deftheorem defines MaxADSF TEX_4:def 6 :
for Y being TopStruct
for x being Point of Y holds MaxADSF x = { A where A is Subset of Y : ( A is anti-discrete & x in A ) } ;

registration
let Y be non empty TopStruct ;
let x be Point of Y;
cluster MaxADSF x -> non empty ;
coherence
not MaxADSF x is empty
proof end;
end;

theorem Th12: :: TEX_4:12
for Y being non empty TopStruct
for x being Point of Y holds MaxADSF x is anti-discrete-set-family
proof end;

theorem Th13: :: TEX_4:13
for Y being non empty TopStruct
for x being Point of Y holds {x} = meet (MaxADSF x)
proof end;

theorem Th14: :: TEX_4:14
for Y being non empty TopStruct
for x being Point of Y holds {x} c= union (MaxADSF x)
proof end;

theorem Th15: :: TEX_4:15
for Y being non empty TopStruct
for x being Point of Y holds union (MaxADSF x) is anti-discrete
proof end;

begin

definition
let Y be TopStruct ;
let IT be Subset of Y;
attr IT is maximal_anti-discrete means :Def7: :: TEX_4:def 7
( IT is anti-discrete & ( for D being Subset of Y st D is anti-discrete & IT c= D holds
IT = D ) );
end;

:: deftheorem Def7 defines maximal_anti-discrete TEX_4:def 7 :
for Y being TopStruct
for IT being Subset of Y holds
( IT is maximal_anti-discrete iff ( IT is anti-discrete & ( for D being Subset of Y st D is anti-discrete & IT c= D holds
IT = D ) ) );

theorem :: TEX_4:16
for Y0, Y1 being TopStruct
for D0 being Subset of Y0
for D1 being Subset of Y1 st TopStruct(# the carrier of Y0, the topology of Y0 #) = TopStruct(# the carrier of Y1, the topology of Y1 #) & D0 = D1 & D0 is maximal_anti-discrete holds
D1 is maximal_anti-discrete
proof end;

theorem Th17: :: TEX_4:17
for Y being non empty TopStruct
for A being empty Subset of Y holds not A is maximal_anti-discrete
proof end;

theorem Th18: :: TEX_4:18
for Y being non empty TopStruct
for A being non empty Subset of Y st A is anti-discrete & A is open holds
A is maximal_anti-discrete
proof end;

theorem Th19: :: TEX_4:19
for Y being non empty TopStruct
for A being non empty Subset of Y st A is anti-discrete & A is closed holds
A is maximal_anti-discrete
proof end;

definition
let Y be TopStruct ;
let x be Point of Y;
func MaxADSet x -> Subset of Y equals :: TEX_4:def 8
union (MaxADSF x);
coherence
union (MaxADSF x) is Subset of Y
;
end;

:: deftheorem defines MaxADSet TEX_4:def 8 :
for Y being TopStruct
for x being Point of Y holds MaxADSet x = union (MaxADSF x);

registration
let Y be non empty TopStruct ;
let x be Point of Y;
cluster MaxADSet x -> non empty ;
coherence
not MaxADSet x is empty
proof end;
end;

theorem :: TEX_4:20
for Y being non empty TopStruct
for x being Point of Y holds {x} c= MaxADSet x by Th14;

theorem Th21: :: TEX_4:21
for Y being non empty TopStruct
for D being Subset of Y
for x being Point of Y st D is anti-discrete & x in D holds
D c= MaxADSet x
proof end;

theorem Th22: :: TEX_4:22
for Y being non empty TopStruct
for x being Point of Y holds MaxADSet x is maximal_anti-discrete
proof end;

theorem Th23: :: TEX_4:23
for Y being non empty TopStruct
for x, y being Point of Y holds
( y in MaxADSet x iff MaxADSet y = MaxADSet x )
proof end;

theorem Th24: :: TEX_4:24
for Y being non empty TopStruct
for x, y being Point of Y holds
( MaxADSet x misses MaxADSet y or MaxADSet x = MaxADSet y )
proof end;

theorem Th25: :: TEX_4:25
for Y being non empty TopStruct
for F being Subset of Y
for x being Point of Y st F is closed & x in F holds
MaxADSet x c= F
proof end;

theorem Th26: :: TEX_4:26
for Y being non empty TopStruct
for G being Subset of Y
for x being Point of Y st G is open & x in G holds
MaxADSet x c= G
proof end;

theorem :: TEX_4:27
for Y being non empty TopStruct
for x being Point of Y holds MaxADSet x c= meet { F where F is Subset of Y : ( F is closed & x in F ) }
proof end;

theorem :: TEX_4:28
for Y being non empty TopStruct
for x being Point of Y holds MaxADSet x c= meet { G where G is Subset of Y : ( G is open & x in G ) }
proof end;

definition
let Y be non empty TopStruct ;
let A be Subset of Y;
redefine attr A is maximal_anti-discrete means :Def9: :: TEX_4:def 9
ex x being Point of Y st
( x in A & A = MaxADSet x );
compatibility
( A is maximal_anti-discrete iff ex x being Point of Y st
( x in A & A = MaxADSet x ) )
proof end;
end;

:: deftheorem Def9 defines maximal_anti-discrete TEX_4:def 9 :
for Y being non empty TopStruct
for A being Subset of Y holds
( A is maximal_anti-discrete iff ex x being Point of Y st
( x in A & A = MaxADSet x ) );

theorem Th29: :: TEX_4:29
for Y being non empty TopStruct
for A being Subset of Y
for x being Point of Y st x in A & A is maximal_anti-discrete holds
A = MaxADSet x
proof end;

definition
let Y be non empty TopStruct ;
let A be non empty Subset of Y;
redefine attr A is maximal_anti-discrete means :: TEX_4:def 10
for x being Point of Y st x in A holds
A = MaxADSet x;
compatibility
( A is maximal_anti-discrete iff for x being Point of Y st x in A holds
A = MaxADSet x )
proof end;
end;

:: deftheorem defines maximal_anti-discrete TEX_4:def 10 :
for Y being non empty TopStruct
for A being non empty Subset of Y holds
( A is maximal_anti-discrete iff for x being Point of Y st x in A holds
A = MaxADSet x );

definition
let Y be non empty TopStruct ;
let A be Subset of Y;
func MaxADSet A -> Subset of Y equals :: TEX_4:def 11
union { (MaxADSet a) where a is Point of Y : a in A } ;
coherence
union { (MaxADSet a) where a is Point of Y : a in A } is Subset of Y
proof end;
end;

:: deftheorem defines MaxADSet TEX_4:def 11 :
for Y being non empty TopStruct
for A being Subset of Y holds MaxADSet A = union { (MaxADSet a) where a is Point of Y : a in A } ;

theorem Th30: :: TEX_4:30
for Y being non empty TopStruct
for x being Point of Y holds MaxADSet x = MaxADSet {x}
proof end;

theorem Th31: :: TEX_4:31
for Y being non empty TopStruct
for A being Subset of Y
for x being Point of Y st MaxADSet x meets MaxADSet A holds
MaxADSet x meets A
proof end;

theorem Th32: :: TEX_4:32
for Y being non empty TopStruct
for A being Subset of Y
for x being Point of Y st MaxADSet x meets MaxADSet A holds
MaxADSet x c= MaxADSet A
proof end;

theorem Th33: :: TEX_4:33
for Y being non empty TopStruct
for A, B being Subset of Y st A c= B holds
MaxADSet A c= MaxADSet B
proof end;

theorem Th34: :: TEX_4:34
for Y being non empty TopStruct
for A being Subset of Y holds A c= MaxADSet A
proof end;

theorem Th35: :: TEX_4:35
for Y being non empty TopStruct
for A being Subset of Y holds MaxADSet A = MaxADSet (MaxADSet A)
proof end;

theorem Th36: :: TEX_4:36
for Y being non empty TopStruct
for A, B being Subset of Y st A c= MaxADSet B holds
MaxADSet A c= MaxADSet B
proof end;

theorem Th37: :: TEX_4:37
for Y being non empty TopStruct
for A, B being Subset of Y st B c= MaxADSet A & A c= MaxADSet B holds
MaxADSet A = MaxADSet B
proof end;

theorem :: TEX_4:38
for Y being non empty TopStruct
for A, B being Subset of Y holds MaxADSet (A \/ B) = (MaxADSet A) \/ (MaxADSet B)
proof end;

theorem Th39: :: TEX_4:39
for Y being non empty TopStruct
for A, B being Subset of Y holds MaxADSet (A /\ B) c= (MaxADSet A) /\ (MaxADSet B)
proof end;

registration
let Y be non empty TopStruct ;
let A be non empty Subset of Y;
cluster MaxADSet A -> non empty ;
coherence
not MaxADSet A is empty
by Th34, XBOOLE_1:3;
end;

registration
let Y be non empty TopStruct ;
let A be empty Subset of Y;
cluster MaxADSet A -> empty ;
coherence
MaxADSet A is empty
proof end;
end;

registration
let Y be non empty TopStruct ;
let A be non proper Subset of Y;
cluster MaxADSet A -> non proper ;
coherence
not MaxADSet A is proper
proof end;
end;

registration
let Y be non empty non trivial TopStruct ;
let A be non empty non trivial Subset of Y;
cluster MaxADSet A -> non trivial ;
coherence
not MaxADSet A is trivial
by Th34, TEX_2:1;
end;

theorem Th40: :: TEX_4:40
for Y being non empty TopStruct
for G, A being Subset of Y st G is open & A c= G holds
MaxADSet A c= G
proof end;

theorem Th41: :: TEX_4:41
for Y being non empty TopStruct
for A being Subset of Y st { G where G is Subset of Y : ( G is open & A c= G ) } <> {} holds
MaxADSet A c= meet { G where G is Subset of Y : ( G is open & A c= G ) }
proof end;

theorem Th42: :: TEX_4:42
for Y being non empty TopStruct
for F, A being Subset of Y st F is closed & A c= F holds
MaxADSet A c= F
proof end;

theorem Th43: :: TEX_4:43
for Y being non empty TopStruct
for A being Subset of Y st { F where F is Subset of Y : ( F is closed & A c= F ) } <> {} holds
MaxADSet A c= meet { F where F is Subset of Y : ( F is closed & A c= F ) }
proof end;

begin

definition
let X be non empty TopSpace;
let A be Subset of X;
redefine attr A is anti-discrete means :Def12: :: TEX_4:def 12
for x being Point of X st x in A holds
A c= Cl {x};
compatibility
( A is anti-discrete iff for x being Point of X st x in A holds
A c= Cl {x} )
proof end;
end;

:: deftheorem Def12 defines anti-discrete TEX_4:def 12 :
for X being non empty TopSpace
for A being Subset of X holds
( A is anti-discrete iff for x being Point of X st x in A holds
A c= Cl {x} );

definition
let X be non empty TopSpace;
let A be Subset of X;
redefine attr A is anti-discrete means :: TEX_4:def 13
for x being Point of X st x in A holds
Cl A = Cl {x};
compatibility
( A is anti-discrete iff for x being Point of X st x in A holds
Cl A = Cl {x} )
proof end;
end;

:: deftheorem defines anti-discrete TEX_4:def 13 :
for X being non empty TopSpace
for A being Subset of X holds
( A is anti-discrete iff for x being Point of X st x in A holds
Cl A = Cl {x} );

definition
let X be non empty TopSpace;
let A be Subset of X;
redefine attr A is anti-discrete means :Def14: :: TEX_4:def 14
for x, y being Point of X st x in A & y in A holds
Cl {x} = Cl {y};
compatibility
( A is anti-discrete iff for x, y being Point of X st x in A & y in A holds
Cl {x} = Cl {y} )
proof end;
end;

:: deftheorem Def14 defines anti-discrete TEX_4:def 14 :
for X being non empty TopSpace
for A being Subset of X holds
( A is anti-discrete iff for x, y being Point of X st x in A & y in A holds
Cl {x} = Cl {y} );

theorem :: TEX_4:44
for X being non empty TopSpace
for x being Point of X
for D being Subset of X st D is anti-discrete & Cl {x} c= D holds
D = Cl {x}
proof end;

theorem :: TEX_4:45
for X being non empty TopSpace
for A being Subset of X holds
( ( A is anti-discrete & A is closed ) iff for x being Point of X st x in A holds
A = Cl {x} )
proof end;

theorem :: TEX_4:46
for X being non empty TopSpace
for A being Subset of X st A is anti-discrete & not A is open holds
A is boundary
proof end;

theorem Th47: :: TEX_4:47
for X being non empty TopSpace
for x being Point of X st Cl {x} = {x} holds
{x} is maximal_anti-discrete
proof end;

theorem Th48: :: TEX_4:48
for X being non empty TopSpace
for x being Point of X holds MaxADSet x c= meet { G where G is Subset of X : ( G is open & x in G ) }
proof end;

theorem Th49: :: TEX_4:49
for X being non empty TopSpace
for x being Point of X holds MaxADSet x c= meet { F where F is Subset of X : ( F is closed & x in F ) }
proof end;

theorem Th50: :: TEX_4:50
for X being non empty TopSpace
for x being Point of X holds MaxADSet x c= Cl {x}
proof end;

Lm1: for X being non empty TopSpace
for x, y being Point of X st MaxADSet x = MaxADSet y holds
Cl {x} = Cl {y}
proof end;

theorem Th51: :: TEX_4:51
for X being non empty TopSpace
for x, y being Point of X holds
( MaxADSet x = MaxADSet y iff Cl {x} = Cl {y} )
proof end;

theorem :: TEX_4:52
for X being non empty TopSpace
for x, y being Point of X holds
( MaxADSet x misses MaxADSet y iff Cl {x} <> Cl {y} )
proof end;

definition
let X be non empty TopSpace;
let x be Point of X;
:: original: MaxADSet
redefine func MaxADSet x -> non empty Subset of X equals :: TEX_4:def 15
(Cl {x}) /\ (meet { G where G is Subset of X : ( G is open & x in G ) } );
compatibility
for b1 being non empty Subset of X holds
( b1 = MaxADSet x iff b1 = (Cl {x}) /\ (meet { G where G is Subset of X : ( G is open & x in G ) } ) )
proof end;
coherence
MaxADSet x is non empty Subset of X
;
end;

:: deftheorem defines MaxADSet TEX_4:def 15 :
for X being non empty TopSpace
for x being Point of X holds MaxADSet x = (Cl {x}) /\ (meet { G where G is Subset of X : ( G is open & x in G ) } );

theorem Th53: :: TEX_4:53
for X being non empty TopSpace
for x, y being Point of X holds
( Cl {x} c= Cl {y} iff meet { G where G is Subset of X : ( G is open & y in G ) } c= meet { G where G is Subset of X : ( G is open & x in G ) } )
proof end;

theorem :: TEX_4:54
for X being non empty TopSpace
for x, y being Point of X holds
( Cl {x} c= Cl {y} iff MaxADSet y c= meet { G where G is Subset of X : ( G is open & x in G ) } )
proof end;

theorem Th55: :: TEX_4:55
for X being non empty TopSpace
for x, y being Point of X holds
( MaxADSet x misses MaxADSet y iff ( ex V being Subset of X st
( V is open & MaxADSet x c= V & V misses MaxADSet y ) or ex W being Subset of X st
( W is open & W misses MaxADSet x & MaxADSet y c= W ) ) )
proof end;

theorem :: TEX_4:56
for X being non empty TopSpace
for x, y being Point of X holds
( MaxADSet x misses MaxADSet y iff ( ex E being Subset of X st
( E is closed & MaxADSet x c= E & E misses MaxADSet y ) or ex F being Subset of X st
( F is closed & F misses MaxADSet x & MaxADSet y c= F ) ) )
proof end;

theorem Th57: :: TEX_4:57
for X being non empty TopSpace
for A being Subset of X holds MaxADSet A c= meet { G where G is Subset of X : ( G is open & A c= G ) }
proof end;

theorem Th58: :: TEX_4:58
for X being non empty TopSpace
for P being Subset of X st P is open holds
MaxADSet P = P
proof end;

theorem :: TEX_4:59
for X being non empty TopSpace
for A being Subset of X holds MaxADSet (Int A) = Int A by Th58;

theorem Th60: :: TEX_4:60
for X being non empty TopSpace
for A being Subset of X holds MaxADSet A c= meet { F where F is Subset of X : ( F is closed & A c= F ) }
proof end;

theorem Th61: :: TEX_4:61
for X being non empty TopSpace
for A being Subset of X holds MaxADSet A c= Cl A
proof end;

theorem Th62: :: TEX_4:62
for X being non empty TopSpace
for P being Subset of X st P is closed holds
MaxADSet P = P
proof end;

theorem :: TEX_4:63
for X being non empty TopSpace
for A being Subset of X holds MaxADSet (Cl A) = Cl A by Th62;

theorem :: TEX_4:64
for X being non empty TopSpace
for A being Subset of X holds Cl (MaxADSet A) = Cl A
proof end;

theorem :: TEX_4:65
for X being non empty TopSpace
for A, B being Subset of X st MaxADSet A = MaxADSet B holds
Cl A = Cl B
proof end;

theorem :: TEX_4:66
for X being non empty TopSpace
for P, Q being Subset of X st ( P is closed or Q is closed ) holds
MaxADSet (P /\ Q) = (MaxADSet P) /\ (MaxADSet Q)
proof end;

theorem :: TEX_4:67
for X being non empty TopSpace
for P, Q being Subset of X st ( P is open or Q is open ) holds
MaxADSet (P /\ Q) = (MaxADSet P) /\ (MaxADSet Q)
proof end;

begin

theorem Th68: :: TEX_4:68
for Y being non empty TopStruct
for Y0 being SubSpace of Y
for A being Subset of Y st A = the carrier of Y0 & Y0 is anti-discrete holds
A is anti-discrete
proof end;

theorem Th69: :: TEX_4:69
for Y being non empty TopStruct
for Y0 being SubSpace of Y st Y0 is TopSpace-like holds
for A being Subset of Y st A = the carrier of Y0 & A is anti-discrete holds
Y0 is anti-discrete
proof end;

theorem :: TEX_4:70
for X being non empty TopSpace
for Y0 being non empty SubSpace of X st ( for X0 being open SubSpace of X holds
( Y0 misses X0 or Y0 is SubSpace of X0 ) ) holds
Y0 is anti-discrete
proof end;

theorem :: TEX_4:71
for X being non empty TopSpace
for Y0 being non empty SubSpace of X st ( for X0 being closed SubSpace of X holds
( Y0 misses X0 or Y0 is SubSpace of X0 ) ) holds
Y0 is anti-discrete
proof end;

theorem :: TEX_4:72
for X being non empty TopSpace
for Y0 being anti-discrete SubSpace of X
for X0 being open SubSpace of X holds
( Y0 misses X0 or Y0 is SubSpace of X0 )
proof end;

theorem :: TEX_4:73
for X being non empty TopSpace
for Y0 being anti-discrete SubSpace of X
for X0 being closed SubSpace of X holds
( Y0 misses X0 or Y0 is SubSpace of X0 )
proof end;

definition
let Y be non empty TopStruct ;
let IT be SubSpace of Y;
attr IT is maximal_anti-discrete means :Def16: :: TEX_4:def 16
( IT is anti-discrete & ( for Y0 being SubSpace of Y st Y0 is anti-discrete & the carrier of IT c= the carrier of Y0 holds
the carrier of IT = the carrier of Y0 ) );
end;

:: deftheorem Def16 defines maximal_anti-discrete TEX_4:def 16 :
for Y being non empty TopStruct
for IT being SubSpace of Y holds
( IT is maximal_anti-discrete iff ( IT is anti-discrete & ( for Y0 being SubSpace of Y st Y0 is anti-discrete & the carrier of IT c= the carrier of Y0 holds
the carrier of IT = the carrier of Y0 ) ) );

registration
let Y be non empty TopStruct ;
cluster maximal_anti-discrete -> anti-discrete SubSpace of Y;
coherence
for b1 being SubSpace of Y st b1 is maximal_anti-discrete holds
b1 is anti-discrete
by Def16;
cluster non anti-discrete -> non maximal_anti-discrete SubSpace of Y;
coherence
for b1 being SubSpace of Y st not b1 is anti-discrete holds
not b1 is maximal_anti-discrete
;
end;

theorem Th74: :: TEX_4:74
for X being non empty TopSpace
for Y0 being non empty SubSpace of X
for A being Subset of X st A = the carrier of Y0 holds
( Y0 is maximal_anti-discrete iff A is maximal_anti-discrete )
proof end;

registration
let X be non empty TopSpace;
cluster non empty open anti-discrete -> non empty maximal_anti-discrete SubSpace of X;
coherence
for b1 being non empty SubSpace of X st b1 is open & b1 is anti-discrete holds
b1 is maximal_anti-discrete
proof end;
cluster non empty open non maximal_anti-discrete -> non empty non anti-discrete SubSpace of X;
coherence
for b1 being non empty SubSpace of X st b1 is open & not b1 is maximal_anti-discrete holds
not b1 is anti-discrete
;
cluster non empty anti-discrete non maximal_anti-discrete -> non empty non open SubSpace of X;
coherence
for b1 being non empty SubSpace of X st b1 is anti-discrete & not b1 is maximal_anti-discrete holds
not b1 is open
;
cluster non empty closed anti-discrete -> non empty maximal_anti-discrete SubSpace of X;
coherence
for b1 being non empty SubSpace of X st b1 is closed & b1 is anti-discrete holds
b1 is maximal_anti-discrete
proof end;
cluster non empty closed non maximal_anti-discrete -> non empty non anti-discrete SubSpace of X;
coherence
for b1 being non empty SubSpace of X st b1 is closed & not b1 is maximal_anti-discrete holds
not b1 is anti-discrete
;
cluster non empty anti-discrete non maximal_anti-discrete -> non empty non closed SubSpace of X;
coherence
for b1 being non empty SubSpace of X st b1 is anti-discrete & not b1 is maximal_anti-discrete holds
not b1 is closed
;
end;

definition
let Y be TopStruct ;
let x be Point of Y;
func MaxADSspace x -> strict SubSpace of Y means :Def17: :: TEX_4:def 17
the carrier of it = MaxADSet x;
existence
ex b1 being strict SubSpace of Y st the carrier of b1 = MaxADSet x
proof end;
uniqueness
for b1, b2 being strict SubSpace of Y st the carrier of b1 = MaxADSet x & the carrier of b2 = MaxADSet x holds
b1 = b2
proof end;
end;

:: deftheorem Def17 defines MaxADSspace TEX_4:def 17 :
for Y being TopStruct
for x being Point of Y
for b3 being strict SubSpace of Y holds
( b3 = MaxADSspace x iff the carrier of b3 = MaxADSet x );

registration
let Y be non empty TopStruct ;
let x be Point of Y;
cluster MaxADSspace x -> non empty strict ;
coherence
not MaxADSspace x is empty
proof end;
end;

Lm2: for Y being non empty TopStruct
for X1, X2 being SubSpace of Y st the carrier of X1 c= the carrier of X2 holds
X1 is SubSpace of X2
proof end;

theorem :: TEX_4:75
for Y being non empty TopStruct
for x being Point of Y holds Sspace x is SubSpace of MaxADSspace x
proof end;

theorem :: TEX_4:76
for Y being non empty TopStruct
for x, y being Point of Y holds
( y is Point of (MaxADSspace x) iff TopStruct(# the carrier of (MaxADSspace y), the topology of (MaxADSspace y) #) = TopStruct(# the carrier of (MaxADSspace x), the topology of (MaxADSspace x) #) )
proof end;

theorem :: TEX_4:77
for Y being non empty TopStruct
for x, y being Point of Y holds
( the carrier of (MaxADSspace x) misses the carrier of (MaxADSspace y) or TopStruct(# the carrier of (MaxADSspace x), the topology of (MaxADSspace x) #) = TopStruct(# the carrier of (MaxADSspace y), the topology of (MaxADSspace y) #) )
proof end;

registration
let X be non empty TopSpace;
cluster strict TopSpace-like maximal_anti-discrete SubSpace of X;
existence
ex b1 being SubSpace of X st
( b1 is maximal_anti-discrete & b1 is strict )
proof end;
end;

registration
let X be non empty TopSpace;
let x be Point of X;
cluster MaxADSspace x -> strict maximal_anti-discrete ;
coherence
MaxADSspace x is maximal_anti-discrete
proof end;
end;

theorem :: TEX_4:78
for X being non empty TopSpace
for X0 being non empty closed SubSpace of X
for x being Point of X st x is Point of X0 holds
MaxADSspace x is SubSpace of X0
proof end;

theorem :: TEX_4:79
for X being non empty TopSpace
for X0 being non empty open SubSpace of X
for x being Point of X st x is Point of X0 holds
MaxADSspace x is SubSpace of X0
proof end;

theorem :: TEX_4:80
for X being non empty TopSpace
for x being Point of X st Cl {x} = {x} holds
Sspace x is maximal_anti-discrete
proof end;

notation
let Y be TopStruct ;
let A be Subset of Y;
synonym Sspace A for Y | A;
end;

Lm3: for Y being TopStruct
for A being Subset of Y holds the carrier of (Y | A) = A
proof end;

theorem :: TEX_4:81
for Y being non empty TopStruct
for A being non empty Subset of Y holds A is Subset of (Sspace A)
proof end;

theorem :: TEX_4:82
for Y being non empty TopStruct
for Y0 being SubSpace of Y
for A being non empty Subset of Y st A is Subset of Y0 holds
Sspace A is SubSpace of Y0
proof end;

registration
let Y be non empty non trivial TopStruct ;
cluster strict non proper SubSpace of Y;
existence
ex b1 being SubSpace of Y st
( not b1 is proper & b1 is strict )
proof end;
end;

registration
let Y be non empty non trivial TopStruct ;
let A be non empty non trivial Subset of Y;
cluster Sspace A -> non trivial ;
coherence
not Sspace A is trivial
by Lm3;
end;

registration
let Y be non empty TopStruct ;
let A be non proper Subset of Y;
cluster Sspace A -> non proper ;
coherence
not Sspace A is proper
proof end;
end;

definition
let Y be non empty TopStruct ;
let A be Subset of Y;
func MaxADSspace A -> strict SubSpace of Y means :Def18: :: TEX_4:def 18
the carrier of it = MaxADSet A;
existence
ex b1 being strict SubSpace of Y st the carrier of b1 = MaxADSet A
proof end;
uniqueness
for b1, b2 being strict SubSpace of Y st the carrier of b1 = MaxADSet A & the carrier of b2 = MaxADSet A holds
b1 = b2
proof end;
end;

:: deftheorem Def18 defines MaxADSspace TEX_4:def 18 :
for Y being non empty TopStruct
for A being Subset of Y
for b3 being strict SubSpace of Y holds
( b3 = MaxADSspace A iff the carrier of b3 = MaxADSet A );

registration
let Y be non empty TopStruct ;
let A be non empty Subset of Y;
cluster MaxADSspace A -> non empty strict ;
coherence
not MaxADSspace A is empty
proof end;
end;

theorem :: TEX_4:83
for Y being non empty TopStruct
for A being non empty Subset of Y holds A is Subset of (MaxADSspace A)
proof end;

theorem :: TEX_4:84
for Y being non empty TopStruct
for A being non empty Subset of Y holds Sspace A is SubSpace of MaxADSspace A
proof end;

theorem :: TEX_4:85
for Y being non empty TopStruct
for x being Point of Y holds TopStruct(# the carrier of (MaxADSspace x), the topology of (MaxADSspace x) #) = TopStruct(# the carrier of (MaxADSspace {x}), the topology of (MaxADSspace {x}) #)
proof end;

theorem :: TEX_4:86
for Y being non empty TopStruct
for A, B being non empty Subset of Y st A c= B holds
MaxADSspace A is SubSpace of MaxADSspace B
proof end;

theorem :: TEX_4:87
for Y being non empty TopStruct
for A being non empty Subset of Y holds TopStruct(# the carrier of (MaxADSspace A), the topology of (MaxADSspace A) #) = TopStruct(# the carrier of (MaxADSspace (MaxADSet A)), the topology of (MaxADSspace (MaxADSet A)) #)
proof end;

theorem :: TEX_4:88
for Y being non empty TopStruct
for A, B being non empty Subset of Y st A is Subset of (MaxADSspace B) holds
MaxADSspace A is SubSpace of MaxADSspace B
proof end;

theorem :: TEX_4:89
for Y being non empty TopStruct
for A, B being non empty Subset of Y holds
( ( B is Subset of (MaxADSspace A) & A is Subset of (MaxADSspace B) ) iff TopStruct(# the carrier of (MaxADSspace A), the topology of (MaxADSspace A) #) = TopStruct(# the carrier of (MaxADSspace B), the topology of (MaxADSspace B) #) )
proof end;

registration
let Y be non empty non trivial TopStruct ;
let A be non empty non trivial Subset of Y;
cluster MaxADSspace A -> non trivial strict ;
coherence
not MaxADSspace A is trivial
proof end;
end;

registration
let Y be non empty TopStruct ;
let A be non proper Subset of Y;
cluster MaxADSspace A -> strict non proper ;
coherence
not MaxADSspace A is proper
proof end;
end;

theorem :: TEX_4:90
for X being non empty TopSpace
for X0 being open SubSpace of X
for A being non empty Subset of X st A is Subset of X0 holds
MaxADSspace A is SubSpace of X0
proof end;

theorem :: TEX_4:91
for X being non empty TopSpace
for X0 being closed SubSpace of X
for A being non empty Subset of X st A is Subset of X0 holds
MaxADSspace A is SubSpace of X0
proof end;