Article RECDEF_1, MML version 4.99.1005

:: RECDEF_1:funcnot 1 => RECDEF_1:func 1
definition
  let a1 be Relation-like Function-like natural-valued set;
  let a2 be set;
  redefine func a1 . a2 -> Element of NAT;
end;

:: RECDEF_1:sch 1
scheme RECDEF_1:sch 1
{F1 -> set}:
ex b1 being Relation-like Function-like set st
   proj1 b1 = NAT &
    b1 . 0 = F1() &
    (for b2 being Element of NAT holds
       P1[b2, b1 . b2, b1 . (b2 + 1)])
provided
   for b1 being Element of NAT
   for b2 being set holds
      ex b3 being set st
         P1[b1, b2, b3]
and
   for b1 being Element of NAT
   for b2, b3, b4 being set
         st P1[b1, b2, b3] & P1[b1, b2, b4]
      holds b3 = b4;


:: RECDEF_1:sch 2
scheme RECDEF_1:sch 2
{F1 -> non empty set,
  F2 -> Element of F1()}:
ex b1 being Function-like quasi_total Relation of NAT,F1() st
   b1 . 0 = F2() &
    (for b2 being Element of NAT holds
       P1[b2, b1 . b2, b1 . (b2 + 1)])
provided
   for b1 being Element of NAT
   for b2 being Element of F1() holds
      ex b3 being Element of F1() st
         P1[b1, b2, b3];


:: RECDEF_1:sch 3
scheme RECDEF_1:sch 3
{F1 -> set,
  F2 -> Element of NAT}:
ex b1 being Relation-like Function-like FinSequence-like set st
   len b1 = F2() &
    (b1 . 1 = F1() or F2() = 0) &
    (for b2 being Element of NAT
          st 1 <= b2 & b2 < F2()
       holds P1[b2, b1 . b2, b1 . (b2 + 1)])
provided
   for b1 being Element of NAT
      st 1 <= b1 & b1 < F2()
   for b2 being set holds
      ex b3 being set st
         P1[b1, b2, b3]
and
   for b1 being Element of NAT
      st 1 <= b1 & b1 < F2()
   for b2, b3, b4 being set
         st P1[b1, b2, b3] & P1[b1, b2, b4]
      holds b3 = b4;


:: RECDEF_1:sch 4
scheme RECDEF_1:sch 4
{F1 -> non empty set,
  F2 -> Element of F1(),
  F3 -> Element of NAT}:
ex b1 being FinSequence of F1() st
   len b1 = F3() &
    (b1 . 1 = F2() or F3() = 0) &
    (for b2 being Element of NAT
          st 1 <= b2 & b2 < F3()
       holds P1[b2, b1 . b2, b1 . (b2 + 1)])
provided
   for b1 being Element of NAT
      st 1 <= b1 & b1 < F3()
   for b2 being Element of F1() holds
      ex b3 being Element of F1() st
         P1[b1, b2, b3];


:: RECDEF_1:sch 5
scheme RECDEF_1:sch 5
{F1 -> Relation-like Function-like FinSequence-like set}:
ex b1 being set st
   ex b2 being Relation-like Function-like FinSequence-like set st
      b1 = b2 . len b2 &
       len b2 = len F1() &
       b2 . 1 = F1() . 1 &
       (for b3 being Element of NAT
             st 1 <= b3 & b3 < len F1()
          holds P1[F1() . (b3 + 1), b2 . b3, b2 . (b3 + 1)])
provided
   for b1 being Element of NAT
   for b2 being set
         st 1 <= b1 & b1 < len F1()
      holds ex b3 being set st
         P1[F1() . (b1 + 1), b2, b3]
and
   for b1 being Element of NAT
   for b2, b3, b4, b5 being set
         st 1 <= b1 & b1 < len F1() & b5 = F1() . (b1 + 1) & P1[b5, b2, b3] & P1[b5, b2, b4]
      holds b3 = b4;


:: RECDEF_1:sch 6
scheme RECDEF_1:sch 6
{F1 -> Relation-like Function-like FinSequence-like set,
  F2 -> set}:
