Article AFINSQ_1, MML version 4.99.1005

:: AFINSQ_1:th 1
theorem
for b1 being Element of NAT holds
   b1 in b1 + 1;

:: AFINSQ_1:th 2
theorem
for b1, b2 being Element of NAT
      st b1 <= b2
   holds b1 = b1 /\ b2;

:: AFINSQ_1:th 3
theorem
for b1, b2 being Element of NAT
      st b1 = b1 /\ b2
   holds b1 <= b2;

:: AFINSQ_1:th 4
theorem
for b1 being Element of NAT holds
   b1 \/ {b1} = b1 + 1;

:: AFINSQ_1:th 5
theorem
for b1 being Element of NAT holds
   Seg b1 c= b1 + 1;

:: AFINSQ_1:th 6
theorem
for b1 being Element of NAT holds
   b1 + 1 = {0} \/ Seg b1;

:: AFINSQ_1:th 7
theorem
for b1 being Relation-like Function-like set holds
      b1 is finite & b1 is T-Sequence-like
   iff
      ex b2 being Element of NAT st
         proj1 b1 = b2;

:: AFINSQ_1:exreg 1
registration
  cluster Relation-like Function-like T-Sequence-like finite set;
end;

:: AFINSQ_1:modenot 1
definition
  mode XFinSequence is Relation-like Function-like T-Sequence-like finite set;
end;

:: AFINSQ_1:funcreg 1
registration
  let a1 be Relation-like Function-like T-Sequence-like finite set;
  cluster proj1 a1 -> natural;
end;

:: AFINSQ_1:funcnot 1 => CARD_1:func 1
notation
  let a1 be Relation-like Function-like T-Sequence-like finite set;
  synonym len a1 for Card a1;
end;

:: AFINSQ_1:funcnot 2 => AFINSQ_1:func 1
definition
  let a1 be Relation-like Function-like T-Sequence-like finite set;
  redefine func len A1 -> Element of NAT means
    it = proj1 a1;
  projectivity;
::  for a1 being Relation-like Function-like T-Sequence-like finite set holds
::     len len a1 = len a1;
end;

:: AFINSQ_1:def 1
theorem
for b1 being Relation-like Function-like T-Sequence-like finite set
for b2 being Element of NAT holds
      b2 = len b1
   iff
      b2 = proj1 b1;

:: AFINSQ_1:funcnot 3 => AFINSQ_1:func 2
definition
  let a1 be Relation-like Function-like T-Sequence-like finite set;
  redefine func dom a1 -> Element of bool NAT;
end;

:: AFINSQ_1:th 8
theorem
for b1 being Relation-like Function-like set
      st ex b2 being Element of NAT st
           proj1 b1 c= b2
   holds ex b2 being Relation-like Function-like T-Sequence-like finite set st
      b1 c= b2;

:: AFINSQ_1:sch 1
scheme AFINSQ_1:sch 1
{F1 -> natural set}:
ex b1 being Relation-like Function-like T-Sequence-like finite set st
   dom b1 = F1() &
    (for b2 being Element of NAT
          st b2 in F1()
       holds P1[b2, b1 . b2])
provided
   for b1 being Element of NAT
   for b2, b3 being set
         st b1 in F1() & P1[b1, b2] & P1[b1, b3]
      holds b2 = b3
and
   for b1 being Element of NAT
         st b1 in F1()
      holds ex b2 being set st
         P1[b1, b2];


:: AFINSQ_1:sch 2
scheme AFINSQ_1:sch 2
{F1 -> natural set,
  F2 -> set}:
ex b1 being Relation-like Function-like T-Sequence-like finite set st
   len b1 = F1() &
    (for b2 being Element of NAT
          st b2 in F1()
       holds b1 . b2 = F2(b2))


:: AFINSQ_1:th 9
theorem
for b1 being set
for b2 being Relation-like Function-like T-Sequence-like finite set
      st b1 in b2
   holds ex b3 being Element of NAT st
      b3 in dom b2 & b1 = [b3,b2 . b3];

:: AFINSQ_1:th 10
theorem
for b1, b2 being Relation-like Function-like T-Sequence-like finite set
      st dom b1 = dom b2 &
         (for b3 being Element of NAT
               st b3 in dom b1
            holds b1 . b3 = b2 . b3)
   holds b1 = b2;

