Article RECDEF_2, MML version 4.99.1005

:: RECDEF_2:funcnot 1 => RECDEF_2:func 1
definition
  let a1 be set;
  assume ex b1, b2, b3 being set st
       a1 = [b1,b2,b3];
  func A1 `1_3 -> set means
    for b1, b2, b3 being set
          st a1 = [b1,b2,b3]
       holds it = b1;
end;

:: RECDEF_2:def 1
theorem
for b1 being set
   st ex b2, b3, b4 being set st
        b1 = [b2,b3,b4]
for b2 being set holds
      b2 = b1 `1_3
   iff
      for b3, b4, b5 being set
            st b1 = [b3,b4,b5]
         holds b2 = b3;

:: RECDEF_2:funcnot 2 => RECDEF_2:func 2
definition
  let a1 be set;
  assume ex b1, b2, b3 being set st
       a1 = [b1,b2,b3];
  func A1 `2_3 -> set means
    for b1, b2, b3 being set
          st a1 = [b1,b2,b3]
       holds it = b2;
end;

:: RECDEF_2:def 2
theorem
for b1 being set
   st ex b2, b3, b4 being set st
        b1 = [b2,b3,b4]
for b2 being set holds
      b2 = b1 `2_3
   iff
      for b3, b4, b5 being set
            st b1 = [b3,b4,b5]
         holds b2 = b4;

:: RECDEF_2:funcnot 3 => RECDEF_2:func 3
definition
  let a1 be set;
  assume ex b1, b2, b3 being set st
       a1 = [b1,b2,b3];
  func A1 `3_3 -> set means
    for b1, b2, b3 being set
          st a1 = [b1,b2,b3]
       holds it = b3;
end;

:: RECDEF_2:def 3
theorem
for b1 being set
   st ex b2, b3, b4 being set st
        b1 = [b2,b3,b4]
for b2 being set holds
      b2 = b1 `3_3
   iff
      for b3, b4, b5 being set
            st b1 = [b3,b4,b5]
         holds b2 = b5;

