Article CARD_FIN, MML version 4.99.1005

:: CARD_FIN:th 1
theorem
for b1, b2 being finite set
      st b1 c= b2 & card b1 = card b2
   holds b1 = b2;

:: CARD_FIN:th 2
theorem
for b1, b2 being finite set
for b3, b4 being set
      st (b2 = {} implies b1 = {}) & not b3 in b1
   holds card Funcs(b1,b2) = Card {b5 where b5 is Function-like quasi_total Relation of b1 \/ {b3},b2 \/ {b4}: rng (b5 | b1) c= b2 & b5 . b3 = b4};

:: CARD_FIN:th 3
theorem
for b1, b2 being finite set
for b3, b4 being set
      st not b3 in b1 & b4 in b2
   holds card Funcs(b1,b2) = Card {b5 where b5 is Function-like quasi_total Relation of b1 \/ {b3},b2: b5 . b3 = b4};

:: CARD_FIN:th 4
theorem
for b1, b2 being finite set
      st (b1 = {} implies b2 = {})
   holds card Funcs(b2,b1) = (card b1) |^ card b2;

:: CARD_FIN:th 5
theorem
for b1, b2 being finite set
for b3, b4 being set
      st (b2 is empty implies b1 is empty) & not b3 in b1 & not b4 in b2
   holds Card {b5 where b5 is Function-like quasi_total Relation of b1,b2: b5 is one-to-one} = Card {b5 where b5 is Function-like quasi_total Relation of b1 \/ {b3},b2 \/ {b4}: b5 is one-to-one & b5 . b3 = b4};