:: AFINSQ_1:th 11
theorem
for b1, b2 being Relation-like Function-like T-Sequence-like finite set
      st len b1 = len b2 &
         (for b3 being Element of NAT
               st b3 < len b1
            holds b1 . b3 = b2 . b3)
   holds b1 = b2;

:: AFINSQ_1:th 12
theorem
for b1 being Element of NAT
for b2 being Relation-like Function-like T-Sequence-like finite set holds
   b2 | b1 is Relation-like Function-like T-Sequence-like finite set;

:: AFINSQ_1:th 13
theorem
for b1 being Relation-like Function-like set
for b2 being Relation-like Function-like T-Sequence-like finite set
      st proj2 b2 c= proj1 b1
   holds b2 * b1 is Relation-like Function-like T-Sequence-like finite set;

:: AFINSQ_1:th 14
theorem
for b1 being Element of NAT
for b2, b3 being Relation-like Function-like T-Sequence-like finite set
      st b1 < len b2 & b3 = b2 | b1
   holds len b3 = b1 & dom b3 = b1;

:: AFINSQ_1:exreg 2
registration
  let a1 be set;
  cluster Relation-like Function-like T-Sequence-like finite T-Sequence of a1;
end;

:: AFINSQ_1:modenot 2
definition
  let a1 be set;
  mode XFinSequence of a1 is finite T-Sequence of a1;
end;

:: AFINSQ_1:th 15
theorem
for b1 being set
for b2 being finite T-Sequence of b1 holds
   b2 is Function-like Relation of NAT,b1;

:: AFINSQ_1:funcreg 2
registration
  cluster {} -> T-Sequence-like;
end;

:: AFINSQ_1:exreg 3
registration
  let a1 be set;
  cluster Relation-like Function-like T-Sequence-like finite Relation of NAT,a1;
end;

:: AFINSQ_1:th 16
theorem
for b1 being Element of NAT
for b2 being set
for b3 being finite T-Sequence of b2 holds
   b3 | b1 is finite T-Sequence of b2;

:: AFINSQ_1:th 17
theorem
for b1 being Element of NAT
for b2 being non empty set holds
   ex b3 being finite T-Sequence of b2 st
      len b3 = b1;

:: AFINSQ_1:exreg 4
registration
  cluster Relation-like Function-like T-Sequence-like empty finite set;
end;

:: AFINSQ_1:th 18
theorem
for b1 being Relation-like Function-like T-Sequence-like finite set holds
      len b1 = 0
   iff
      b1 = {};

:: AFINSQ_1:th 19
theorem
for b1 being set holds
   {} is finite T-Sequence of b1;

:: AFINSQ_1:exreg 5
registration
  let a1 be set;
  cluster Relation-like Function-like T-Sequence-like empty finite T-Sequence of a1;
end;

:: AFINSQ_1:funcnot 4 => AFINSQ_1:func 3
definition
  let a1 be set;
  func <%A1%> -> set equals
    {[0,a1]};
end;

:: AFINSQ_1:def 2
theorem
for b1 being set holds
   <%b1%> = {[0,b1]};

:: AFINSQ_1:funcreg 3
registration
  let a1 be set;
  cluster <%a1%> -> non empty;
end;

:: AFINSQ_1:funcnot 5 => AFINSQ_1:func 4
definition
  let a1 be set;
  func <%> A1 -> finite T-Sequence of a1 equals
    {};
end;

:: AFINSQ_1:def 3
theorem
for b1 being set holds
   <%> b1 = {};

:: AFINSQ_1:funcreg 4
registration
  let a1 be set;
  cluster <%> a1 -> empty finite;
end;

:: AFINSQ_1:funcnot 6 => ORDINAL4:func 1
definition
  let a1, a2 be Relation-like Function-like T-Sequence-like set;
  func A1 ^ A2 -> Relation-like Function-like T-Sequence-like set means
    proj1 it = (len a1) + len a2 &
     (for b1 being Element of NAT
           st b1 in dom a1
        holds it . b1 = a1 . b1) &
     (for b1 being Element of NAT
           st b1 in dom a2
        holds it . ((len a1) + b1) = a2 . b1);
end;