ex b1 being set st
   ex b2 being Relation-like Function-like FinSequence-like set st
      b1 = b2 . len b2 &
       len b2 = len F1() &
       b2 . 1 = F1() . 1 &
       (for b3 being Element of NAT
             st 1 <= b3 & b3 < len F1()
          holds b2 . (b3 + 1) = F2(F1() . (b3 + 1), b2 . b3))


:: RECDEF_1:sch 7
scheme RECDEF_1:sch 7
{F1 -> set,
  F2 -> Element of NAT,
  F3 -> Relation-like Function-like FinSequence-like set,
  F4 -> Relation-like Function-like FinSequence-like set}:
F3() = F4()
provided
   for b1 being Element of NAT
      st 1 <= b1 & b1 < F2()
   for b2, b3, b4 being set
         st P1[b1, b2, b3] & P1[b1, b2, b4]
      holds b3 = b4
and
   len F3() = F2() &
    (F3() . 1 = F1() or F2() = 0) &
    (for b1 being Element of NAT
          st 1 <= b1 & b1 < F2()
       holds P1[b1, F3() . b1, F3() . (b1 + 1)])
and
   len F4() = F2() &
    (F4() . 1 = F1() or F2() = 0) &
    (for b1 being Element of NAT
          st 1 <= b1 & b1 < F2()
       holds P1[b1, F4() . b1, F4() . (b1 + 1)]);


:: RECDEF_1:sch 8
scheme RECDEF_1:sch 8
{F1 -> non empty set,
  F2 -> Element of F1(),
  F3 -> Element of NAT,
  F4 -> FinSequence of F1(),
  F5 -> FinSequence of F1()}:
F4() = F5()
provided
   for b1 being Element of NAT
      st 1 <= b1 & b1 < F3()
   for b2, b3, b4 being Element of F1()
         st P1[b1, b2, b3] & P1[b1, b2, b4]
      holds b3 = b4
and
   len F4() = F3() &
    (F4() . 1 = F2() or F3() = 0) &
    (for b1 being Element of NAT
          st 1 <= b1 & b1 < F3()
       holds P1[b1, F4() . b1, F4() . (b1 + 1)])
and
   len F5() = F3() &
    (F5() . 1 = F2() or F3() = 0) &
    (for b1 being Element of NAT
          st 1 <= b1 & b1 < F3()
       holds P1[b1, F5() . b1, F5() . (b1 + 1)]);


:: RECDEF_1:sch 9
scheme RECDEF_1:sch 9
{F1 -> Relation-like Function-like FinSequence-like set,
  F2 -> set,
  F3 -> set}:
F2() = F3()
provided
   for b1 being Element of NAT
   for b2, b3, b4, b5 being set
         st 1 <= b1 & b1 < len F1() & b5 = F1() . (b1 + 1) & P1[b5, b2, b3] & P1[b5, b2, b4]
      holds b3 = b4
and
   ex b1 being Relation-like Function-like FinSequence-like set st
      F2() = b1 . len b1 &
       len b1 = len F1() &
       b1 . 1 = F1() . 1 &
       (for b2 being Element of NAT
             st 1 <= b2 & b2 < len F1()
          holds P1[F1() . (b2 + 1), b1 . b2, b1 . (b2 + 1)])
and
   ex b1 being Relation-like Function-like FinSequence-like set st
      F3() = b1 . len b1 &
       len b1 = len F1() &
       b1 . 1 = F1() . 1 &
       (for b2 being Element of NAT
             st 1 <= b2 & b2 < len F1()
          holds P1[F1() . (b2 + 1), b1 . b2, b1 . (b2 + 1)]);


:: RECDEF_1:sch 10
scheme RECDEF_1:sch 10
{F1 -> Relation-like Function-like FinSequence-like set,
  F2 -> set,
  F3 -> set,
  F4 -> set}:
F3() = F4()
provided
   ex b1 being Relation-like Function-like FinSequence-like set st
      F3() = b1 . len b1 &
       len b1 = len F1() &
       b1 . 1 = F1() . 1 &
       (for b2 being Element of NAT
             st 1 <= b2 & b2 < len F1()
          holds b1 . (b2 + 1) = F2(F1() . (b2 + 1), b1 . b2))
