Article SUBSET_1, MML version 4.99.1005

:: SUBSET_1:funcreg 1
registration
  let a1 be set;
  cluster bool a1 -> non empty;
end;

:: SUBSET_1:funcreg 2
registration
  let a1, a2, a3 be set;
  cluster {a1,a2,a3} -> non empty;
end;

:: SUBSET_1:funcreg 3
registration
  let a1, a2, a3, a4 be set;
  cluster {a1,a2,a3,a4} -> non empty;
end;

:: SUBSET_1:funcreg 4
registration
  let a1, a2, a3, a4, a5 be set;
  cluster {a1,a2,a3,a4,a5} -> non empty;
end;

:: SUBSET_1:funcreg 5
registration
  let a1, a2, a3, a4, a5, a6 be set;
  cluster {a1,a2,a3,a4,a5,a6} -> non empty;
end;

:: SUBSET_1:funcreg 6
registration
  let a1, a2, a3, a4, a5, a6, a7 be set;
  cluster {a1,a2,a3,a4,a5,a6,a7} -> non empty;
end;

:: SUBSET_1:funcreg 7
registration
  let a1, a2, a3, a4, a5, a6, a7, a8 be set;
  cluster {a1,a2,a3,a4,a5,a6,a7,a8} -> non empty;
end;

:: SUBSET_1:funcreg 8
registration
  let a1, a2, a3, a4, a5, a6, a7, a8, a9 be set;
  cluster {a1,a2,a3,a4,a5,a6,a7,a8,a9} -> non empty;
end;

:: SUBSET_1:funcreg 9
registration
  let a1, a2, a3, a4, a5, a6, a7, a8, a9, a10 be set;
  cluster {a1,a2,a3,a4,a5,a6,a7,a8,a9,a10} -> non empty;
end;

:: SUBSET_1:modenot 1 => SUBSET_1:mode 1
definition
  let a1 be set;
  mode Element of A1 means
    it in a1
    if a1 is not empty
    otherwise it is empty;
end;

:: SUBSET_1:dfs 1
definiens
  let a1, a2 be set;
To prove
     a2 is Element of a1
it is sufficient to prove
  per cases;
  case a1 is not empty;
    thus a2 in a1;
  end;
  case a1 is empty;
    thus a2 is empty;
  end;

:: SUBSET_1:def 2
theorem
for b1, b2 being set holds
(b1 is empty or    (b2 is Element of b1
 iff
    b2 in b1)) &
 (b1 is empty implies    (b2 is Element of b1
 iff
    b2 is empty));

:: SUBSET_1:modenot 2
definition
  let a1 be set;
  mode Subset of a1 is Element of bool a1;
end;

:: SUBSET_1:exreg 1
registration
  let a1 be non empty set;
  cluster non empty Element of bool a1;
end;

:: SUBSET_1:funcreg 10
registration
  let a1, a2 be non empty set;
  cluster [:a1,a2:] -> non empty;
end;

:: SUBSET_1:funcreg 11
registration
  let a1, a2, a3 be non empty set;
  cluster [:a1,a2,a3:] -> non empty;
end;

:: SUBSET_1:funcreg 12
registration
  let a1, a2, a3, a4 be non empty set;
  cluster [:a1,a2,a3,a4:] -> non empty;
end;

:: SUBSET_1:modenot 3 => SUBSET_1:mode 2
definition
  let a1 be non empty set;
  let a2 be non empty Element of bool a1;
  redefine mode Element of a2 -> Element of a1;
end;

:: SUBSET_1:exreg 2
registration
  let a1 be set;
  cluster empty Element of bool a1;
end;

:: SUBSET_1:funcnot 1 => SUBSET_1:func 1
definition
  let a1 be set;
  func {} A1 -> Element of bool a1 equals
    {};
end;

:: SUBSET_1:def 3
theorem
for b1 being set holds
   {} b1 = {};