:: AFINSQ_1:def 4
theorem
for b1, b2 being Relation-like Function-like T-Sequence-like finite set
for b3 being Relation-like Function-like T-Sequence-like set holds
      b3 = b1 ^ b2
   iff
      proj1 b3 = (len b1) + len b2 &
       (for b4 being Element of NAT
             st b4 in dom b1
          holds b3 . b4 = b1 . b4) &
       (for b4 being Element of NAT
             st b4 in dom b2
          holds b3 . ((len b1) + b4) = b2 . b4);

:: AFINSQ_1:funcreg 5
registration
  let a1, a2 be Relation-like Function-like T-Sequence-like finite set;
  cluster a1 ^ a2 -> Relation-like Function-like T-Sequence-like finite;
end;

:: AFINSQ_1:th 20
theorem
for b1, b2 being Relation-like Function-like T-Sequence-like finite set holds
len (b1 ^ b2) = (len b1) + len b2;

:: AFINSQ_1:th 21
theorem
for b1 being Element of NAT
for b2, b3 being Relation-like Function-like T-Sequence-like finite set
      st len b2 <= b1 & b1 < (len b2) + len b3
   holds (b2 ^ b3) . b1 = b3 . (b1 - len b2);

:: AFINSQ_1:th 22
theorem
for b1 being Element of NAT
for b2, b3 being Relation-like Function-like T-Sequence-like finite set
      st len b2 <= b1 & b1 < len (b2 ^ b3)
   holds (b2 ^ b3) . b1 = b3 . (b1 - len b2);

:: AFINSQ_1:th 23
theorem
for b1 being Element of NAT
for b2, b3 being Relation-like Function-like T-Sequence-like finite set
      st b1 in dom (b2 ^ b3) & not b1 in dom b2
   holds ex b4 being Element of NAT st
      b4 in dom b3 & b1 = (len b2) + b4;

:: AFINSQ_1:th 24
theorem
for b1, b2 being Relation-like Function-like T-Sequence-like set holds
proj1 b1 c= proj1 (b1 ^ b2);

:: AFINSQ_1:th 25
theorem
for b1 being set
for b2, b3 being Relation-like Function-like T-Sequence-like finite set
      st b1 in dom b2
   holds ex b4 being Element of NAT st
      b4 = b1 & (len b3) + b4 in dom (b3 ^ b2);

:: AFINSQ_1:th 26
theorem
for b1 being Element of NAT
for b2, b3 being Relation-like Function-like T-Sequence-like finite set
      st b1 in dom b2
   holds (len b3) + b1 in dom (b3 ^ b2);

:: AFINSQ_1:th 27
theorem
for b1, b2 being Relation-like Function-like T-Sequence-like finite set holds
proj2 b1 c= proj2 (b1 ^ b2);

:: AFINSQ_1:th 28
theorem
for b1, b2 being Relation-like Function-like T-Sequence-like finite set holds
proj2 b1 c= proj2 (b2 ^ b1);

:: AFINSQ_1:th 29
theorem
for b1, b2 being Relation-like Function-like T-Sequence-like finite set holds
proj2 (b1 ^ b2) = (proj2 b1) \/ proj2 b2;

:: AFINSQ_1:th 30
theorem
for b1, b2, b3 being Relation-like Function-like T-Sequence-like finite set holds
(b1 ^ b2) ^ b3 = b1 ^ (b2 ^ b3);

:: AFINSQ_1:th 31
theorem
for b1, b2, b3 being Relation-like Function-like T-Sequence-like finite set
      st (b1 ^ b2 = b3 ^ b2 or b2 ^ b1 = b2 ^ b3)
   holds b1 = b3;

:: AFINSQ_1:th 32
theorem
for b1 being Relation-like Function-like T-Sequence-like finite set holds
   b1 ^ {} = b1 & {} ^ b1 = b1;

:: AFINSQ_1:th 33
theorem
for b1, b2 being Relation-like Function-like T-Sequence-like finite set
      st b1 ^ b2 = {}
   holds b1 = {} & b2 = {};

:: AFINSQ_1:funcnot 7 => AFINSQ_1:func 5
definition
  let a1 be set;
  let a2, a3 be finite T-Sequence of a1;
  redefine func a2 ^ a3 -> T-Sequence of a1;
end;

