Article FINSET_1, MML version 4.99.1005

:: FINSET_1:attrnot 1 => FINSET_1:attr 1
definition
  let a1 be set;
  attr a1 is finite means
    ex b1 being Relation-like Function-like set st
       proj2 b1 = a1 & proj1 b1 in omega;
end;

:: FINSET_1:dfs 1
definiens
  let a1 be set;
To prove
     a1 is finite
it is sufficient to prove
  thus ex b1 being Relation-like Function-like set st
       proj2 b1 = a1 & proj1 b1 in omega;

:: FINSET_1:def 1
theorem
for b1 being set holds
      b1 is finite
   iff
      ex b2 being Relation-like Function-like set st
         proj2 b2 = b1 & proj1 b2 in omega;

:: FINSET_1:attrnot 2 => FINSET_1:attr 1
notation
  let a1 be set;
  antonym infinite for finite;
end;

:: FINSET_1:exreg 1
registration
  cluster non empty finite set;
end;

:: FINSET_1:condreg 1
registration
  cluster empty -> finite (set);
end;

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

:: FINSET_1:sch 1
scheme FINSET_1:sch 1
{F1 -> set,
  F2 -> set,
  F3 -> set}:
ex b1 being Relation-like Function-like set st
   proj1 b1 = F1() &
    (for b2 being ordinal set
          st b2 in F1()
       holds (P1[b2] implies b1 . b2 = F2(b2)) & (P1[b2] or b1 . b2 = F3(b2)))


:: FINSET_1:funcreg 1
registration
  let a1 be set;
  cluster {a1} -> finite;
end;

:: FINSET_1:funcreg 2
registration
  let a1, a2 be set;
  cluster {a1,a2} -> finite;
end;

:: FINSET_1:funcreg 3
registration
  let a1, a2, a3 be set;
  cluster {a1,a2,a3} -> finite;
end;

:: FINSET_1:funcreg 4
registration
  let a1, a2, a3, a4 be set;
  cluster {a1,a2,a3,a4} -> finite;
end;

:: FINSET_1:funcreg 5
registration
  let a1, a2, a3, a4, a5 be set;
  cluster {a1,a2,a3,a4,a5} -> finite;
end;

:: FINSET_1:funcreg 6
registration
  let a1, a2, a3, a4, a5, a6 be set;
  cluster {a1,a2,a3,a4,a5,a6} -> finite;
end;

:: FINSET_1:funcreg 7
registration
  let a1, a2, a3, a4, a5, a6, a7 be set;
  cluster {a1,a2,a3,a4,a5,a6,a7} -> finite;
end;

:: FINSET_1:funcreg 8
registration
  let a1, a2, a3, a4, a5, a6, a7, a8 be set;
  cluster {a1,a2,a3,a4,a5,a6,a7,a8} -> finite;
end;

:: FINSET_1:condreg 2
registration
  let a1 be finite set;
  cluster -> finite (Element of bool a1);
end;

:: FINSET_1:funcreg 9
registration
  let a1, a2 be finite set;
  cluster a1 \/ a2 -> finite;
end;

:: FINSET_1:th 13
theorem
for b1, b2 being set
      st b1 c= b2 & b2 is finite
   holds b1 is finite;

:: FINSET_1:th 14
theorem
for b1, b2 being set
      st b1 is finite & b2 is finite
   holds b1 \/ b2 is finite;

:: FINSET_1:funcreg 10
registration
  let a1 be set;
  let a2 be finite set;
  cluster a1 /\ a2 -> finite;
end;

:: FINSET_1:funcreg 11
registration
  let a1 be finite set;
  let a2 be set;
  cluster a1 /\ a2 -> finite;
end;

:: FINSET_1:funcreg 12
registration
  let a1 be finite set;
  let a2 be set;
  cluster a1 \ a2 -> finite;
end;

:: FINSET_1:th 15
theorem
for b1, b2 being set
      st b1 is finite
   holds b1 /\ b2 is finite;

:: FINSET_1:th 16
theorem
for b1, b2 being set
      st b1 is finite
   holds b1 \ b2 is finite;

:: FINSET_1:th 17
theorem
for b1 being set
for b2 being Relation-like Function-like set
      st b1 is finite
   holds b2 .: b1 is finite;

:: FINSET_1:funcreg 13
registration
  let a1 be Relation-like Function-like set;
  let a2 be finite set;
  cluster a1 .: a2 -> finite;
end;

:: FINSET_1:th 18
theorem
for b1 being set
   st b1 is finite
for b2 being Element of bool bool b1
      st b2 <> {}
   holds ex b3 being set st
      b3 in b2 &
       (for b4 being set
             st b4 in b2 & b3 c= b4
          holds b4 = b3);

:: FINSET_1:sch 2
scheme FINSET_1:sch 2
{F1 -> set}:
P1[F1()]
provided
   F1() is finite
and
   P1[{}]
and
   for b1, b2 being set
         st b1 in F1() & b2 c= F1() & P1[b2]
      holds P1[b2 \/ {b1}];


:: FINSET_1:th 19
theorem
for b1, b2 being set
      st b1 is finite & b2 is finite
   holds [:b1,b2:] is finite;