:: SUBSET_1:funcnot 2 => SUBSET_1:func 2
definition
  let a1 be set;
  func [#] A1 -> Element of bool a1 equals
    a1;
end;

:: SUBSET_1:def 4
theorem
for b1 being set holds
   [#] b1 = b1;

:: SUBSET_1:funcreg 13
registration
  let a1 be set;
  cluster {} a1 -> empty;
end;

:: SUBSET_1:th 4
theorem
for b1 being set holds
   {} is Element of bool b1;

:: SUBSET_1:th 7
theorem
for b1 being set
for b2, b3 being Element of bool b1
      st for b4 being Element of b1
              st b4 in b2
           holds b4 in b3
   holds b2 c= b3;

:: SUBSET_1:th 8
theorem
for b1 being set
for b2, b3 being Element of bool b1
      st for b4 being Element of b1 holds
              b4 in b2
           iff
              b4 in b3
   holds b2 = b3;

:: SUBSET_1:th 10
theorem
for b1 being set
for b2 being Element of bool b1
      st b2 <> {}
   holds ex b3 being Element of b1 st
      b3 in b2;

:: SUBSET_1:funcnot 3 => SUBSET_1:func 3
definition
  let a1 be set;
  let a2 be Element of bool a1;
  func A2 ` -> Element of bool a1 equals
    a1 \ a2;
  involutiveness;
::  for a1 being set
::  for a2 being Element of bool a1 holds
::     a2 ` ` = a2;
end;

:: SUBSET_1:def 5
theorem
for b1 being set
for b2 being Element of bool b1 holds
   b2 ` = b1 \ b2;

:: SUBSET_1:funcnot 4 => SUBSET_1:func 4
definition
  let a1 be set;
  let a2, a3 be Element of bool a1;
  redefine func a2 \/ a3 -> Element of bool a1;
  commutativity;
::  for a1 being set
::  for a2, a3 being Element of bool a1 holds
::  a2 \/ a3 = a3 \/ a2;
  idempotence;
::  for a1 being set
::  for a2 being Element of bool a1 holds
::     a2 \/ a2 = a2;
end;

:: SUBSET_1:funcnot 5 => SUBSET_1:func 5
definition
  let a1 be set;
  let a2, a3 be Element of bool a1;
  redefine func a2 \+\ a3 -> Element of bool a1;
  commutativity;
::  for a1 being set
::  for a2, a3 being Element of bool a1 holds
::  a2 \+\ a3 = a3 \+\ a2;
end;

:: SUBSET_1:funcnot 6 => SUBSET_1:func 6
definition
  let a1, a2 be set;
  redefine func a1 \ a2 -> Element of bool a1;
end;

:: SUBSET_1:funcnot 7 => SUBSET_1:func 7
definition
  let a1 be set;
  let a2 be Element of bool a1;
  let a3 be set;
  redefine func a2 \ a3 -> Element of bool a1;
end;

:: SUBSET_1:funcnot 8 => SUBSET_1:func 8
definition
  let a1 be set;
  let a2 be Element of bool a1;
  let a3 be set;
  redefine func a2 /\ a3 -> Element of bool a1;
  commutativity;
::  for a1 being set
::  for a2 being Element of bool a1
::  for a3 being set holds
::     a2 /\ a3 = a3 /\ a2;
  idempotence;
::  for a1 being set
::  for a2 being Element of bool a1 holds
::     a2 /\ a2 = a2;
end;

:: SUBSET_1:funcnot 9 => SUBSET_1:func 9
definition
  let a1, a2 be set;
  let a3 be Element of bool a1;
  redefine func a2 /\ a3 -> Element of bool a1;
  commutativity;
::  for a1, a2 being set
::  for a3 being Element of bool a1 holds
::     a2 /\ a3 = a3 /\ a2;
  idempotence;
::  for a1, a2 being set holds
::  a2 /\ a2 = a2;
end;

:: SUBSET_1:th 15
theorem
for b1 being set
for b2, b3, b4 being Element of bool b1
      st for b5 being Element of b1 holds
              b5 in b2
           iff
              (b5 in b3 or b5 in b4)
   holds b2 = b3 \/ b4;

:: SUBSET_1:th 16
theorem
for b1 being set
for b2, b3, b4 being Element of bool b1
      st for b5 being Element of b1 holds
              b5 in b2
           iff
              b5 in b3 & b5 in b4
   holds b2 = b3 /\ b4;

:: SUBSET_1:th 17
theorem
for b1 being set
for b2, b3, b4 being Element of bool b1
      st for b5 being Element of b1 holds
              b5 in b2
           iff
              b5 in b3 & not b5 in b4
   holds b2 = b3 \ b4;

:: SUBSET_1:th 18
theorem
for b1 being set
for b2, b3, b4 being Element of bool b1
      st for b5 being Element of b1 holds
              b5 in b2
           iff
              (b5 in b3 & not b5 in b4 or b5 in b4 & not b5 in b3)
   holds b2 = b3 \+\ b4;

:: SUBSET_1:th 22
theorem
for b1 being set holds
   [#] b1 = ({} b1) `;

:: SUBSET_1:th 25
theorem
for b1 being set
for b2 being Element of bool b1 holds
   b2 \/ (b2 `) = [#] b1;

:: SUBSET_1:th 28
theorem
for b1 being set
for b2 being Element of bool b1 holds
   b2 \/ [#] b1 = [#] b1;

:: SUBSET_1:th 31
theorem
for b1 being set
for b2, b3 being Element of bool b1 holds
   b2 c= b3
iff
   b3 ` c= b2 `;

:: SUBSET_1:th 32
theorem
for b1 being set
for b2, b3 being Element of bool b1 holds
b2 \ b3 = b2 /\ (b3 `);

:: SUBSET_1:th 33
theorem
for b1 being set
for b2, b3 being Element of bool b1 holds
(b2 \ b3) ` = b2 ` \/ b3;

:: SUBSET_1:th 34
theorem
for b1 being set
for b2, b3 being Element of bool b1 holds
(b2 \+\ b3) ` = (b2 /\ b3) \/ (b2 ` /\ (b3 `));

:: SUBSET_1:th 35
theorem
for b1 being set
for b2, b3 being Element of bool b1
      st b2 c= b3 `
   holds b3 c= b2 `;

:: SUBSET_1:th 36
theorem
for b1 being set
for b2, b3 being Element of bool b1
      st b2 ` c= b3
   holds b3 ` c= b2;

:: SUBSET_1:th 38
theorem
for b1 being set
for b2 being Element of bool b1 holds
      b2 c= b2 `
   iff
      b2 = {} b1;

:: SUBSET_1:th 39
theorem
for b1 being set
for b2 being Element of bool b1 holds
      b2 ` c= b2
   iff
      b2 = [#] b1;

:: SUBSET_1:th 40
theorem
for b1, b2 being set
for b3 being Element of bool b1
      st b2 c= b3 & b2 c= b3 `
   holds b2 = {};

:: SUBSET_1:th 41
theorem
for b1 being set
for b2, b3 being Element of bool b1 holds
(b2 \/ b3) ` c= b2 `;

:: SUBSET_1:th 42
theorem
for b1 being set
for b2, b3 being Element of bool b1 holds
b2 ` c= (b2 /\ b3) `;

:: SUBSET_1:th 43
theorem
for b1 being set
for b2, b3 being Element of bool b1 holds
   b2 misses b3
iff
   b2 c= b3 `;

:: SUBSET_1:th 44
theorem
for b1 being set
for b2, b3 being Element of bool b1 holds
   b2 misses b3 `
iff
   b2 c= b3;

:: SUBSET_1:th 46
theorem
for b1 being set
for b2, b3 being Element of bool b1
      st b2 misses b3 & b2 ` misses b3 `
   holds b2 = b3 `;

:: SUBSET_1:th 47
theorem
for b1 being set
for b2, b3, b4 being Element of bool b1
      st b2 c= b3 & b4 misses b3
   holds b2 c= b4 `;

:: SUBSET_1:th 48
theorem
for b1 being set
for b2, b3 being Element of bool b1
      st for b4 being Element of b2 holds
           b4 in b3
   holds b2 c= b3;

:: SUBSET_1:th 49
theorem
for b1 being set
for b2 being Element of bool b1
      st for b3 being Element of b1 holds
           b3 in b2
   holds b1 = b2;

:: SUBSET_1:th 50
theorem
for b1 being set
   st b1 <> {}
for b2 being Element of bool b1
for b3 being Element of b1
      st not b3 in b2
   holds b3 in b2 `;

:: SUBSET_1:th 51
theorem
for b1 being set
for b2, b3 being Element of bool b1
      st for b4 being Element of b1 holds
              b4 in b2
           iff
              not b4 in b3
   holds b2 = b3 `;

:: SUBSET_1:th 52
theorem
for b1 being set
for b2, b3 being Element of bool b1
      st for b4 being Element of b1 holds
              not b4 in b2
           iff
              b4 in b3
   holds b2 = b3 `;

:: SUBSET_1:th 53
theorem
for b1 being set
for b2, b3 being Element of bool b1
      st for b4 being Element of b1
              st (b4 in b2 implies b4 in b3)
           holds b4 in b3 & not b4 in b2
   holds b2 = b3 `;

:: SUBSET_1:th 55
theorem
for b1 being set
for b2 being Element of b1
      st b1 <> {}
   holds {b2} is Element of bool b1;

:: SUBSET_1:th 56
theorem
for b1 being set
for b2, b3 being Element of b1
      st b1 <> {}
   holds {b2,b3} is Element of bool b1;

:: SUBSET_1:th 57
theorem
for b1 being set
for b2, b3, b4 being Element of b1
      st b1 <> {}
   holds {b2,b3,b4} is Element of bool b1;

:: SUBSET_1:th 58
theorem
for b1 being set
for b2, b3, b4, b5 being Element of b1
      st b1 <> {}
   holds {b2,b3,b4,b5} is Element of bool b1;

:: SUBSET_1:th 59
theorem
for b1 being set
for b2, b3, b4, b5, b6 being Element of b1
      st b1 <> {}
   holds {b2,b3,b4,b5,b6} is Element of bool b1;

:: SUBSET_1:th 60
theorem
for b1 being set
for b2, b3, b4, b5, b6, b7 being Element of b1
      st b1 <> {}
   holds {b2,b3,b4,b5,b6,b7} is Element of bool b1;

:: SUBSET_1:th 61
theorem
for b1 being set
for b2, b3, b4, b5, b6, b7, b8 being Element of b1
      st b1 <> {}
   holds {b2,b3,b4,b5,b6,b7,b8} is Element of bool b1;

:: SUBSET_1:th 62
theorem
for b1 being set
for b2, b3, b4, b5, b6, b7, b8, b9 being Element of b1
      st b1 <> {}
   holds {b2,b3,b4,b5,b6,b7,b8,b9} is Element of bool b1;

:: SUBSET_1:th 63
theorem
for b1, b2 being set
      st b1 in b2
   holds {b1} is Element of bool b2;

:: SUBSET_1:sch 1
scheme SUBSET_1:sch 1
{F1 -> set}:
ex b1 being Element of bool F1() st
   for b2 being set holds
         b2 in b1
      iff
         b2 in F1() & P1[b2]


:: SUBSET_1:sch 2
scheme SUBSET_1:sch 2
{F1 -> set}:
for b1, b2 being Element of bool F1()
      st (for b3 being Element of F1() holds
               b3 in b1
            iff
               P1[b3]) &
         (for b3 being Element of F1() holds
               b3 in b2
            iff
               P1[b3])
   holds b1 = b2


:: SUBSET_1:prednot 1 => SUBSET_1:pred 1
definition
  let a1, a2 be non empty set;
  redefine pred a1 misses a2;
  symmetry;
::  for a1, a2 being non empty set
::        st a1 misses a2
::     holds a2 misses a1;
  irreflexivity;
::  for a1 being non empty set holds
::     not a1 misses a1;
end;

:: SUBSET_1:prednot 2 => not SUBSET_1:pred 2
notation
  let a1, a2 be non empty set;
  antonym a1 meets a2 for a1 meets a2;
end;

:: SUBSET_1:funcnot 10 => SUBSET_1:func 10
definition
  let a1 be set;
  assume contradiction;
  func choose A1 -> Element of a1 means
    TRUE;
end;

:: SUBSET_1:def 6
theorem
for b1 being set
   st contradiction
for b2 being Element of b1 holds
   (b2 = choose b1 implies TRUE) & b2 = choose b1;

:: SUBSET_1:sch 3
scheme SUBSET_1:sch 3
{F1 -> non empty set}:
ex b1 being Element of bool F1() st
   for b2 being Element of F1() holds
         b2 in b1
      iff
         P1[b2]


:: SUBSET_1:sch 4
scheme SUBSET_1:sch 4
{F1 -> set,
  F2 -> Element of bool F1(),
  F3 -> Element of bool F1()}:
F2() = F3()
provided
   for b1 being Element of F1() holds
         b1 in F2()
      iff
         P1[b1]
and
   for b1 being Element of F1() holds
         b1 in F3()
      iff
         P1[b1];


:: SUBSET_1:th 64
theorem
for b1 being set
for b2, b3 being Element of bool b1
      st b2 ` = b3 `
   holds b2 = b3;