:: AFINSQ_1:funcnot 8 => AFINSQ_1:func 6
definition
  let a1 be set;
  redefine func <%A1%> -> Relation-like Function-like set means
    proj1 it = 1 & it . 0 = a1;
end;

:: AFINSQ_1:def 5
theorem
for b1 being set
for b2 being Relation-like Function-like set holds
      b2 = <%b1%>
   iff
      proj1 b2 = 1 & b2 . 0 = b1;

:: AFINSQ_1:funcreg 6
registration
  let a1 be set;
  cluster <%a1%> -> Relation-like Function-like;
end;

:: AFINSQ_1:funcreg 7
registration
  let a1 be set;
  cluster <%a1%> -> T-Sequence-like finite;
end;

:: AFINSQ_1:th 34
theorem
for b1, b2 being Relation-like Function-like T-Sequence-like finite set
for b3 being set
      st b1 ^ b2 is finite T-Sequence of b3
   holds b1 is finite T-Sequence of b3 & b2 is finite T-Sequence of b3;

:: AFINSQ_1:funcnot 9 => AFINSQ_1:func 7
definition
  let a1, a2 be set;
  func <%A1,A2%> -> set equals
    <%a1%> ^ <%a2%>;
end;

:: AFINSQ_1:def 6
theorem
for b1, b2 being set holds
<%b1,b2%> = <%b1%> ^ <%b2%>;

:: AFINSQ_1:funcnot 10 => AFINSQ_1:func 8
definition
  let a1, a2, a3 be set;
  func <%A1,A2,A3%> -> set equals
    (<%a1%> ^ <%a2%>) ^ <%a3%>;
end;

:: AFINSQ_1:def 7
theorem
for b1, b2, b3 being set holds
<%b1,b2,b3%> = (<%b1%> ^ <%b2%>) ^ <%b3%>;

:: AFINSQ_1:funcreg 8
registration
  let a1, a2 be set;
  cluster <%a1,a2%> -> Relation-like Function-like;
end;

:: AFINSQ_1:funcreg 9
registration
  let a1, a2, a3 be set;
  cluster <%a1,a2,a3%> -> Relation-like Function-like;
end;

:: AFINSQ_1:funcreg 10
registration
  let a1, a2 be set;
  cluster <%a1,a2%> -> T-Sequence-like finite;
end;

:: AFINSQ_1:funcreg 11
registration
  let a1, a2, a3 be set;
  cluster <%a1,a2,a3%> -> T-Sequence-like finite;
end;

:: AFINSQ_1:th 35
theorem
for b1 being set holds
   <%b1%> = {[0,b1]};

:: AFINSQ_1:th 36
theorem
for b1 being set
for b2 being Relation-like Function-like T-Sequence-like finite set holds
      b2 = <%b1%>
   iff
      dom b2 = 1 & proj2 b2 = {b1};

:: AFINSQ_1:th 37
theorem
for b1 being set
for b2 being Relation-like Function-like T-Sequence-like finite set holds
      b2 = <%b1%>
   iff
      len b2 = 1 & proj2 b2 = {b1};

:: AFINSQ_1:th 38
theorem
for b1 being set
for b2 being Relation-like Function-like T-Sequence-like finite set holds
      b2 = <%b1%>
   iff
      len b2 = 1 & b2 . 0 = b1;

:: AFINSQ_1:th 39
theorem
for b1 being set
for b2 being Relation-like Function-like T-Sequence-like finite set holds
   (<%b1%> ^ b2) . 0 = b1;

:: AFINSQ_1:th 40
theorem
for b1 being set
for b2 being Relation-like Function-like T-Sequence-like finite set holds
   (b2 ^ <%b1%>) . len b2 = b1;

:: AFINSQ_1:th 41
theorem
for b1, b2, b3 being set holds
<%b1,b2,b3%> = <%b1%> ^ <%b2,b3%> &
 <%b1,b2,b3%> = <%b1,b2%> ^ <%b3%>;

:: AFINSQ_1:th 42
theorem
for b1, b2 being set
for b3 being Relation-like Function-like T-Sequence-like finite set holds
      b3 = <%b1,b2%>
   iff
      len b3 = 2 & b3 . 0 = b1 & b3 . 1 = b2;