:: RECDEF_2:th 1
theorem
for b1 being set
      st ex b2, b3, b4 being set st
           b1 = [b2,b3,b4]
   holds b1 = [b1 `1_3,b1 `2_3,b1 `3_3];

:: RECDEF_2:th 2
theorem
for b1, b2, b3, b4 being set
      st b1 in [:b2,b3,b4:]
   holds b1 `1_3 in b2 & b1 `2_3 in b3 & b1 `3_3 in b4;

:: RECDEF_2:th 3
theorem
for b1, b2, b3, b4 being set
      st b1 in [:b2,b3,b4:]
   holds b1 = [b1 `1_3,b1 `2_3,b1 `3_3];

:: RECDEF_2:funcnot 4 => RECDEF_2:func 4
definition
  let a1 be set;
  assume ex b1, b2, b3, b4 being set st
       a1 = [b1,b2,b3,b4];
  func A1 `1_4 -> set means
    for b1, b2, b3, b4 being set
          st a1 = [b1,b2,b3,b4]
       holds it = b1;
end;

:: RECDEF_2:def 4
theorem
for b1 being set
   st ex b2, b3, b4, b5 being set st
        b1 = [b2,b3,b4,b5]
for b2 being set holds
      b2 = b1 `1_4
   iff
      for b3, b4, b5, b6 being set
            st b1 = [b3,b4,b5,b6]
         holds b2 = b3;

:: RECDEF_2:funcnot 5 => RECDEF_2:func 5
definition
  let a1 be set;
  assume ex b1, b2, b3, b4 being set st
       a1 = [b1,b2,b3,b4];
  func A1 `2_4 -> set means
    for b1, b2, b3, b4 being set
          st a1 = [b1,b2,b3,b4]
       holds it = b2;
end;

:: RECDEF_2:def 5
theorem
for b1 being set
   st ex b2, b3, b4, b5 being set st
        b1 = [b2,b3,b4,b5]
for b2 being set holds
      b2 = b1 `2_4
   iff
      for b3, b4, b5, b6 being set
            st b1 = [b3,b4,b5,b6]
         holds b2 = b4;

:: RECDEF_2:funcnot 6 => RECDEF_2:func 6
definition
  let a1 be set;
  assume ex b1, b2, b3, b4 being set st
       a1 = [b1,b2,b3,b4];
  func A1 `3_4 -> set means
    for b1, b2, b3, b4 being set
          st a1 = [b1,b2,b3,b4]
       holds it = b3;
end;

:: RECDEF_2:def 6
theorem
for b1 being set
   st ex b2, b3, b4, b5 being set st
        b1 = [b2,b3,b4,b5]
for b2 being set holds
      b2 = b1 `3_4
   iff
      for b3, b4, b5, b6 being set
            st b1 = [b3,b4,b5,b6]
         holds b2 = b5;

:: RECDEF_2:funcnot 7 => RECDEF_2:func 7
definition
  let a1 be set;
  assume ex b1, b2, b3, b4 being set st
       a1 = [b1,b2,b3,b4];
  func A1 `4_4 -> set means
    for b1, b2, b3, b4 being set
          st a1 = [b1,b2,b3,b4]
       holds it = b4;
end;

:: RECDEF_2:def 7
theorem
for b1 being set
   st ex b2, b3, b4, b5 being set st
        b1 = [b2,b3,b4,b5]
for b2 being set holds
      b2 = b1 `4_4
   iff
      for b3, b4, b5, b6 being set
            st b1 = [b3,b4,b5,b6]
         holds b2 = b6;

:: RECDEF_2:th 4
theorem
for b1 being set
      st ex b2, b3, b4, b5 being set st
           b1 = [b2,b3,b4,b5]
   holds b1 = [b1 `1_4,b1 `2_4,b1 `3_4,b1 `4_4];

:: RECDEF_2:th 5
theorem
for b1, b2, b3, b4, b5 being set
      st b1 in [:b2,b3,b4,b5:]
   holds b1 `1_4 in b2 & b1 `2_4 in b3 & b1 `3_4 in b4 & b1 `4_4 in b5;

:: RECDEF_2:th 6
theorem
for b1, b2, b3, b4, b5 being set
      st b1 in [:b2,b3,b4,b5:]
   holds b1 = [b1 `1_4,b1 `2_4,b1 `3_4,b1 `4_4];

:: RECDEF_2:funcnot 8 => RECDEF_2:func 8
definition
  let a1 be set;
  assume ex b1, b2, b3, b4, b5 being set st
       a1 = [b1,b2,b3,b4,b5];
  func A1 `1_5 -> set means
    for b1, b2, b3, b4, b5 being set
          st a1 = [b1,b2,b3,b4,b5]
       holds it = b1;
end;

:: RECDEF_2:def 8
theorem
for b1 being set
   st ex b2, b3, b4, b5, b6 being set st
        b1 = [b2,b3,b4,b5,b6]
for b2 being set holds
      b2 = b1 `1_5
   iff
      for b3, b4, b5, b6, b7 being set
            st b1 = [b3,b4,b5,b6,b7]
         holds b2 = b3;

:: RECDEF_2:funcnot 9 => RECDEF_2:func 9
definition
  let a1 be set;
  assume ex b1, b2, b3, b4, b5 being set st
       a1 = [b1,b2,b3,b4,b5];
  func A1 `2_5 -> set means
    for b1, b2, b3, b4, b5 being set
          st a1 = [b1,b2,b3,b4,b5]
       holds it = b2;
end;

:: RECDEF_2:def 9
theorem
for b1 being set
   st ex b2, b3, b4, b5, b6 being set st
        b1 = [b2,b3,b4,b5,b6]
for b2 being set holds
      b2 = b1 `2_5
   iff
      for b3, b4, b5, b6, b7 being set
            st b1 = [b3,b4,b5,b6,b7]
         holds b2 = b4;

:: RECDEF_2:funcnot 10 => RECDEF_2:func 10
definition
  let a1 be set;
  assume ex b1, b2, b3, b4, b5 being set st
       a1 = [b1,b2,b3,b4,b5];
  func A1 `3_5 -> set means
    for b1, b2, b3, b4, b5 being set
          st a1 = [b1,b2,b3,b4,b5]
       holds it = b3;
end;

:: RECDEF_2:def 10
theorem
for b1 being set
   st ex b2, b3, b4, b5, b6 being set st
        b1 = [b2,b3,b4,b5,b6]
for b2 being set holds
      b2 = b1 `3_5
   iff
      for b3, b4, b5, b6, b7 being set
            st b1 = [b3,b4,b5,b6,b7]
         holds b2 = b5;

:: RECDEF_2:funcnot 11 => RECDEF_2:func 11
definition
  let a1 be set;
  assume ex b1, b2, b3, b4, b5 being set st
       a1 = [b1,b2,b3,b4,b5];
  func A1 `4_5 -> set means
    for b1, b2, b3, b4, b5 being set
          st a1 = [b1,b2,b3,b4,b5]
       holds it = b4;
end;

:: RECDEF_2:def 11
theorem
for b1 being set
   st ex b2, b3, b4, b5, b6 being set st
        b1 = [b2,b3,b4,b5,b6]
for b2 being set holds
      b2 = b1 `4_5
   iff
      for b3, b4, b5, b6, b7 being set
            st b1 = [b3,b4,b5,b6,b7]
         holds b2 = b6;

:: RECDEF_2:funcnot 12 => RECDEF_2:func 12
definition
  let a1 be set;
  assume ex b1, b2, b3, b4, b5 being set st
       a1 = [b1,b2,b3,b4,b5];
  func A1 `5_5 -> set means
    for b1, b2, b3, b4, b5 being set
          st a1 = [b1,b2,b3,b4,b5]
       holds it = b5;
end;

:: RECDEF_2:def 12
theorem
for b1 being set
   st ex b2, b3, b4, b5, b6 being set st
        b1 = [b2,b3,b4,b5,b6]
for b2 being set holds
      b2 = b1 `5_5
   iff
      for b3, b4, b5, b6, b7 being set
            st b1 = [b3,b4,b5,b6,b7]
         holds b2 = b7;

:: RECDEF_2:th 7
theorem
for b1 being set
      st ex b2, b3, b4, b5, b6 being set st
           b1 = [b2,b3,b4,b5,b6]
   holds b1 = [b1 `1_5,b1 `2_5,b1 `3_5,b1 `4_5,b1 `5_5];

:: RECDEF_2:th 8
theorem
for b1, b2, b3, b4, b5, b6 being set
      st b1 in [:b2,b3,b4,b5,b6:]
   holds b1 `1_5 in b2 & b1 `2_5 in b3 & b1 `3_5 in b4 & b1 `4_5 in b5 & b1 `5_5 in b6;

:: RECDEF_2:th 9
theorem
for b1, b2, b3, b4, b5, b6 being set
      st b1 in [:b2,b3,b4,b5,b6:]
   holds b1 = [b1 `1_5,b1 `2_5,b1 `3_5,b1 `4_5,b1 `5_5];