:: FINSET_1:funcreg 14
registration
  let a1, a2 be finite set;
  cluster [:a1,a2:] -> finite;
end;

:: FINSET_1:th 20
theorem
for b1, b2, b3 being set
      st b1 is finite & b2 is finite & b3 is finite
   holds [:b1,b2,b3:] is finite;

:: FINSET_1:funcreg 15
registration
  let a1, a2, a3 be finite set;
  cluster [:a1,a2,a3:] -> finite;
end;

:: FINSET_1:th 21
theorem
for b1, b2, b3, b4 being set
      st b1 is finite & b2 is finite & b3 is finite & b4 is finite
   holds [:b1,b2,b3,b4:] is finite;

:: FINSET_1:funcreg 16
registration
  let a1, a2, a3, a4 be finite set;
  cluster [:a1,a2,a3,a4:] -> finite;
end;

:: FINSET_1:th 22
theorem
for b1, b2 being set
      st b1 <> {} & [:b2,b1:] is finite
   holds b2 is finite;

:: FINSET_1:th 23
theorem
for b1, b2 being set
      st b1 <> {} & [:b1,b2:] is finite
   holds b2 is finite;

:: FINSET_1:th 24
theorem
for b1 being set holds
      b1 is finite
   iff
      bool b1 is finite;

:: FINSET_1:funcreg 17
registration
  let a1 be finite set;
  cluster bool a1 -> finite;
end;

:: FINSET_1:th 25
theorem
for b1 being set holds
      b1 is finite &
       (for b2 being set
             st b2 in b1
          holds b2 is finite)
   iff
      union b1 is finite;

:: FINSET_1:th 26
theorem
for b1 being Relation-like Function-like set
      st proj1 b1 is finite
   holds proj2 b1 is finite;

:: FINSET_1:th 27
theorem
for b1 being set
for b2 being Relation-like Function-like set
      st b1 c= proj2 b2 & b2 " b1 is finite
   holds b1 is finite;

:: FINSET_1:th 28
theorem
for b1, b2 being set
      st b1 is finite & b2 is finite
   holds b1 \+\ b2 is finite;

:: FINSET_1:funcreg 18
registration
  let a1, a2 be finite set;
  cluster a1 \+\ a2 -> finite;
end;

:: FINSET_1:exreg 3
registration
  let a1 be non empty set;
  cluster non empty finite Element of bool a1;
end;

:: FINSET_1:th 29
theorem
for b1 being Relation-like Function-like set holds
      proj1 b1 is finite
   iff
      b1 is finite;

:: FINSET_1:th 30
theorem
for b1 being set
      st b1 is finite & b1 <> {} & b1 is c=-linear
   holds ex b2 being set st
      b2 in b1 &
       (for b3 being set
             st b3 in b1
          holds b2 c= b3);

:: FINSET_1:th 31
theorem
for b1 being set
      st b1 is finite & b1 <> {} & b1 is c=-linear
   holds ex b2 being set st
      b2 in b1 &
       (for b3 being set
             st b3 in b1
          holds b3 c= b2);

:: FINSET_1:attrnot 3 => FINSET_1:attr 2
definition
  let a1 be Relation-like set;
  attr a1 is finite-yielding means
    for b1 being set
          st b1 in proj2 a1
       holds b1 is finite;
end;

:: FINSET_1:dfs 2
definiens
  let a1 be Relation-like set;
To prove
     a1 is finite-yielding
it is sufficient to prove
  thus for b1 being set
          st b1 in proj2 a1
       holds b1 is finite;

:: FINSET_1:def 2
theorem
for b1 being Relation-like set holds
      b1 is finite-yielding
   iff
      for b2 being set
            st b2 in proj2 b1
         holds b2 is finite;

:: FINSET_1:th 32
theorem
for b1, b2, b3 being set
      st b1 is finite & b1 c= [:b2,b3:]
   holds ex b4, b5 being set st
      b4 is finite & b4 c= b2 & b5 is finite & b5 c= b3 & b1 c= [:b4,b5:];

:: FINSET_1:th 33
theorem
for b1, b2, b3 being set
      st b1 is finite & b2 is finite & b1 c= [:b3,b2:]
   holds ex b4 being set st
      b4 is finite & b4 c= b3 & b1 c= [:b4,b2:];

:: FINSET_1:exreg 4
registration
  cluster empty Relation-like Function-like finite set;
end;

:: FINSET_1:exreg 5
registration
  cluster non empty Relation-like Function-like finite set;
end;

:: FINSET_1:funcreg 19
registration
  let a1 be Relation-like finite set;
  cluster proj1 a1 -> finite;
end;

:: FINSET_1:funcreg 20
registration
  let a1 be Relation-like Function-like set;
  let a2 be Relation-like Function-like finite set;
  cluster a2 * a1 -> Relation-like finite;
end;

:: FINSET_1:condreg 3
registration
  let a1 be finite set;
  let a2 be set;
  cluster Function-like quasi_total -> finite (Relation of a1,a2);
end;

:: FINSET_1:funcreg 21
registration
  let a1, a2 be set;
  cluster a1 .--> a2 -> finite;
end;

:: FINSET_1:funcreg 22
registration
  let a1 be Relation-like finite set;
  cluster proj2 a1 -> finite;
end;