:: AFINSQ_1:th 43
theorem
for b1, b2, b3 being set
for b4 being Relation-like Function-like T-Sequence-like finite set holds
      b4 = <%b1,b2,b3%>
   iff
      len b4 = 3 & b4 . 0 = b1 & b4 . 1 = b2 & b4 . 2 = b3;

:: AFINSQ_1:th 44
theorem
for b1 being Relation-like Function-like T-Sequence-like finite set
      st b1 <> {}
   holds ex b2 being Relation-like Function-like T-Sequence-like finite set st
      ex b3 being set st
         b1 = b2 ^ <%b3%>;

:: AFINSQ_1:funcnot 11 => AFINSQ_1:func 9
definition
  let a1 be non empty set;
  let a2 be Element of a1;
  redefine func <%a2%> -> finite T-Sequence of a1;
end;

:: AFINSQ_1:sch 3
scheme AFINSQ_1:sch 3
for b1 being Relation-like Function-like T-Sequence-like finite set holds
   P1[b1]
provided
   P1[{}]
and
   for b1 being Relation-like Function-like T-Sequence-like finite set
   for b2 being set
         st P1[b1]
      holds P1[b1 ^ <%b2%>];


:: AFINSQ_1:th 45
theorem
for b1, b2, b3, b4 being Relation-like Function-like T-Sequence-like finite set
      st b1 ^ b2 = b3 ^ b4 & len b1 <= len b3
   holds ex b5 being Relation-like Function-like T-Sequence-like finite set st
      b1 ^ b5 = b3;

:: AFINSQ_1:funcnot 12 => AFINSQ_1:func 10
definition
  let a1 be set;
  func A1 ^omega -> set means
    for b1 being set holds
          b1 in it
       iff
          b1 is finite T-Sequence of a1;
end;

:: AFINSQ_1:def 8
theorem
for b1, b2 being set holds
   b2 = b1 ^omega
iff
   for b3 being set holds
         b3 in b2
      iff
         b3 is finite T-Sequence of b1;

:: AFINSQ_1:funcreg 12
registration
  let a1 be set;
  cluster a1 ^omega -> non empty;
end;

:: AFINSQ_1:th 46
theorem
for b1, b2 being set holds
   b1 in b2 ^omega
iff
   b1 is finite T-Sequence of b2;

:: AFINSQ_1:th 47
theorem
for b1 being set holds
   {} in b1 ^omega;

:: AFINSQ_1:sch 4
scheme AFINSQ_1:sch 4
{F1 -> non empty set}:
ex b1 being set st
   for b2 being set holds
         b2 in b1
      iff
         ex b3 being Relation-like Function-like T-Sequence-like finite set st
            b3 in F1() ^omega & P1[b3] & b2 = b3


:: AFINSQ_1:funcnot 13 => FUNCT_7:func 2
notation
  let a1 be Relation-like Function-like T-Sequence-like finite set;
  let a2, a3 be set;
  synonym Replace(a1,a2,a3) for a1 +*(a2,a3);
end;

:: AFINSQ_1:funcreg 13
registration
  let a1 be Relation-like Function-like T-Sequence-like finite set;
  let a2, a3 be set;
  cluster a1 +*(a2,a3) -> Relation-like Function-like T-Sequence-like finite;
end;

:: AFINSQ_1:th 48
theorem
for b1 being Relation-like Function-like T-Sequence-like finite set
for b2 being Element of NAT
for b3 being set holds
   len (b1 +*(b2,b3)) = len b1 &
    (len b1 <= b2 or (b1 +*(b2,b3)) . b2 = b3) &
    (for b4 being Element of NAT
          st b4 <> b2
       holds (b1 +*(b2,b3)) . b4 = b1 . b4);

:: AFINSQ_1:funcnot 14 => AFINSQ_1:func 11
definition
  let a1 be non empty set;
  let a2 be finite T-Sequence of a1;
  let a3 be Element of NAT;
  let a4 be Element of a1;
  redefine func Replace(a2,a3,a4) -> finite T-Sequence of a1;
end;

:: AFINSQ_1:funcreg 14
registration
  let a1, a2 be set;
  cluster [a1,a2] -> non natural;
end;

:: AFINSQ_1:condreg 1
registration
  cluster finite -> real-valued (T-Sequence of REAL);
end;

:: AFINSQ_1:condreg 2
registration
  cluster finite -> natural-valued (T-Sequence of NAT);
end;