Article KURATO_1, MML version 4.99.1005

:: KURATO_1:funcnot 1 => PRE_TOPC:func 2
notation
  let a1 be non empty TopSpace-like TopStruct;
  let a2 be Element of bool the carrier of a1;
  synonym a2 - for Cl a2;
end;

:: KURATO_1:th 1
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of bool the carrier of b1 holds
   Cl ((Cl ((Cl ((Cl b2) `)) `)) `) = Cl ((Cl b2) `);

:: KURATO_1:funcnot 2 => KURATO_1:func 1
definition
  let a1 be non empty TopSpace-like TopStruct;
  let a2 be Element of bool the carrier of a1;
  func Kurat14Part A2 -> set equals
    {a2,Cl a2,(Cl a2) `,Cl ((Cl a2) `),(Cl ((Cl a2) `)) `,Cl ((Cl ((Cl a2) `)) `),(Cl ((Cl ((Cl a2) `)) `)) `};
end;

:: KURATO_1:def 1
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of bool the carrier of b1 holds
   Kurat14Part b2 = {b2,Cl b2,(Cl b2) `,Cl ((Cl b2) `),(Cl ((Cl b2) `)) `,Cl ((Cl ((Cl b2) `)) `),(Cl ((Cl ((Cl b2) `)) `)) `};

:: KURATO_1:funcreg 1
registration
  let a1 be non empty TopSpace-like TopStruct;
  let a2 be Element of bool the carrier of a1;
  cluster Kurat14Part a2 -> finite;
end;

:: KURATO_1:funcnot 3 => KURATO_1:func 2
definition
  let a1 be non empty TopSpace-like TopStruct;
  let a2 be Element of bool the carrier of a1;
  func Kurat14Set A2 -> Element of bool bool the carrier of a1 equals
    {a2,Cl a2,(Cl a2) `,Cl ((Cl a2) `),(Cl ((Cl a2) `)) `,Cl ((Cl ((Cl a2) `)) `),(Cl ((Cl ((Cl a2) `)) `)) `} \/ {a2 `,Cl (a2 `),(Cl (a2 `)) `,Cl ((Cl (a2 `)) `),(Cl ((Cl (a2 `)) `)) `,Cl ((Cl ((Cl (a2 `)) `)) `),(Cl ((Cl ((Cl (a2 `)) `)) `)) `};
end;

:: KURATO_1:def 2
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of bool the carrier of b1 holds
   Kurat14Set b2 = {b2,Cl b2,(Cl b2) `,Cl ((Cl b2) `),(Cl ((Cl b2) `)) `,Cl ((Cl ((Cl b2) `)) `),(Cl ((Cl ((Cl b2) `)) `)) `} \/ {b2 `,Cl (b2 `),(Cl (b2 `)) `,Cl ((Cl (b2 `)) `),(Cl ((Cl (b2 `)) `)) `,Cl ((Cl ((Cl (b2 `)) `)) `),(Cl ((Cl ((Cl (b2 `)) `)) `)) `};

:: KURATO_1:th 2
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of bool the carrier of b1 holds
   Kurat14Set b2 = (Kurat14Part b2) \/ Kurat14Part (b2 `);

:: KURATO_1:th 3
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of bool the carrier of b1 holds
   b2 in Kurat14Set b2 &
    Cl b2 in Kurat14Set b2 &
    (Cl b2) ` in Kurat14Set b2 &
    Cl ((Cl b2) `) in Kurat14Set b2 &
    (Cl ((Cl b2) `)) ` in Kurat14Set b2 &
    Cl ((Cl ((Cl b2) `)) `) in Kurat14Set b2 &
    (Cl ((Cl ((Cl b2) `)) `)) ` in Kurat14Set b2;

:: KURATO_1:th 4
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of bool the carrier of b1 holds
   b2 ` in Kurat14Set b2 &
    Cl (b2 `) in Kurat14Set b2 &
    (Cl (b2 `)) ` in Kurat14Set b2 &
    Cl ((Cl (b2 `)) `) in Kurat14Set b2 &
    (Cl ((Cl (b2 `)) `)) ` in Kurat14Set b2 &
    Cl ((Cl ((Cl (b2 `)) `)) `) in Kurat14Set b2 &
    (Cl ((Cl ((Cl (b2 `)) `)) `)) ` in Kurat14Set b2;

:: KURATO_1:funcnot 4 => KURATO_1:func 3
definition
  let a1 be non empty TopSpace-like TopStruct;
  let a2 be Element of bool the carrier of a1;
  func Kurat14ClPart A2 -> Element of bool bool the carrier of a1 equals
    {Cl a2,Cl ((Cl a2) `),Cl ((Cl ((Cl a2) `)) `),Cl (a2 `),Cl ((Cl (a2 `)) `),Cl ((Cl ((Cl (a2 `)) `)) `)};
end;

:: KURATO_1:def 3
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of bool the carrier of b1 holds
   Kurat14ClPart b2 = {Cl b2,Cl ((Cl b2) `),Cl ((Cl ((Cl b2) `)) `),Cl (b2 `),Cl ((Cl (b2 `)) `),Cl ((Cl ((Cl (b2 `)) `)) `)};

:: KURATO_1:funcnot 5 => KURATO_1:func 4
definition
  let a1 be non empty TopSpace-like TopStruct;
  let a2 be Element of bool the carrier of a1;
  func Kurat14OpPart A2 -> Element of bool bool the carrier of a1 equals
    {(Cl a2) `,(Cl ((Cl a2) `)) `,(Cl ((Cl ((Cl a2) `)) `)) `,(Cl (a2 `)) `,(Cl ((Cl (a2 `)) `)) `,(Cl ((Cl ((Cl (a2 `)) `)) `)) `};
end;

:: KURATO_1:def 4
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of bool the carrier of b1 holds
   Kurat14OpPart b2 = {(Cl b2) `,(Cl ((Cl b2) `)) `,(Cl ((Cl ((Cl b2) `)) `)) `,(Cl (b2 `)) `,(Cl ((Cl (b2 `)) `)) `,(Cl ((Cl ((Cl (b2 `)) `)) `)) `};

:: KURATO_1:th 5
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of bool the carrier of b1 holds
   Kurat14Set b2 = ({b2,b2 `} \/ Kurat14ClPart b2) \/ Kurat14OpPart b2;

:: KURATO_1:funcreg 2
registration
  let a1 be non empty TopSpace-like TopStruct;
  let a2 be Element of bool the carrier of a1;
  cluster Kurat14Set a2 -> finite;
end;

:: KURATO_1:th 6
theorem
for b1 being non empty TopSpace-like TopStruct
for b2, b3 being Element of bool the carrier of b1
      st b3 in Kurat14Set b2
   holds b3 ` in Kurat14Set b2 & Cl b3 in Kurat14Set b2;

:: KURATO_1:th 7
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of bool the carrier of b1 holds
   card Kurat14Set b2 <= 14;

:: KURATO_1:funcnot 6 => KURATO_1:func 5
definition
  let a1 be non empty TopSpace-like TopStruct;
  let a2 be Element of bool the carrier of a1;
  func Kurat7Set A2 -> Element of bool bool the carrier of a1 equals
    {a2,Int a2,Cl a2,Int Cl a2,Cl Int a2,Cl Int Cl a2,Int Cl Int a2};
end;

:: KURATO_1:def 5
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of bool the carrier of b1 holds
   Kurat7Set b2 = {b2,Int b2,Cl b2,Int Cl b2,Cl Int b2,Cl Int Cl b2,Int Cl Int b2};

:: KURATO_1:th 9
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of bool the carrier of b1 holds
   Kurat7Set b2 = ({b2} \/ {Int b2,Int Cl b2,Int Cl Int b2}) \/ {Cl b2,Cl Int b2,Cl Int Cl b2};

:: KURATO_1:funcreg 3
registration
  let a1 be non empty TopSpace-like TopStruct;
  let a2 be Element of bool the carrier of a1;
  cluster Kurat7Set a2 -> finite;
end;

:: KURATO_1:th 10
theorem
for b1 being non empty TopSpace-like TopStruct
for b2, b3 being Element of bool the carrier of b1
      st b3 in Kurat7Set b2
   holds Int b3 in Kurat7Set b2 & Cl b3 in Kurat7Set b2;

:: KURATO_1:funcnot 7 => KURATO_1:func 6
definition
  func KurExSet -> Element of bool the carrier of R^1 equals
    (({1} \/ RAT(2,4)) \/ ].4,5.[) \/ ].5,+infty.[;
end;

:: KURATO_1:def 6
theorem
KurExSet = (({1} \/ RAT(2,4)) \/ ].4,5.[) \/ ].5,+infty.[;

:: KURATO_1:th 12
theorem
Cl KurExSet = {1} \/ [.2,+infty.[;

:: KURATO_1:th 13
theorem
(Cl KurExSet) ` = ].-infty,1.[ \/ ].1,2.[;

:: KURATO_1:th 14
theorem
Cl ((Cl KurExSet) `) = ].-infty,2.];

:: KURATO_1:th 15
theorem
(Cl ((Cl KurExSet) `)) ` = ].2,+infty.[;

:: KURATO_1:th 16
theorem
Cl ((Cl ((Cl KurExSet) `)) `) = [.2,+infty.[;

:: KURATO_1:th 17
theorem
(Cl ((Cl ((Cl KurExSet) `)) `)) ` = ].-infty,2.[;

:: KURATO_1:th 18
theorem
KurExSet ` = (((].-infty,1.[ \/ ].1,2.]) \/ IRRAT(2,4)) \/ {4}) \/ {5};

:: KURATO_1:th 19
theorem
Cl (KurExSet `) = ].-infty,4.] \/ {5};

:: KURATO_1:th 20
theorem
(Cl (KurExSet `)) ` = ].4,5.[ \/ ].5,+infty.[;

:: KURATO_1:th 21
theorem
Cl ((Cl (KurExSet `)) `) = [.4,+infty.[;

:: KURATO_1:th 22
theorem
(Cl ((Cl (KurExSet `)) `)) ` = ].-infty,4.[;

:: KURATO_1:th 23
theorem
Cl ((Cl ((Cl (KurExSet `)) `)) `) = ].-infty,4.];

:: KURATO_1:th 24
theorem
(Cl ((Cl ((Cl (KurExSet `)) `)) `)) ` = ].4,+infty.[;

:: KURATO_1:th 25
theorem
Int KurExSet = ].4,5.[ \/ ].5,+infty.[;

:: KURATO_1:th 26
theorem
Cl Int KurExSet = [.4,+infty.[;

:: KURATO_1:th 27
theorem
Int Cl Int KurExSet = ].4,+infty.[;

:: KURATO_1:th 28
theorem
Int Cl KurExSet = ].2,+infty.[;

:: KURATO_1:th 29
theorem
Cl Int Cl KurExSet = [.2,+infty.[;

:: KURATO_1:th 30
theorem
Cl Int Cl KurExSet <> Int Cl KurExSet;

:: KURATO_1:th 31
theorem
Cl Int Cl KurExSet <> Cl KurExSet;

:: KURATO_1:th 32
theorem
Cl Int Cl KurExSet <> Int Cl Int KurExSet;

:: KURATO_1:th 33
theorem
Cl Int Cl KurExSet <> Cl Int KurExSet;

:: KURATO_1:th 34
theorem
Cl Int Cl KurExSet <> Int KurExSet;

:: KURATO_1:th 35
theorem
Int Cl KurExSet <> Cl KurExSet;

:: KURATO_1:th 36
theorem
Int Cl KurExSet <> Int Cl Int KurExSet;

:: KURATO_1:th 37
theorem
Int Cl KurExSet <> Cl Int KurExSet;

:: KURATO_1:th 38
theorem
Int Cl KurExSet <> Int KurExSet;

:: KURATO_1:th 39
theorem
Int Cl Int KurExSet <> Cl KurExSet;

:: KURATO_1:th 40
theorem
Cl Int KurExSet <> Cl KurExSet;

:: KURATO_1:th 41
theorem
Int KurExSet <> Cl KurExSet;

:: KURATO_1:th 42
theorem
Cl KurExSet <> KurExSet;

:: KURATO_1:th 43
theorem
KurExSet <> Int KurExSet;

:: KURATO_1:th 44
theorem
Cl Int KurExSet <> Int Cl Int KurExSet;

:: KURATO_1:th 45
theorem
Int Cl Int KurExSet <> Int KurExSet;

:: KURATO_1:th 46
theorem
Cl Int KurExSet <> Int KurExSet;

:: KURATO_1:th 47
theorem
Int Cl Int KurExSet <> Int Cl KurExSet;

:: KURATO_1:th 48
theorem
Int KurExSet,Int Cl KurExSet,Int Cl Int KurExSet are_mutually_different;

:: KURATO_1:th 49
theorem
Cl KurExSet,Cl Int KurExSet,Cl Int Cl KurExSet are_mutually_different;

:: KURATO_1:th 50
theorem
for b1 being set
      st b1 in {Int KurExSet,Int Cl KurExSet,Int Cl Int KurExSet}
   holds b1 is non empty open Element of bool the carrier of R^1;

:: KURATO_1:th 52
theorem
for b1 being set
      st b1 in {Int KurExSet,Int Cl KurExSet,Int Cl Int KurExSet}
   holds b1 <> REAL;

:: KURATO_1:th 53
theorem
for b1 being set
      st b1 in {Cl KurExSet,Cl Int KurExSet,Cl Int Cl KurExSet}
   holds b1 <> REAL;

:: KURATO_1:th 54
theorem
{Int KurExSet,Int Cl KurExSet,Int Cl Int KurExSet} misses {Cl KurExSet,Cl Int KurExSet,Cl Int Cl KurExSet};

:: KURATO_1:th 55
theorem
Int KurExSet,Int Cl KurExSet,Int Cl Int KurExSet,Cl KurExSet,Cl Int KurExSet,Cl Int Cl KurExSet are_mutually_different;

:: KURATO_1:funcreg 4
registration
  cluster KurExSet -> non open non closed;
end;

:: KURATO_1:th 56
theorem
{Int KurExSet,Int Cl KurExSet,Int Cl Int KurExSet,Cl KurExSet,Cl Int KurExSet,Cl Int Cl KurExSet} misses {KurExSet};

:: KURATO_1:th 57
theorem
KurExSet,Int KurExSet,Int Cl KurExSet,Int Cl Int KurExSet,Cl KurExSet,Cl Int KurExSet,Cl Int Cl KurExSet are_mutually_different;

:: KURATO_1:th 58
theorem
card Kurat7Set KurExSet = 7;

:: KURATO_1:funcreg 5
registration
  cluster Kurat14ClPart KurExSet -> with_proper_subsets;
end;

:: KURATO_1:funcreg 6
registration
  cluster Kurat14OpPart KurExSet -> with_proper_subsets;
end;

:: KURATO_1:funcreg 7
registration
  cluster Kurat14Set KurExSet -> with_proper_subsets;
end;

:: KURATO_1:funcreg 8
registration
  cluster Kurat14Set KurExSet -> with_non-empty_elements;
end;

:: KURATO_1:th 59
theorem
for b1 being with_non-empty_elements set
for b2 being set
      st b2 c= b1
   holds b2 is with_non-empty_elements;

:: KURATO_1:funcreg 9
registration
  cluster Kurat14ClPart KurExSet -> with_non-empty_elements;
end;

:: KURATO_1:funcreg 10
registration
  cluster Kurat14OpPart KurExSet -> with_non-empty_elements;
end;

:: KURATO_1:exreg 1
registration
  cluster with_non-empty_elements with_proper_subsets Element of bool bool the carrier of R^1;
end;

:: KURATO_1:th 60
theorem
for b1, b2 being with_non-empty_elements with_proper_subsets Element of bool bool the carrier of R^1
      st b1 is open(R^1) & b2 is closed(R^1)
   holds b1 misses b2;

:: KURATO_1:funcreg 11
registration
  cluster Kurat14ClPart KurExSet -> closed;
end;

:: KURATO_1:funcreg 12
registration
  cluster Kurat14OpPart KurExSet -> open;
end;

:: KURATO_1:th 61
theorem
Kurat14ClPart KurExSet misses Kurat14OpPart KurExSet;

:: KURATO_1:funcreg 13
registration
  let a1 be non empty TopSpace-like TopStruct;
  let a2 be Element of bool the carrier of a1;
  cluster Kurat14ClPart a2 -> finite;
end;

:: KURATO_1:funcreg 14
registration
  let a1 be non empty TopSpace-like TopStruct;
  let a2 be Element of bool the carrier of a1;
  cluster Kurat14OpPart a2 -> finite;
end;

:: KURATO_1:th 62
theorem
card Kurat14ClPart KurExSet = 6;

:: KURATO_1:th 63
theorem
card Kurat14OpPart KurExSet = 6;

:: KURATO_1:th 64
theorem
{KurExSet,KurExSet `} misses Kurat14ClPart KurExSet;

:: KURATO_1:funcreg 15
registration
  cluster KurExSet -> non empty;
end;

:: KURATO_1:th 65
theorem
KurExSet <> KurExSet `;

:: KURATO_1:th 66
theorem
{KurExSet,KurExSet `} misses Kurat14OpPart KurExSet;

:: KURATO_1:th 67
theorem
card Kurat14Set KurExSet = 14;

:: KURATO_1:attrnot 1 => KURATO_1:attr 1
definition
  let a1 be TopStruct;
  let a2 be Element of bool bool the carrier of a1;
  attr a2 is Cl-closed means
    for b1 being Element of bool the carrier of a1
          st b1 in a2
       holds Cl b1 in a2;
end;

:: KURATO_1:dfs 7
definiens
  let a1 be TopStruct;
  let a2 be Element of bool bool the carrier of a1;
To prove
     a2 is Cl-closed
it is sufficient to prove
  thus for b1 being Element of bool the carrier of a1
          st b1 in a2
       holds Cl b1 in a2;

:: KURATO_1:def 7
theorem
for b1 being TopStruct
for b2 being Element of bool bool the carrier of b1 holds
      b2 is Cl-closed(b1)
   iff
      for b3 being Element of bool the carrier of b1
            st b3 in b2
         holds Cl b3 in b2;

:: KURATO_1:attrnot 2 => KURATO_1:attr 2
definition
  let a1 be TopStruct;
  let a2 be Element of bool bool the carrier of a1;
  attr a2 is Int-closed means
    for b1 being Element of bool the carrier of a1
          st b1 in a2
       holds Int b1 in a2;
end;

:: KURATO_1:dfs 8
definiens
  let a1 be TopStruct;
  let a2 be Element of bool bool the carrier of a1;
To prove
     a2 is Int-closed
it is sufficient to prove
  thus for b1 being Element of bool the carrier of a1
          st b1 in a2
       holds Int b1 in a2;

:: KURATO_1:def 8
theorem
for b1 being TopStruct
for b2 being Element of bool bool the carrier of b1 holds
      b2 is Int-closed(b1)
   iff
      for b3 being Element of bool the carrier of b1
            st b3 in b2
         holds Int b3 in b2;

:: KURATO_1:funcreg 16
registration
  let a1 be non empty TopSpace-like TopStruct;
  let a2 be Element of bool the carrier of a1;
  cluster Kurat14Set a2 -> non empty;
end;

:: KURATO_1:funcreg 17
registration
  let a1 be non empty TopSpace-like TopStruct;
  let a2 be Element of bool the carrier of a1;
  cluster Kurat14Set a2 -> Cl-closed;
end;

:: KURATO_1:funcreg 18
registration
  let a1 be non empty TopSpace-like TopStruct;
  let a2 be Element of bool the carrier of a1;
  cluster Kurat14Set a2 -> compl-closed;
end;

:: KURATO_1:funcreg 19
registration
  let a1 be non empty TopSpace-like TopStruct;
  let a2 be Element of bool the carrier of a1;
  cluster Kurat7Set a2 -> non empty;
end;

:: KURATO_1:funcreg 20
registration
  let a1 be non empty TopSpace-like TopStruct;
  let a2 be Element of bool the carrier of a1;
  cluster Kurat7Set a2 -> Int-closed;
end;

:: KURATO_1:funcreg 21
registration
  let a1 be non empty TopSpace-like TopStruct;
  let a2 be Element of bool the carrier of a1;
  cluster Kurat7Set a2 -> Cl-closed;
end;

:: KURATO_1:exreg 2
registration
  let a1 be non empty TopSpace-like TopStruct;
  cluster non empty Cl-closed Int-closed Element of bool bool the carrier of a1;
end;

:: KURATO_1:exreg 3
registration
  let a1 be non empty TopSpace-like TopStruct;
  cluster non empty compl-closed Cl-closed Element of bool bool the carrier of a1;
end;