and
   ex b1 being Relation-like Function-like FinSequence-like set st
      F4() = b1 . len b1 &
       len b1 = len F1() &
       b1 . 1 = F1() . 1 &
       (for b2 being Element of NAT
             st 1 <= b2 & b2 < len F1()
          holds b1 . (b2 + 1) = F2(F1() . (b2 + 1), b1 . b2));


:: RECDEF_1:sch 11
scheme RECDEF_1:sch 11
{F1 -> set,
  F2 -> Element of NAT}:
(ex b1 being set st
    ex b2 being Relation-like Function-like set st
       b1 = b2 . F2() &
        proj1 b2 = NAT &
        b2 . 0 = F1() &
        (for b3 being Element of NAT holds
           P1[b3, b2 . b3, b2 . (b3 + 1)])) &
 (for b1, b2 being set
       st (ex b3 being Relation-like Function-like set st
             b1 = b3 . F2() &
              proj1 b3 = NAT &
              b3 . 0 = F1() &
              (for b4 being Element of NAT holds
                 P1[b4, b3 . b4, b3 . (b4 + 1)])) &
          (ex b3 being Relation-like Function-like set st
             b2 = b3 . F2() &
              proj1 b3 = NAT &
              b3 . 0 = F1() &
              (for b4 being Element of NAT holds
                 P1[b4, b3 . b4, b3 . (b4 + 1)]))
    holds b1 = b2)
provided
   for b1 being Element of NAT
   for b2 being set holds
      ex b3 being set st
         P1[b1, b2, b3]
and
   for b1 being Element of NAT
   for b2, b3, b4 being set
         st P1[b1, b2, b3] & P1[b1, b2, b4]
      holds b3 = b4;


:: RECDEF_1:sch 12
scheme RECDEF_1:sch 12
{F1 -> set,
  F2 -> Element of NAT,
  F3 -> set}:
(ex b1 being set st
    ex b2 being Relation-like Function-like set st
       b1 = b2 . F2() &
        proj1 b2 = NAT &
        b2 . 0 = F1() &
        (for b3 being Element of NAT holds
           b2 . (b3 + 1) = F3(b3, b2 . b3))) &
 (for b1, b2 being set
       st (ex b3 being Relation-like Function-like set st
             b1 = b3 . F2() &
              proj1 b3 = NAT &
              b3 . 0 = F1() &
              (for b4 being Element of NAT holds
                 b3 . (b4 + 1) = F3(b4, b3 . b4))) &
          (ex b3 being Relation-like Function-like set st
             b2 = b3 . F2() &
              proj1 b3 = NAT &
              b3 . 0 = F1() &
              (for b4 being Element of NAT holds
                 b3 . (b4 + 1) = F3(b4, b3 . b4)))
    holds b1 = b2)


:: RECDEF_1:sch 13
scheme RECDEF_1:sch 13
{F1 -> non empty set,
  F2 -> Element of F1(),
  F3 -> natural set}:
(ex b1 being Element of F1() st
    ex b2 being Function-like quasi_total Relation of NAT,F1() st
       b1 = b2 . F3() &
        b2 . 0 = F2() &
        (for b3 being Element of NAT holds
           P1[b3, b2 . b3, b2 . (b3 + 1)])) &
 (for b1, b2 being Element of F1()
       st (ex b3 being Function-like quasi_total Relation of NAT,F1() st
             b1 = b3 . F3() &
              b3 . 0 = F2() &
              (for b4 being Element of NAT holds
                 P1[b4, b3 . b4, b3 . (b4 + 1)])) &
          (ex b3 being Function-like quasi_total Relation of NAT,F1() st
             b2 = b3 . F3() &
              b3 . 0 = F2() &
              (for b4 being Element of NAT holds
                 P1[b4, b3 . b4, b3 . (b4 + 1)]))
    holds b1 = b2)
provided
   for b1 being Element of NAT
   for b2 being Element of F1() holds
      ex b3 being Element of F1() st
         P1[b1, b2, b3]
and
   for b1 being Element of NAT
   for b2, b3, b4 being Element of F1()
         st P1[b1, b2, b3] & P1[b1, b2, b4]
      holds b3 = b4;