:: RECDEF_2:sch 1
scheme RECDEF_2:sch 1
{F1 -> set,
  F2 -> set,
  F3 -> set,
  F4 -> set}:
ex b1 being Relation-like Function-like set st
   proj1 b1 = F1() &
    (for b2 being set
          st b2 in F1()
       holds (P1[b2] implies b1 . b2 = F2(b2)) & (P2[b2] implies b1 . b2 = F3(b2)) & (P3[b2] implies b1 . b2 = F4(b2)))
provided
   for b1 being set
         st b1 in F1()
      holds (P1[b1] implies not (P2[b1])) & (P1[b1] implies not (P3[b1])) & (P2[b1] implies not (P3[b1]))
and
   for b1 being set
         st b1 in F1() & not (P1[b1]) & not (P2[b1])
      holds P3[b1];


:: RECDEF_2:sch 2
scheme RECDEF_2:sch 2
{F1 -> set,
  F2 -> set,
  F3 -> set,
  F4 -> set,
  F5 -> set}:
ex b1 being Relation-like Function-like set st
   proj1 b1 = F1() &
    (for b2 being set
          st b2 in F1()
       holds (P1[b2] implies b1 . b2 = F2(b2)) & (P2[b2] implies b1 . b2 = F3(b2)) & (P3[b2] implies b1 . b2 = F4(b2)) & (P4[b2] implies b1 . b2 = F5(b2)))