:: CARD_FIN:th 6
theorem
for b1, b2 being Element of NAT holds
b1 ! / ((b1 -' b2) !) is Element of NAT;

:: CARD_FIN:th 7
theorem
for b1, b2 being finite set
      st card b1 <= card b2
   holds Card {b3 where b3 is Function-like quasi_total Relation of b1,b2: b3 is one-to-one} = (card b2) ! / (((card b2) -' card b1) !);

:: CARD_FIN:th 8
theorem
for b1 being finite set holds
   Card {b2 where b2 is Function-like quasi_total Relation of b1,b1: b2 is Function-like quasi_total bijective Relation of b1,b1} = (card b1) !;

:: CARD_FIN:funcnot 1 => CARD_FIN:func 1
definition
  let a1 be finite set;
  let a2 be Element of NAT;
  let a3, a4 be set;
  func Choose(A1,A2,A3,A4) -> Element of bool Funcs(a1,{a3,a4}) means
    for b1 being set holds
          b1 in it
       iff
          ex b2 being Function-like quasi_total Relation of a1,{a3,a4} st
             b2 = b1 & Card (b2 " {a3}) = a2;
end;

:: CARD_FIN:def 1
theorem
for b1 being finite set
for b2 being Element of NAT
for b3, b4 being set
for b5 being Element of bool Funcs(b1,{b3,b4}) holds
      b5 = Choose(b1,b2,b3,b4)
   iff
      for b6 being set holds
            b6 in b5
         iff
            ex b7 being Function-like quasi_total Relation of b1,{b3,b4} st
               b7 = b6 & Card (b7 " {b3}) = b2;

:: CARD_FIN:th 9
theorem
for b1 being set
for b2 being finite set
for b3 being Element of NAT
      st card b2 <> b3
   holds Choose(b2,b3,b1,b1) is empty;

:: CARD_FIN:th 10
theorem
for b1, b2 being set
for b3 being finite set
for b4 being Element of NAT
      st card b3 < b4
   holds Choose(b3,b4,b1,b2) is empty;

:: CARD_FIN:th 11
theorem
for b1, b2 being set
for b3 being finite set
      st b1 <> b2
   holds card Choose(b3,0,b1,b2) = 1;

:: CARD_FIN:th 12
theorem
for b1, b2 being set
for b3 being finite set holds
   card Choose(b3,card b3,b1,b2) = 1;

:: CARD_FIN:th 13
theorem
for b1, b2 being set
for b3 being Relation-like Function-like set
      st b3 . b1 = b2 & b1 in proj1 b3
   holds {b1} \/ ((b3 | ((proj1 b3) \ {b1})) " {b2}) = b3 " {b2};

:: CARD_FIN:th 14
theorem
for b1, b2, b3 being set
for b4 being finite set
for b5 being Element of NAT
      st not b1 in b4
   holds card Choose(b4,b5,b2,b3) = Card {b6 where b6 is Function-like quasi_total Relation of b4 \/ {b1},{b2,b3}: Card (b6 " {b2}) = b5 + 1 &
    b6 . b1 = b2};

:: CARD_FIN:th 15
theorem
for b1, b2 being set
for b3 being Relation-like Function-like set
      st b3 . b1 <> b2
   holds (b3 | ((proj1 b3) \ {b1})) " {b2} = b3 " {b2};

:: CARD_FIN:th 16
theorem
for b1, b2, b3 being set
for b4 being finite set
for b5 being Element of NAT
      st not b1 in b4 & b2 <> b3
   holds card Choose(b4,b5,b2,b3) = Card {b6 where b6 is Function-like quasi_total Relation of b4 \/ {b1},{b2,b3}: Card (b6 " {b2}) = b5 & b6 . b1 = b3};

:: CARD_FIN:th 17
theorem
for b1, b2, b3 being set
for b4 being finite set
for b5 being Element of NAT
      st b1 <> b2 & not b3 in b4
   holds card Choose(b4 \/ {b3},b5 + 1,b1,b2) = (card Choose(b4,b5 + 1,b1,b2)) + card Choose(b4,b5,b1,b2);

:: CARD_FIN:th 18
theorem
for b1, b2 being set
for b3 being finite set
for b4 being Element of NAT
      st b1 <> b2
   holds card Choose(b3,b4,b1,b2) = (card b3) choose b4;

:: CARD_FIN:th 19
theorem
for b1, b2 being set
for b3, b4 being finite set
      st b1 <> b2
   holds (b3 --> b2) +* (b4 --> b1) in Choose(b4 \/ b3,card b4,b1,b2);

:: CARD_FIN:th 20
theorem
for b1, b2 being set
for b3, b4 being finite set
      st b1 <> b2 & b3 misses b4
   holds (b3 --> b1) +* (b4 --> b2) in Choose(b3 \/ b4,card b3,b1,b2);

:: CARD_FIN:funcnot 2 => CARD_FIN:func 2
definition
  let a1, a2 be Relation-like Function-like set;
  let a3 be set;
  func Intersection(A1,A2,A3) -> Element of bool union proj2 a1 means
    for b1 being set holds
          b1 in it
       iff
          b1 in union proj2 a1 &
           (for b2 being set
                 st b2 in proj1 a2 & a2 . b2 = a3
              holds b1 in a1 . b2);
end;

:: CARD_FIN:def 2
theorem
for b1, b2 being Relation-like Function-like set
for b3 being set
for b4 being Element of bool union proj2 b1 holds
      b4 = Intersection(b1,b2,b3)
   iff
      for b5 being set holds
            b5 in b4
         iff
            b5 in union proj2 b1 &
             (for b6 being set
                   st b6 in proj1 b2 & b2 . b6 = b3
                holds b5 in b1 . b6);

:: CARD_FIN:th 21
theorem
for b1, b2 being set
for b3, b4 being Relation-like Function-like set
      st (proj1 b3) /\ (b4 " {b1}) is not empty
   holds    b2 in Intersection(b3,b4,b1)
   iff
      for b5 being set
            st b5 in proj1 b4 & b4 . b5 = b1
         holds b2 in b3 . b5;

:: CARD_FIN:th 22
theorem
for b1 being set
for b2, b3 being Relation-like Function-like set
      st Intersection(b2,b3,b1) is not empty
   holds b3 " {b1} c= proj1 b2;

:: CARD_FIN:th 23
theorem
for b1 being set
for b2, b3 being Relation-like Function-like set
   st Intersection(b2,b3,b1) is not empty
for b4, b5 being set
      st b4 in b3 " {b1} & b5 in b3 " {b1}
   holds b2 . b4 meets b2 . b5;

:: CARD_FIN:th 24
theorem
for b1, b2 being set
for b3, b4 being Relation-like Function-like set
      st b1 in Intersection(b3,b4,b2) & b2 in proj2 b4
   holds ex b5 being set st
      b5 in proj1 b4 & b4 . b5 = b2 & b1 in b3 . b5;

:: CARD_FIN:th 25
theorem
for b1 being set
for b2, b3 being Relation-like Function-like set
      st (b2 is empty or union proj2 b2 is empty)
   holds Intersection(b2,b3,b1) = union proj2 b2;

:: CARD_FIN:th 26
theorem
for b1 being set
for b2, b3 being Relation-like Function-like set
      st b2 | (b3 " {b1}) = (b3 " {b1}) --> union proj2 b2
   holds Intersection(b2,b3,b1) = union proj2 b2;

:: CARD_FIN:th 27
theorem
for b1 being set
for b2, b3 being Relation-like Function-like set
      st union proj2 b2 is not empty & Intersection(b2,b3,b1) = union proj2 b2
   holds b2 | (b3 " {b1}) = (b3 " {b1}) --> union proj2 b2;

:: CARD_FIN:th 28
theorem
for b1 being set
for b2 being Relation-like Function-like set holds
   Intersection(b2,{},b1) = union proj2 b2;

:: CARD_FIN:th 29
theorem
for b1, b2 being set
for b3, b4 being Relation-like Function-like set holds
Intersection(b3,b4,b1) c= Intersection(b3,b4 | b2,b1);

:: CARD_FIN:th 30
theorem
for b1, b2 being set
for b3, b4 being Relation-like Function-like set
      st b3 " {b1} = (b3 | b2) " {b1}
   holds Intersection(b4,b3,b1) = Intersection(b4,b3 | b2,b1);

:: CARD_FIN:th 31
theorem
for b1, b2 being set
for b3, b4 being Relation-like Function-like set holds
Intersection(b3 | b1,b4,b2) c= Intersection(b3,b4,b2);

:: CARD_FIN:th 32
theorem
for b1, b2 being set
for b3, b4 being Relation-like Function-like set
      st b1 in proj2 b3 & b3 " {b1} c= b2
   holds Intersection(b4 | b2,b3,b1) = Intersection(b4,b3,b1);

:: CARD_FIN:th 33
theorem
for b1, b2 being set
for b3, b4 being Relation-like Function-like set
      st b1 in b3 " {b2}
   holds Intersection(b4,b3,b2) c= b4 . b1;

:: CARD_FIN:th 34
theorem
for b1, b2 being set
for b3, b4 being Relation-like Function-like set
      st b1 in b3 " {b2}
   holds (Intersection(b4,b3 | ((proj1 b3) \ {b1}),b2)) /\ (b4 . b1) = Intersection(b4,b3,b2);

:: CARD_FIN:th 35
theorem
for b1, b2 being set
for b3, b4, b5 being Relation-like Function-like set
      st b4 " {b1} = b5 " {b2}
   holds Intersection(b3,b4,b1) = Intersection(b3,b5,b2);

:: CARD_FIN:th 36
theorem
for b1 being set
for b2, b3 being Relation-like Function-like set
      st b2 " {b1} = {}
   holds Intersection(b3,b2,b1) = union proj2 b3;

:: CARD_FIN:th 37
theorem
for b1, b2 being set
for b3, b4 being Relation-like Function-like set
      st {b1} = b3 " {b2}
   holds Intersection(b4,b3,b2) = b4 . b1;

:: CARD_FIN:th 38
theorem
for b1, b2, b3 being set
for b4, b5 being Relation-like Function-like set
      st {b1,b2} = b4 " {b3}
   holds Intersection(b5,b4,b3) = (b5 . b1) /\ (b5 . b2);

:: CARD_FIN:th 39
theorem
for b1, b2 being set
for b3 being Relation-like Function-like set
      st b3 is not empty
   holds    b1 in Intersection(b3,(proj1 b3) --> b2,b2)
   iff
      for b4 being set
            st b4 in proj1 b3
         holds b1 in b3 . b4;

:: CARD_FIN:attrnot 1 => FINSET_1:attr 2
definition
  let a1 be Relation-like set;
  attr a1 is finite-yielding means
    for b1 being set holds
       a1 . b1 is finite;
end;

:: CARD_FIN:dfs 3
definiens
  let a1 be Relation-like Function-like set;
To prove
     a1 is finite-yielding
it is sufficient to prove
  thus for b1 being set holds
       a1 . b1 is finite;

:: CARD_FIN:def 3
theorem
for b1 being Relation-like Function-like set holds
      b1 is finite-yielding
   iff
      for b2 being set holds
         b1 . b2 is finite;

:: CARD_FIN:exreg 1
registration
  cluster Relation-like Function-like non empty finite-yielding set;
end;

:: CARD_FIN:exreg 2
registration
  cluster Relation-like Function-like empty finite-yielding set;
end;

:: CARD_FIN:funcreg 1
registration
  let a1 be Relation-like Function-like finite-yielding set;
  let a2 be set;
  cluster a1 . a2 -> finite;
end;

:: CARD_FIN:funcreg 2
registration
  let a1 be Relation-like Function-like finite-yielding set;
  let a2 be set;
  cluster a1 | a2 -> Relation-like finite-yielding;
end;

:: CARD_FIN:funcreg 3
registration
  let a1 be Relation-like Function-like finite-yielding set;
  let a2 be Relation-like Function-like set;
  cluster a2 * a1 -> Relation-like finite-yielding;
end;

:: CARD_FIN:funcreg 4
registration
  let a1 be Relation-like Function-like finite-yielding set;
  let a2 be Relation-like Function-like set;
  cluster Intersect(a1,a2) -> Relation-like Function-like finite-yielding;
end;

:: CARD_FIN:th 40
theorem
for b1 being set
for b2 being Relation-like Function-like set
for b3 being Relation-like Function-like finite-yielding set
      st b1 in proj2 b2
   holds Intersection(b3,b2,b1) is finite;

:: CARD_FIN:th 41
theorem
for b1 being Relation-like Function-like finite-yielding set
      st proj1 b1 is finite
   holds union proj2 b1 is finite;

:: CARD_FIN:funcnot 3 => CARD_FIN:func 3
definition
  let a1 be Relation-like Function-like T-Sequence-like finite set;
  let a2 be Element of NAT;
  redefine func a1 | a2 -> Relation-like Function-like T-Sequence-like finite set;
end;

:: CARD_FIN:funcnot 4 => CARD_FIN:func 4
definition
  let a1 be set;
  let a2 be finite T-Sequence of a1;
  let a3 be Element of NAT;
  redefine func a2 | a3 -> finite T-Sequence of a1;
end;

:: CARD_FIN:th 42
theorem
for b1 being non empty set
for b2 being finite T-Sequence of b1
for b3 being Function-like quasi_total Relation of [:b1,b1:],b1
for b4 being Element of NAT
      st b4 in dom b2 & (b3 is not having_a_unity(b1) implies b4 <> 0)
   holds b3 .(b3 "**" (b2 | b4),b2 . b4) = b3 "**" (b2 | (b4 + 1));

:: CARD_FIN:th 43
theorem
for b1 being non empty set
for b2 being finite T-Sequence of b1
for b3 being Element of NAT
      st len b2 = b3 + 1
   holds b2 = (b2 | b3) ^ <%b2 . b3%>;

:: CARD_FIN:th 44
theorem
for b1 being finite T-Sequence of NAT
for b2 being Element of NAT
      st b2 in dom b1
   holds (Sum (b1 | b2)) + (b1 . b2) = Sum (b1 | (b2 + 1));

:: CARD_FIN:th 45
theorem
for b1 being finite T-Sequence of NAT
for b2 being Element of NAT
      st proj2 b1 c= {0,b2}
   holds Sum b1 = b2 * card (b1 " {b2});

:: CARD_FIN:th 46
theorem
for b1 being set
for b2, b3 being Element of NAT holds
   b1 in Choose(b2,b3,1,0)
iff
   ex b4 being finite T-Sequence of NAT st
      b4 = b1 & dom b4 = b2 & proj2 b4 c= {0,1} & Sum b4 = b3;

:: CARD_FIN:th 47
theorem
for b1 being non empty set
for b2 being finite T-Sequence of b1
for b3 being Function-like quasi_total Relation of [:b1,b1:],b1
      st (b3 is having_a_unity(b1) or 1 <= len b2)
   holds b3 "**" b2 = b3 "**" XFS2FS b2;

:: CARD_FIN:th 48
theorem
for b1 being non empty set
for b2 being Function-like quasi_total Relation of [:b1,b1:],b1
for b3, b4 being finite T-Sequence of b1
for b5 being Function-like quasi_total bijective Relation of dom b3,dom b3
      st b2 is commutative(b1) & b2 is associative(b1) & (b2 is having_a_unity(b1) or 1 <= len b3) & b4 = b5 * b3
   holds b2 "**" b3 = b2 "**" b4;

:: CARD_FIN:funcnot 5 => CARD_FIN:func 5
definition
  let a1 be Element of NAT;
  let a2 be Relation-like Function-like finite-yielding set;
  assume proj1 a2 is finite;
  func Card_Intersection(A2,A1) -> Element of NAT means
    for b1, b2 being set
    for b3 being finite set
    for b4 being Function-like quasi_total Relation of card Choose(b3,a1,b1,b2),Choose(b3,a1,b1,b2)
          st proj1 a2 = b3 & b4 is one-to-one & b1 <> b2
       holds ex b5 being finite T-Sequence of NAT st
          dom b5 = dom b4 &
           (for b6 being set
           for b7 being Relation-like Function-like set
                 st b6 in dom b5 & b7 = b4 . b6
              holds b5 . b6 = Card Intersection(a2,b7,b1)) &
           it = Sum b5;
end;

:: CARD_FIN:def 4
theorem
for b1 being Element of NAT
for b2 being Relation-like Function-like finite-yielding set
   st proj1 b2 is finite
for b3 being Element of NAT holds
      b3 = Card_Intersection(b2,b1)
   iff
      for b4, b5 being set
      for b6 being finite set
      for b7 being Function-like quasi_total Relation of card Choose(b6,b1,b4,b5),Choose(b6,b1,b4,b5)
            st proj1 b2 = b6 & b7 is one-to-one & b4 <> b5
         holds ex b8 being finite T-Sequence of NAT st
            dom b8 = dom b7 &
             (for b9 being set
             for b10 being Relation-like Function-like set
                   st b9 in dom b8 & b10 = b7 . b9
                holds b8 . b9 = Card Intersection(b2,b10,b4)) &
             b3 = Sum b8;

:: CARD_FIN:th 49
theorem
for b1 being Element of NAT
for b2 being Relation-like Function-like finite-yielding set
for b3, b4 being set
for b5 being finite set
for b6 being Function-like quasi_total Relation of card Choose(b5,b1,b3,b4),Choose(b5,b1,b3,b4)
   st proj1 b2 = b5 & b6 is one-to-one & b3 <> b4
for b7 being finite T-Sequence of NAT
      st dom b7 = dom b6 &
         (for b8 being set
         for b9 being Relation-like Function-like set
               st b8 in dom b7 & b9 = b6 . b8
            holds b7 . b8 = Card Intersection(b2,b9,b3))
   holds Card_Intersection(b2,b1) = Sum b7;

:: CARD_FIN:th 50
theorem
for b1 being Element of NAT
for b2 being Relation-like Function-like finite-yielding set
      st proj1 b2 is finite & b1 = 0
   holds Card_Intersection(b2,b1) = Card union proj2 b2;

:: CARD_FIN:th 51
theorem
for b1 being finite set
for b2 being Element of NAT
for b3 being Relation-like Function-like finite-yielding set
      st proj1 b3 = b1 & card b1 < b2
   holds Card_Intersection(b3,b2) = 0;

:: CARD_FIN:th 52
theorem
for b1 being Relation-like Function-like finite-yielding set
for b2 being finite set
   st proj1 b1 = b2
for b3 being Function-like quasi_total Relation of card b2,b2
      st b3 is one-to-one
   holds ex b4 being finite T-Sequence of NAT st
      dom b4 = card b2 &
       (for b5 being set
             st b5 in dom b4
          holds b4 . b5 = card ((b3 * b1) . b5)) &
       Card_Intersection(b1,1) = Sum b4;

:: CARD_FIN:th 53
theorem
for b1 being set
for b2 being finite set
for b3 being Relation-like Function-like finite-yielding set
      st proj1 b3 = b2
   holds Card_Intersection(b3,card b2) = Card Intersection(b3,b2 --> b1,b1);

:: CARD_FIN:th 54
theorem
for b1 being set
for b2 being finite set
for b3 being Relation-like Function-like finite-yielding set
      st b3 = b1 .--> b2
   holds Card_Intersection(b3,1) = card b2;

:: CARD_FIN:th 55
theorem
for b1, b2 being set
for b3, b4 being finite set
for b5 being Relation-like Function-like finite-yielding set
      st b1 <> b2 & b5 = (b1,b2)-->(b3,b4)
   holds Card_Intersection(b5,1) = (card b3) + card b4 &
    Card_Intersection(b5,2) = card (b3 /\ b4);

:: CARD_FIN:th 56
theorem
for b1 being Relation-like Function-like finite-yielding set
for b2 being set
      st proj1 b1 is finite & b2 in proj1 b1
   holds Card_Intersection(b1,1) = (Card_Intersection(b1 | ((proj1 b1) \ {b2}),1)) + card (b1 . b2);

:: CARD_FIN:th 57
theorem
for b1 being set
for b2 being Relation-like Function-like set holds
   proj1 Intersect(b2,(proj1 b2) --> b1) = proj1 b2 &
    (for b3 being set
          st b3 in proj1 b2
       holds (Intersect(b2,(proj1 b2) --> b1)) . b3 = (b2 . b3) /\ b1);

:: CARD_FIN:th 58
theorem
for b1 being set
for b2 being Relation-like Function-like set holds
   (union proj2 b2) /\ b1 = union proj2 Intersect(b2,(proj1 b2) --> b1);

:: CARD_FIN:th 59
theorem
for b1, b2 being set
for b3, b4 being Relation-like Function-like set holds
(Intersection(b3,b4,b1)) /\ b2 = Intersection(Intersect(b3,(proj1 b3) --> b2),b4,b1);

:: CARD_FIN:th 60
theorem
for b1, b2 being Relation-like Function-like T-Sequence-like finite set
      st b1 is one-to-one & b2 is one-to-one & proj2 b1 misses proj2 b2
   holds b1 ^ b2 is one-to-one;

:: CARD_FIN:th 61
theorem
for b1 being Element of NAT
for b2 being Relation-like Function-like finite-yielding set
for b3 being finite set
for b4 being set
for b5 being Element of NAT
      st proj1 b2 = b3 & b4 in proj1 b2 & 0 < b1
   holds Card_Intersection(b2,b1 + 1) = (Card_Intersection(b2 | ((proj1 b2) \ {b4}),b1 + 1)) + Card_Intersection(Intersect(b2 | ((proj1 b2) \ {b4}),((proj1 b2) \ {b4}) --> (b2 . b4)),b1);

:: CARD_FIN:th 62
theorem
for b1 being non empty set
for b2 being Function-like quasi_total Relation of [:b1,b1:],b1
for b3, b4, b5 being finite T-Sequence of b1
      st b2 is commutative(b1) &
         b2 is associative(b1) &
         (b2 is having_a_unity(b1) or 1 <= len b3) &
         len b3 = len b4 &
         len b3 = len b5 &
         (for b6 being Element of NAT
               st b6 in dom b5
            holds b5 . b6 = b2 .(b3 . b6,b4 . b6))
   holds b2 "**" (b3 ^ b4) = b2 "**" b5;

:: CARD_FIN:funcnot 6 => CARD_FIN:func 6
definition
  let a1 be finite T-Sequence of INT;
  func Sum A1 -> integer set equals
    addint "**" a1;
end;

:: CARD_FIN:def 5
theorem
for b1 being finite T-Sequence of INT holds
   Sum b1 = addint "**" b1;

:: CARD_FIN:funcnot 7 => CARD_FIN:func 7
definition
  let a1 be finite T-Sequence of INT;
  let a2 be set;
  redefine func a1 . a2 -> integer set;
end;

:: CARD_FIN:th 63
theorem
for b1 being finite T-Sequence of NAT
for b2 being finite T-Sequence of INT
      st b2 = b1
   holds Sum b2 = Sum b1;

:: CARD_FIN:th 64
theorem
for b1, b2 being finite T-Sequence of INT
for b3 being integer set
      st dom b1 = dom b2 &
         (for b4 being Element of NAT
               st b4 in dom b1
            holds b3 * (b1 . b4) = b2 . b4)
   holds b3 * Sum b1 = Sum b2;

:: CARD_FIN:th 65
theorem
for b1 being set
for b2 being Relation-like Function-like set
      st b1 in proj1 b2
   holds union proj2 b2 = (union proj2 (b2 | ((proj1 b2) \ {b1}))) \/ (b2 . b1);

:: CARD_FIN:th 66
theorem
for b1 being Relation-like Function-like finite-yielding set
for b2 being finite set holds
   ex b3 being finite T-Sequence of INT st
      dom b3 = card b2 &
       (for b4 being Element of NAT
             st b4 in dom b3
          holds b3 . b4 = ((- 1) |^ b4) * Card_Intersection(b1,b4 + 1));

:: CARD_FIN:th 67
theorem
for b1 being Relation-like Function-like finite-yielding set
for b2 being finite set
   st proj1 b1 = b2
for b3 being finite T-Sequence of INT
      st dom b3 = card b2 &
         (for b4 being Element of NAT
               st b4 in dom b3
            holds b3 . b4 = ((- 1) |^ b4) * Card_Intersection(b1,b4 + 1))
   holds Card union proj2 b1 = Sum b3;

:: CARD_FIN:th 68
theorem
for b1 being Relation-like Function-like finite-yielding set
for b2 being finite set
for b3, b4 being Element of NAT
      st proj1 b1 = b2 &
         (ex b5, b6 being set st
            b5 <> b6 &
             (for b7 being Relation-like Function-like set
                   st b7 in Choose(b2,b4,b5,b6)
                holds Card Intersection(b1,b7,b5) = b3))
   holds Card_Intersection(b1,b4) = b3 * ((card b2) choose b4);

:: CARD_FIN:th 69
theorem
for b1 being Relation-like Function-like finite-yielding set
for b2 being finite set
   st proj1 b1 = b2
for b3 being finite T-Sequence of NAT
      st dom b3 = card b2 &
         (for b4 being Element of NAT
               st b4 in dom b3
            holds ex b5, b6 being set st
               b5 <> b6 &
                (for b7 being Relation-like Function-like set
                      st b7 in Choose(b2,b4 + 1,b5,b6)
                   holds Card Intersection(b1,b7,b5) = b3 . b4))
   holds ex b4 being finite T-Sequence of INT st
      dom b4 = card b2 &
       Card union proj2 b1 = Sum b4 &
       (for b5 being Element of NAT
             st b5 in dom b4
          holds b4 . b5 = (((- 1) |^ b5) * (b3 . b5)) * ((card b2) choose (b5 + 1)));

:: CARD_FIN:th 70
theorem
for b1, b2 being finite set
      st b1 is not empty & b2 is not empty
   holds ex b3 being finite T-Sequence of INT st
      dom b3 = (card b2) + 1 &
       Sum b3 = Card {b4 where b4 is Function-like quasi_total Relation of b1,b2: b4 is onto(b1, b2)} &
       (for b4 being Element of NAT
             st b4 in dom b3
          holds b3 . b4 = (((- 1) |^ b4) * ((card b2) choose b4)) * (((card b2) - b4) |^ card b1));

:: CARD_FIN:th 71
theorem
for b1, b2 being Element of NAT
      st b2 <= b1
   holds ex b3 being finite T-Sequence of INT st
      b1 block b2 = (1 / (b2 !)) * Sum b3 &
       dom b3 = b2 + 1 &
       (for b4 being Element of NAT
             st b4 in dom b3
          holds b3 . b4 = (((- 1) |^ b4) * (b2 choose b4)) * ((b2 - b4) |^ b1));

:: CARD_FIN:th 72
theorem
for b1, b2, b3 being finite set
   st (b2 is empty implies b1 is empty) & b3 c= b1
for b4 being Function-like quasi_total Relation of b1,b2
      st b4 is one-to-one & card b1 = card b2
   holds ((card b1) -' card b3) ! = Card {b5 where b5 is Function-like quasi_total Relation of b1,b2: b5 is one-to-one &
    rng (b5 | (b1 \ b3)) c= b4 .: (b1 \ b3) &
    (for b6 being set
          st b6 in b3
       holds b5 . b6 = b4 . b6)};

:: CARD_FIN:th 73
theorem
for b1 being finite set
for b2 being Relation-like Function-like set
      st proj1 b2 = b1 & b2 is one-to-one
   holds ex b3 being finite T-Sequence of INT st
      Sum b3 = Card {b4 where b4 is Function-like quasi_total Relation of b1,proj2 b2: b4 is one-to-one &
        (for b5 being set
              st b5 in b1
           holds b4 . b5 <> b2 . b5)} &
       dom b3 = (card b1) + 1 &
       (for b4 being Element of NAT
             st b4 in dom b3
          holds b3 . b4 = (((- 1) |^ b4) * ((card b1) !)) / (b4 !));

:: CARD_FIN:th 74
theorem
for b1 being finite set holds
   ex b2 being finite T-Sequence of INT st
      Sum b2 = Card {b3 where b3 is Function-like quasi_total Relation of b1,b1: b3 is one-to-one &
        (for b4 being set
              st b4 in b1
           holds b3 . b4 <> b4)} &
       dom b2 = (card b1) + 1 &
       (for b3 being Element of NAT
             st b3 in dom b2
          holds b2 . b3 = (((- 1) |^ b3) * ((card b1) !)) / (b3 !));