:: RECDEF_1:sch 14
scheme RECDEF_1:sch 14
{F1 -> non empty set,
  F2 -> Element of F1(),
  F3 -> natural set,
  F4 -> Element of F1()}:
(ex b1 being Element of F1() st
    ex b2 being Function-like quasi_total Relation of NAT,F1() st
       b1 = b2 . F3() &
        b2 . 0 = F2() &
        (for b3 being natural set holds
           b2 . (b3 + 1) = F4(b3, b2 . b3))) &
 (for b1, b2 being Element of F1()
       st (ex b3 being Function-like quasi_total Relation of NAT,F1() st
             b1 = b3 . F3() &
              b3 . 0 = F2() &
              (for b4 being natural set holds
                 b3 . (b4 + 1) = F4(b4, b3 . b4))) &
          (ex b3 being Function-like quasi_total Relation of NAT,F1() st
             b2 = b3 . F3() &
              b3 . 0 = F2() &
              (for b4 being natural set holds
                 b3 . (b4 + 1) = F4(b4, b3 . b4)))
    holds b1 = b2)


:: RECDEF_1:sch 15
scheme RECDEF_1:sch 15
{F1 -> Relation-like Function-like FinSequence-like set}:
(ex b1 being set st
    ex b2 being Relation-like Function-like FinSequence-like set st
       b1 = b2 . len b2 &
        len b2 = len F1() &
        b2 . 1 = F1() . 1 &
        (for b3 being Element of NAT
              st 1 <= b3 & b3 < len F1()
           holds P1[F1() . (b3 + 1), b2 . b3, b2 . (b3 + 1)])) &
 (for b1, b2 being set
       st (ex b3 being Relation-like Function-like FinSequence-like set st
             b1 = b3 . len b3 &
              len b3 = len F1() &
              b3 . 1 = F1() . 1 &
              (for b4 being Element of NAT
                    st 1 <= b4 & b4 < len F1()
                 holds P1[F1() . (b4 + 1), b3 . b4, b3 . (b4 + 1)])) &
          (ex b3 being Relation-like Function-like FinSequence-like set st
             b2 = b3 . len b3 &
              len b3 = len F1() &
              b3 . 1 = F1() . 1 &
              (for b4 being Element of NAT
                    st 1 <= b4 & b4 < len F1()
                 holds P1[F1() . (b4 + 1), b3 . b4, b3 . (b4 + 1)]))
    holds b1 = b2)
provided
   for b1 being Element of NAT
   for b2 being set
         st 1 <= b1 & b1 < len F1()
      holds ex b3 being set st
         P1[F1() . (b1 + 1), b2, b3]
and
   for b1 being Element of NAT
   for b2, b3, b4, b5 being set
         st 1 <= b1 & b1 < len F1() & b5 = F1() . (b1 + 1) & P1[b5, b2, b3] & P1[b5, b2, b4]
      holds b3 = b4;


:: RECDEF_1:sch 16
scheme RECDEF_1:sch 16
{F1 -> Relation-like Function-like FinSequence-like set,
  F2 -> set}:
(ex b1 being set st
    ex b2 being Relation-like Function-like FinSequence-like set st
       b1 = b2 . len b2 &
        len b2 = len F1() &
        b2 . 1 = F1() . 1 &
        (for b3 being Element of NAT
              st 1 <= b3 & b3 < len F1()
           holds b2 . (b3 + 1) = F2(F1() . (b3 + 1), b2 . b3))) &
 (for b1, b2 being set
       st (ex b3 being Relation-like Function-like FinSequence-like set st
             b1 = b3 . len b3 &
              len b3 = len F1() &
              b3 . 1 = F1() . 1 &
              (for b4 being Element of NAT
                    st 1 <= b4 & b4 < len F1()
                 holds b3 . (b4 + 1) = F2(F1() . (b4 + 1), b3 . b4))) &
          (ex b3 being Relation-like Function-like FinSequence-like set st
             b2 = b3 . len b3 &
              len b3 = len F1() &
              b3 . 1 = F1() . 1 &
              (for b4 being Element of NAT
                    st 1 <= b4 & b4 < len F1()
                 holds b3 . (b4 + 1) = F2(F1() . (b4 + 1), b3 . b4)))
    holds b1 = b2)