provided
   for b1 being set
         st b1 in F1()
      holds (P1[b1] implies not (P2[b1])) & (P1[b1] implies not (P3[b1])) & (P1[b1] implies not (P4[b1])) & (P2[b1] implies not (P3[b1])) & (P2[b1] implies not (P4[b1])) & (P3[b1] implies not (P4[b1]))
and
   for b1 being set
         st b1 in F1() & not (P1[b1]) & not (P2[b1]) & not (P3[b1])
      holds P4[b1];


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


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


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


:: RECDEF_2:sch 6
scheme RECDEF_2:sch 6
{F1 -> set,
  F2 -> set,
  F3 -> Relation-like Function-like set,
  F4 -> Relation-like Function-like set,
  F5 -> set}:
F3() = F4()
provided
   proj1 F3() = NAT
and
   F3() . 0 = F1() & F3() . 1 = F2()
and
   for b1 being Element of NAT holds
      F3() . (b1 + 2) = F5(b1, F3() . b1, F3() . (b1 + 1))
and
   proj1 F4() = NAT
and
   F4() . 0 = F1() & F4() . 1 = F2()
and
   for b1 being Element of NAT holds
      F4() . (b1 + 2) = F5(b1, F4() . b1, F4() . (b1 + 1));


:: RECDEF_2:sch 7
scheme RECDEF_2:sch 7
{F1 -> non empty set,
  F2 -> Element of F1(),
  F3 -> Element of F1(),
  F4 -> Function-like quasi_total Relation of NAT,F1(),
  F5 -> Function-like quasi_total Relation of NAT,F1(),
  F6 -> Element of F1()}:
F4() = F5()
provided
   F4() . 0 = F2() & F4() . 1 = F3()
and
   for b1 being Element of NAT holds
      F4() . (b1 + 2) = F6(b1, F4() . b1, F4() . (b1 + 1))
and
   F5() . 0 = F2() & F5() . 1 = F3()
and
   for b1 being Element of NAT holds
      F5() . (b1 + 2) = F6(b1, F5() . b1, F5() . (b1 + 1));


:: RECDEF_2:sch 8
scheme RECDEF_2:sch 8
{F1 -> set,
  F2 -> set,
  F3 -> set,
  F4 -> set}:
ex b1 being Relation-like Function-like set st
   proj1 b1 = NAT &
    b1 . 0 = F1() &
    b1 . 1 = F2() &
    b1 . 2 = F3() &
    (for b2 being Element of NAT holds
       b1 . (b2 + 3) = F4(b2, b1 . b2, b1 . (b2 + 1), b1 . (b2 + 2)))


:: RECDEF_2:sch 9
scheme RECDEF_2:sch 9
{F1 -> non empty set,
  F2 -> Element of F1(),
  F3 -> Element of F1(),
  F4 -> Element of F1(),
  F5 -> Element of F1()}:
ex b1 being Function-like quasi_total Relation of NAT,F1() st
   b1 . 0 = F2() &
    b1 . 1 = F3() &
    b1 . 2 = F4() &
    (for b2 being Element of NAT holds
       b1 . (b2 + 3) = F5(b2, b1 . b2, b1 . (b2 + 1), b1 . (b2 + 2)))


:: RECDEF_2:sch 10
scheme RECDEF_2:sch 10
{F1 -> set,
  F2 -> set,
  F3 -> set,
  F4 -> Relation-like Function-like set,
  F5 -> Relation-like Function-like set,
  F6 -> set}:
F4() = F5()
provided
   proj1 F4() = NAT
and
   F4() . 0 = F1() & F4() . 1 = F2() & F4() . 2 = F3()
and
   for b1 being Element of NAT holds
      F4() . (b1 + 3) = F6(b1, F4() . b1, F4() . (b1 + 1), F4() . (b1 + 2))
and
   proj1 F5() = NAT
and
   F5() . 0 = F1() & F5() . 1 = F2() & F5() . 2 = F3()
and
   for b1 being Element of NAT holds
      F5() . (b1 + 3) = F6(b1, F5() . b1, F5() . (b1 + 1), F5() . (b1 + 2));


:: RECDEF_2:sch 11
scheme RECDEF_2:sch 11
{F1 -> non empty set,
  F2 -> Element of F1(),
  F3 -> Element of F1(),
  F4 -> Element of F1(),
  F5 -> Function-like quasi_total Relation of NAT,F1(),
  F6 -> Function-like quasi_total Relation of NAT,F1(),
  F7 -> Element of F1()}:
F5() = F6()
provided
   F5() . 0 = F2() & F5() . 1 = F3() & F5() . 2 = F4()
and
   for b1 being Element of NAT holds
      F5() . (b1 + 3) = F7(b1, F5() . b1, F5() . (b1 + 1), F5() . (b1 + 2))
and
   F6() . 0 = F2() & F6() . 1 = F3() & F6() . 2 = F4()
and
   for b1 being Element of NAT holds
      F6() . (b1 + 3) = F7(b1, F6() . b1, F6() . (b1 + 1), F6() . (b1 + 2));


:: RECDEF_2:sch 12
scheme RECDEF_2:sch 12
{F1 -> set,
  F2 -> set,
  F3 -> set,
  F4 -> set,
  F5 -> set}:
ex b1 being Relation-like Function-like set st
   proj1 b1 = NAT &
    b1 . 0 = F1() &
    b1 . 1 = F2() &
    b1 . 2 = F3() &
    b1 . 3 = F4() &
    (for b2 being Element of NAT holds
       b1 . (b2 + 4) = F5(b2, b1 . b2, b1 . (b2 + 1), b1 . (b2 + 2), b1 . (b2 + 3)))


:: RECDEF_2:sch 13
scheme RECDEF_2:sch 13
{F1 -> non empty set,
  F2 -> Element of F1(),
  F3 -> Element of F1(),
  F4 -> Element of F1(),
  F5 -> Element of F1(),
  F6 -> Element of F1()}:
ex b1 being Function-like quasi_total Relation of NAT,F1() st
   b1 . 0 = F2() &
    b1 . 1 = F3() &
    b1 . 2 = F4() &
    b1 . 3 = F5() &
    (for b2 being Element of NAT holds
       b1 . (b2 + 4) = F6(b2, b1 . b2, b1 . (b2 + 1), b1 . (b2 + 2), b1 . (b2 + 3)))


:: RECDEF_2:sch 14
scheme RECDEF_2:sch 14
{F1 -> set,
  F2 -> set,
  F3 -> set,
  F4 -> set,
  F5 -> Relation-like Function-like set,
  F6 -> Relation-like Function-like set,
  F7 -> set}:
F5() = F6()
provided
   proj1 F5() = NAT
and
   F5() . 0 = F1() & F5() . 1 = F2() & F5() . 2 = F3() & F5() . 3 = F4()
and
   for b1 being Element of NAT holds
      F5() . (b1 + 4) = F7(b1, F5() . b1, F5() . (b1 + 1), F5() . (b1 + 2), F5() . (b1 + 3))
and
   proj1 F6() = NAT
and
   F6() . 0 = F1() & F6() . 1 = F2() & F6() . 2 = F3() & F6() . 3 = F4()
and
   for b1 being Element of NAT holds
      F6() . (b1 + 4) = F7(b1, F6() . b1, F6() . (b1 + 1), F6() . (b1 + 2), F6() . (b1 + 3));


:: RECDEF_2:sch 15
scheme RECDEF_2:sch 15
{F1 -> non empty set,
  F2 -> Element of F1(),
  F3 -> Element of F1(),
  F4 -> Element of F1(),
  F5 -> Element of F1(),
  F6 -> Function-like quasi_total Relation of NAT,F1(),
  F7 -> Function-like quasi_total Relation of NAT,F1(),
  F8 -> Element of F1()}:
F6() = F7()
provided
   F6() . 0 = F2() & F6() . 1 = F3() & F6() . 2 = F4() & F6() . 3 = F5()
and
   for b1 being Element of NAT holds
      F6() . (b1 + 4) = F8(b1, F6() . b1, F6() . (b1 + 1), F6() . (b1 + 2), F6() . (b1 + 3))
and
   F7() . 0 = F2() & F7() . 1 = F3() & F7() . 2 = F4() & F7() . 3 = F5()
and
   for b1 being Element of NAT holds
      F7() . (b1 + 4) = F8(b1, F7() . b1, F7() . (b1 + 1), F7() . (b1 + 2), F7() . (b1 + 3));