Article CQC_LANG, MML version 4.99.1005

:: CQC_LANG:th 5
theorem
for b1, b2 being set holds
proj1 (b1 .--> b2) = {b1} & proj2 (b1 .--> b2) = {b2};

:: CQC_LANG:th 6
theorem
for b1, b2 being set holds
(b1 .--> b2) . b1 = b2;

:: CQC_LANG:th 7
theorem
for b1 being set holds
      b1 in QC-variables
   iff
      (not b1 in fixed_QC-variables & not b1 in free_QC-variables implies b1 in bound_QC-variables);

:: CQC_LANG:modenot 1
definition
  mode Substitution is Function-like Relation of free_QC-variables,QC-variables;
end;

:: CQC_LANG:funcnot 1 => CQC_LANG:func 1
definition
  let a1 be FinSequence of QC-variables;
  let a2 be Function-like Relation of free_QC-variables,QC-variables;
  func Subst(A1,A2) -> FinSequence of QC-variables means
    len it = len a1 &
     (for b1 being Element of NAT
           st 1 <= b1 & b1 <= len a1
        holds (a1 . b1 in proj1 a2 implies it . b1 = a2 . (a1 . b1)) &
         (a1 . b1 in proj1 a2 or it . b1 = a1 . b1));
end;

:: CQC_LANG:def 3
theorem
for b1 being FinSequence of QC-variables
for b2 being Function-like Relation of free_QC-variables,QC-variables
for b3 being FinSequence of QC-variables holds
      b3 = Subst(b1,b2)
   iff
      len b3 = len b1 &
       (for b4 being Element of NAT
             st 1 <= b4 & b4 <= len b1
          holds (b1 . b4 in proj1 b2 implies b3 . b4 = b2 . (b1 . b4)) &
           (b1 . b4 in proj1 b2 or b3 . b4 = b1 . b4));

:: CQC_LANG:funcnot 2 => CQC_LANG:func 2
definition
  let a1 be Element of NAT;
  let a2 be QC-variable_list of a1;
  let a3 be Function-like Relation of free_QC-variables,QC-variables;
  redefine func Subst(a2,a3) -> QC-variable_list of a1;
end;

:: CQC_LANG:th 10
theorem
for b1 being Element of bound_QC-variables
for b2 being Element of free_QC-variables holds
   b2 .--> b1 is Function-like Relation of free_QC-variables,QC-variables;

:: CQC_LANG:funcnot 3 => CQC_LANG:func 3
definition
  let a1 be Element of free_QC-variables;
  let a2 be Element of bound_QC-variables;
  redefine func a1 .--> a2 -> Function-like Relation of free_QC-variables,QC-variables;
end;

:: CQC_LANG:th 11
theorem
for b1 being Element of NAT
for b2 being Element of bound_QC-variables
for b3 being Element of free_QC-variables
for b4, b5 being FinSequence of QC-variables
for b6 being Function-like Relation of free_QC-variables,QC-variables
      st b6 = b3 .--> b2 & b4 = Subst(b5,b6) & 1 <= b1 & b1 <= len b5
   holds (b5 . b1 = b3 implies b4 . b1 = b2) &
    (b5 . b1 = b3 or b4 . b1 = b5 . b1);

:: CQC_LANG:funcnot 4 => CQC_LANG:func 4
definition
  func CQC-WFF -> Element of bool QC-WFF equals
    {b1 where b1 is Element of QC-WFF: Fixed b1 = {} & Free b1 = {}};
end;

:: CQC_LANG:def 4
theorem
CQC-WFF = {b1 where b1 is Element of QC-WFF: Fixed b1 = {} & Free b1 = {}};

:: CQC_LANG:funcreg 1
registration
  cluster CQC-WFF -> non empty;
end;

:: CQC_LANG:th 13
theorem
for b1 being Element of QC-WFF holds
      b1 is Element of CQC-WFF
   iff
      Fixed b1 = {} & Free b1 = {};

:: CQC_LANG:attrnot 1 => CQC_LANG:attr 1
definition
  let a1 be Element of NAT;
  let a2 be QC-variable_list of a1;
  attr a2 is CQC-variable_list-like means
    proj2 a2 c= bound_QC-variables;
end;

:: CQC_LANG:dfs 3
definiens
  let a1 be Element of NAT;
  let a2 be QC-variable_list of a1;
To prove
     a2 is CQC-variable_list-like
it is sufficient to prove
  thus proj2 a2 c= bound_QC-variables;

:: CQC_LANG:def 5
theorem
for b1 being Element of NAT
for b2 being QC-variable_list of b1 holds
      b2 is CQC-variable_list-like(b1)
   iff
      proj2 b2 c= bound_QC-variables;

:: CQC_LANG:exreg 1
registration
  let a1 be Element of NAT;
  cluster Relation-like Function-like FinSequence-like CQC-variable_list-like QC-variable_list of a1;
end;

:: CQC_LANG:modenot 2
definition
  let a1 be Element of NAT;
  mode CQC-variable_list of a1 is CQC-variable_list-like QC-variable_list of a1;
end;

:: CQC_LANG:th 15
theorem
for b1 being Element of NAT
for b2 being QC-variable_list of b1 holds
      b2 is CQC-variable_list-like QC-variable_list of b1
   iff
      {b2 . b3 where b3 is Element of NAT: 1 <= b3 & b3 <= len b2 & b2 . b3 in free_QC-variables} = {} &
       {b2 . b3 where b3 is Element of NAT: 1 <= b3 & b3 <= len b2 & b2 . b3 in fixed_QC-variables} = {};

:: CQC_LANG:th 16
theorem
VERUM is Element of CQC-WFF;

:: CQC_LANG:th 17
theorem
for b1 being Element of NAT
for b2 being Element of b1 -ary_QC-pred_symbols
for b3 being QC-variable_list of b1 holds
      b2 ! b3 is Element of CQC-WFF
   iff
      {b3 . b4 where b4 is Element of NAT: 1 <= b4 & b4 <= len b3 & b3 . b4 in free_QC-variables} = {} &
       {b3 . b4 where b4 is Element of NAT: 1 <= b4 & b4 <= len b3 & b3 . b4 in fixed_QC-variables} = {};

:: CQC_LANG:funcnot 5 => CQC_LANG:func 5
definition
  let a1 be Element of NAT;
  let a2 be Element of a1 -ary_QC-pred_symbols;
  let a3 be CQC-variable_list-like QC-variable_list of a1;
  redefine func a2 ! a3 -> Element of CQC-WFF;
end;

:: CQC_LANG:th 18
theorem
for b1 being Element of QC-WFF holds
      'not' b1 is Element of CQC-WFF
   iff
      b1 is Element of CQC-WFF;

:: CQC_LANG:th 19
theorem
for b1, b2 being Element of QC-WFF holds
   b1 '&' b2 is Element of CQC-WFF
iff
   b1 is Element of CQC-WFF & b2 is Element of CQC-WFF;

:: CQC_LANG:funcnot 6 => CQC_LANG:func 6
definition
  redefine func VERUM -> Element of CQC-WFF;
end;

:: CQC_LANG:funcnot 7 => CQC_LANG:func 7
definition
  let a1 be Element of CQC-WFF;
  redefine func 'not' a1 -> Element of CQC-WFF;
end;

:: CQC_LANG:funcnot 8 => CQC_LANG:func 8
definition
  let a1, a2 be Element of CQC-WFF;
  redefine func a1 '&' a2 -> Element of CQC-WFF;
end;

:: CQC_LANG:th 20
theorem
for b1, b2 being Element of CQC-WFF holds
b1 => b2 is Element of CQC-WFF;

:: CQC_LANG:th 21
theorem
for b1, b2 being Element of CQC-WFF holds
b1 'or' b2 is Element of CQC-WFF;

:: CQC_LANG:th 22
theorem
for b1, b2 being Element of CQC-WFF holds
b1 <=> b2 is Element of CQC-WFF;

:: CQC_LANG:funcnot 9 => CQC_LANG:func 9
definition
  let a1, a2 be Element of CQC-WFF;
  redefine func a1 => a2 -> Element of CQC-WFF;
end;

:: CQC_LANG:funcnot 10 => CQC_LANG:func 10
definition
  let a1, a2 be Element of CQC-WFF;
  redefine func a1 'or' a2 -> Element of CQC-WFF;
end;

:: CQC_LANG:funcnot 11 => CQC_LANG:func 11
definition
  let a1, a2 be Element of CQC-WFF;
  redefine func a1 <=> a2 -> Element of CQC-WFF;
end;

:: CQC_LANG:th 23
theorem
for b1 being Element of bound_QC-variables
for b2 being Element of QC-WFF holds
      All(b1,b2) is Element of CQC-WFF
   iff
      b2 is Element of CQC-WFF;

:: CQC_LANG:funcnot 12 => CQC_LANG:func 12
definition
  let a1 be Element of bound_QC-variables;
  let a2 be Element of CQC-WFF;
  redefine func All(a1,a2) -> Element of CQC-WFF;
end;

:: CQC_LANG:th 24
theorem
for b1 being Element of bound_QC-variables
for b2 being Element of CQC-WFF holds
   Ex(b1,b2) is Element of CQC-WFF;

:: CQC_LANG:funcnot 13 => CQC_LANG:func 13
definition
  let a1 be Element of bound_QC-variables;
  let a2 be Element of CQC-WFF;
  redefine func Ex(a1,a2) -> Element of CQC-WFF;
end;

:: CQC_LANG:sch 1
scheme CQC_LANG:sch 1
for b1 being Element of CQC-WFF holds
   P1[b1]
provided
   for b1, b2 being Element of CQC-WFF
   for b3 being Element of bound_QC-variables
   for b4 being Element of NAT
   for b5 being CQC-variable_list-like QC-variable_list of b4
   for b6 being Element of b4 -ary_QC-pred_symbols holds
      P1[VERUM] & P1[b6 ! b5] & (P1[b1] implies P1['not' b1]) & (P1[b1] & P1[b2] implies P1[b1 '&' b2]) & (P1[b1] implies P1[All(b3,b1)]);


:: CQC_LANG:sch 2
scheme CQC_LANG:sch 2
{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 CQC-WFF,F1() st
   b1 . VERUM = F2() &
    (for b2, b3 being Element of CQC-WFF
    for b4 being Element of bound_QC-variables
    for b5 being Element of NAT
    for b6 being CQC-variable_list-like QC-variable_list of b5
    for b7 being Element of b5 -ary_QC-pred_symbols holds
       b1 . (b7 ! b6) = F3(b5, b7, b6) &
        b1 . 'not' b2 = F4(b1 . b2) &
        b1 . (b2 '&' b3) = F5(b1 . b2, b1 . b3) &
        b1 . All(b4,b2) = F6(b4, b1 . b2))


:: CQC_LANG:sch 3
scheme CQC_LANG:sch 3
{F1 -> non empty set,
  F2 -> Function-like quasi_total Relation of CQC-WFF,F1(),
  F3 -> Function-like quasi_total Relation of CQC-WFF,F1(),
  F4 -> Element of F1(),
  F5 -> Element of F1(),
  F6 -> Element of F1(),
  F7 -> Element of F1(),
  F8 -> Element of F1()}:
F2() = F3()
provided
   F2() . VERUM = F4() &
    (for b1, b2 being Element of CQC-WFF
    for b3 being Element of bound_QC-variables
    for b4 being Element of NAT
    for b5 being CQC-variable_list-like QC-variable_list of b4
    for b6 being Element of b4 -ary_QC-pred_symbols holds
       F2() . (b6 ! b5) = F5(b4, b6, b5) & F2() . 'not' b1 = F6(F2() . b1) & F2() . (b1 '&' b2) = F7(F2() . b1, F2() . b2) & F2() . All(b3,b1) = F8(b3, F2() . b1))
and
   F3() . VERUM = F4() &
    (for b1, b2 being Element of CQC-WFF
    for b3 being Element of bound_QC-variables
    for b4 being Element of NAT
    for b5 being CQC-variable_list-like QC-variable_list of b4
    for b6 being Element of b4 -ary_QC-pred_symbols holds
       F3() . (b6 ! b5) = F5(b4, b6, b5) & F3() . 'not' b1 = F6(F3() . b1) & F3() . (b1 '&' b2) = F7(F3() . b1, F3() . b2) & F3() . All(b3,b1) = F8(b3, F3() . b1));


:: CQC_LANG:sch 4
scheme CQC_LANG:sch 4
{F1 -> non empty set,
  F2 -> Element of CQC-WFF,
  F3 -> Element of F1(),
  F4 -> Element of F1(),
  F5 -> Element of F1(),
  F6 -> Element of F1(),
  F7 -> Element of F1()}:
(ex b1 being Element of F1() st
    ex b2 being Function-like quasi_total Relation of CQC-WFF,F1() st
       b1 = b2 . F2() &
        b2 . VERUM = F3() &
        (for b3, b4 being Element of CQC-WFF
        for b5 being Element of bound_QC-variables
        for b6 being Element of NAT
        for b7 being CQC-variable_list-like QC-variable_list of b6
        for b8 being Element of b6 -ary_QC-pred_symbols holds
           b2 . (b8 ! b7) = F4(b6, b8, b7) &
            b2 . 'not' b3 = F5(b2 . b3) &
            b2 . (b3 '&' b4) = F6(b2 . b3, b2 . b4) &
            b2 . All(b5,b3) = F7(b5, b2 . b3))) &
 (for b1, b2 being Element of F1()
       st (ex b3 being Function-like quasi_total Relation of CQC-WFF,F1() st
             b1 = b3 . F2() &
              b3 . VERUM = F3() &
              (for b4, b5 being Element of CQC-WFF
              for b6 being Element of bound_QC-variables
              for b7 being Element of NAT
              for b8 being CQC-variable_list-like QC-variable_list of b7
              for b9 being Element of b7 -ary_QC-pred_symbols holds
                 b3 . (b9 ! b8) = F4(b7, b9, b8) &
                  b3 . 'not' b4 = F5(b3 . b4) &
                  b3 . (b4 '&' b5) = F6(b3 . b4, b3 . b5) &
                  b3 . All(b6,b4) = F7(b6, b3 . b4))) &
          (ex b3 being Function-like quasi_total Relation of CQC-WFF,F1() st
             b2 = b3 . F2() &
              b3 . VERUM = F3() &
              (for b4, b5 being Element of CQC-WFF
              for b6 being Element of bound_QC-variables
              for b7 being Element of NAT
              for b8 being CQC-variable_list-like QC-variable_list of b7
              for b9 being Element of b7 -ary_QC-pred_symbols holds
                 b3 . (b9 ! b8) = F4(b7, b9, b8) &
                  b3 . 'not' b4 = F5(b3 . b4) &
                  b3 . (b4 '&' b5) = F6(b3 . b4, b3 . b5) &
                  b3 . All(b6,b4) = F7(b6, b3 . b4)))
    holds b1 = b2)


:: CQC_LANG:sch 5
scheme CQC_LANG:sch 5
{F1 -> non empty set,
  F2 -> Element of F1(),
  F3 -> Element of F1(),
  F4 -> Element of F1(),
  F5 -> Element of F1(),
  F6 -> Element of F1(),
  F7 -> Element of F1()}:
F2(VERUM) = F3()
provided
   for b1 being Element of CQC-WFF
   for b2 being Element of F1() holds
         b2 = F2(b1)
      iff
         ex b3 being Function-like quasi_total Relation of CQC-WFF,F1() st
            b2 = b3 . b1 &
             b3 . VERUM = F3() &
             (for b4, b5 being Element of CQC-WFF
             for b6 being Element of bound_QC-variables
             for b7 being Element of NAT
             for b8 being CQC-variable_list-like QC-variable_list of b7
             for b9 being Element of b7 -ary_QC-pred_symbols holds
                b3 . (b9 ! b8) = F4(b7, b9, b8) &
                 b3 . 'not' b4 = F5(b3 . b4) &
                 b3 . (b4 '&' b5) = F6(b3 . b4, b3 . b5) &
                 b3 . All(b6,b4) = F7(b6, b3 . b4));


:: CQC_LANG:sch 6
scheme CQC_LANG:sch 6
{F1 -> non empty set,
  F2 -> Element of F1(),
  F3 -> Element of F1(),
  F4 -> Element of F1(),
  F5 -> Element of NAT,
  F6 -> Element of F5() -ary_QC-pred_symbols,
  F7 -> CQC-variable_list-like QC-variable_list of F5(),
  F8 -> Element of F1(),
  F9 -> Element of F1(),
  F10 -> Element of F1()}:
F3(F6() ! F7()) = F4(F5(), F6(), F7())
provided
   for b1 being Element of CQC-WFF
   for b2 being Element of F1() holds
         b2 = F3(b1)
      iff
         ex b3 being Function-like quasi_total Relation of CQC-WFF,F1() st
            b2 = b3 . b1 &
             b3 . VERUM = F2() &
             (for b4, b5 being Element of CQC-WFF
             for b6 being Element of bound_QC-variables
             for b7 being Element of NAT
             for b8 being CQC-variable_list-like QC-variable_list of b7
             for b9 being Element of b7 -ary_QC-pred_symbols holds
                b3 . (b9 ! b8) = F4(b7, b9, b8) &
                 b3 . 'not' b4 = F8(b3 . b4) &
                 b3 . (b4 '&' b5) = F9(b3 . b4, b3 . b5) &
                 b3 . All(b6,b4) = F10(b6, b3 . b4));


:: CQC_LANG:sch 7
scheme CQC_LANG:sch 7
{F1 -> non empty set,
  F2 -> Element of F1(),
  F3 -> Element of F1(),
  F4 -> Element of F1(),
  F5 -> Element of F1(),
  F6 -> Element of CQC-WFF,
  F7 -> Element of F1(),
  F8 -> Element of F1()}:
F2('not' F6()) = F5(F2(F6()))
provided
   for b1 being Element of CQC-WFF
   for b2 being Element of F1() holds
         b2 = F2(b1)
      iff
         ex b3 being Function-like quasi_total Relation of CQC-WFF,F1() st
            b2 = b3 . b1 &
             b3 . VERUM = F3() &
             (for b4, b5 being Element of CQC-WFF
             for b6 being Element of bound_QC-variables
             for b7 being Element of NAT
             for b8 being CQC-variable_list-like QC-variable_list of b7
             for b9 being Element of b7 -ary_QC-pred_symbols holds
                b3 . (b9 ! b8) = F4(b7, b9, b8) &
                 b3 . 'not' b4 = F5(b3 . b4) &
                 b3 . (b4 '&' b5) = F7(b3 . b4, b3 . b5) &
                 b3 . All(b6,b4) = F8(b6, b3 . b4));


:: CQC_LANG:sch 8
scheme CQC_LANG:sch 8
{F1 -> non empty set,
  F2 -> Element of F1(),
  F3 -> Element of F1(),
  F4 -> Element of F1(),
  F5 -> Element of F1(),
  F6 -> Element of F1(),
  F7 -> Element of CQC-WFF,
  F8 -> Element of CQC-WFF,
  F9 -> Element of F1()}:
F2(F7() '&' F8()) = F6(F2(F7()), F2(F8()))
provided
   for b1 being Element of CQC-WFF
   for b2 being Element of F1() holds
         b2 = F2(b1)
      iff
         ex b3 being Function-like quasi_total Relation of CQC-WFF,F1() st
            b2 = b3 . b1 &
             b3 . VERUM = F3() &
             (for b4, b5 being Element of CQC-WFF
             for b6 being Element of bound_QC-variables
             for b7 being Element of NAT
             for b8 being CQC-variable_list-like QC-variable_list of b7
             for b9 being Element of b7 -ary_QC-pred_symbols holds
                b3 . (b9 ! b8) = F4(b7, b9, b8) &
                 b3 . 'not' b4 = F5(b3 . b4) &
                 b3 . (b4 '&' b5) = F6(b3 . b4, b3 . b5) &
                 b3 . All(b6,b4) = F9(b6, b3 . b4));


:: CQC_LANG:sch 9
scheme CQC_LANG:sch 9
{F1 -> non empty set,
  F2 -> Element of F1(),
  F3 -> Element of F1(),
  F4 -> Element of F1(),
  F5 -> Element of F1(),
  F6 -> Element of F1(),
  F7 -> Element of F1(),
  F8 -> Element of bound_QC-variables,
  F9 -> Element of CQC-WFF}:
F2(All(F8(),F9())) = F7(F8(), F2(F9()))
provided
   for b1 being Element of CQC-WFF
   for b2 being Element of F1() holds
         b2 = F2(b1)
      iff
         ex b3 being Function-like quasi_total Relation of CQC-WFF,F1() st
            b2 = b3 . b1 &
             b3 . VERUM = F3() &
             (for b4, b5 being Element of CQC-WFF
             for b6 being Element of bound_QC-variables
             for b7 being Element of NAT
             for b8 being CQC-variable_list-like QC-variable_list of b7
             for b9 being Element of b7 -ary_QC-pred_symbols holds
                b3 . (b9 ! b8) = F4(b7, b9, b8) &
                 b3 . 'not' b4 = F5(b3 . b4) &
                 b3 . (b4 '&' b5) = F6(b3 . b4, b3 . b5) &
                 b3 . All(b6,b4) = F7(b6, b3 . b4));


:: CQC_LANG:funcnot 14 => CQC_LANG:func 14
definition
  let a1 be Element of QC-WFF;
  let a2 be Element of bound_QC-variables;
  func A1 . A2 -> Element of QC-WFF means
    ex b1 being Function-like quasi_total Relation of QC-WFF,QC-WFF st
       it = b1 . a1 &
        (for b2 being Element of QC-WFF holds
           b1 . VERUM = VERUM &
            (b2 is atomic implies b1 . b2 = (the_pred_symbol_of b2) ! Subst(the_arguments_of b2,(a. 0) .--> a2)) &
            (b2 is negative implies b1 . b2 = 'not' (b1 . the_argument_of b2)) &
            (b2 is conjunctive implies b1 . b2 = (b1 . the_left_argument_of b2) '&' (b1 . the_right_argument_of b2)) &
            (b2 is universal implies b1 . b2 = IFEQ(bound_in b2,a2,b2,All(bound_in b2,b1 . the_scope_of b2))));
end;

:: CQC_LANG:def 6
theorem
for b1 being Element of QC-WFF
for b2 being Element of bound_QC-variables
for b3 being Element of QC-WFF holds
      b3 = b1 . b2
   iff
      ex b4 being Function-like quasi_total Relation of QC-WFF,QC-WFF st
         b3 = b4 . b1 &
          (for b5 being Element of QC-WFF holds
             b4 . VERUM = VERUM &
              (b5 is atomic implies b4 . b5 = (the_pred_symbol_of b5) ! Subst(the_arguments_of b5,(a. 0) .--> b2)) &
              (b5 is negative implies b4 . b5 = 'not' (b4 . the_argument_of b5)) &
              (b5 is conjunctive implies b4 . b5 = (b4 . the_left_argument_of b5) '&' (b4 . the_right_argument_of b5)) &
              (b5 is universal implies b4 . b5 = IFEQ(bound_in b5,b2,b5,All(bound_in b5,b4 . the_scope_of b5))));

:: CQC_LANG:th 28
theorem
for b1 being Element of bound_QC-variables holds
   VERUM . b1 = VERUM;

:: CQC_LANG:th 29
theorem
for b1 being Element of bound_QC-variables
for b2 being Element of QC-WFF
      st b2 is atomic
   holds b2 . b1 = (the_pred_symbol_of b2) ! Subst(the_arguments_of b2,(a. 0) .--> b1);

:: CQC_LANG:th 30
theorem
for b1 being Element of NAT
for b2 being Element of bound_QC-variables
for b3 being Element of b1 -ary_QC-pred_symbols
for b4 being QC-variable_list of b1 holds
   (b3 ! b4) . b2 = b3 ! Subst(b4,(a. 0) .--> b2);

:: CQC_LANG:th 31
theorem
for b1 being Element of bound_QC-variables
for b2 being Element of QC-WFF
      st b2 is negative
   holds b2 . b1 = 'not' ((the_argument_of b2) . b1);

:: CQC_LANG:th 32
theorem
for b1 being Element of bound_QC-variables
for b2 being Element of QC-WFF holds
   ('not' b2) . b1 = 'not' (b2 . b1);

:: CQC_LANG:th 33
theorem
for b1 being Element of bound_QC-variables
for b2 being Element of QC-WFF
      st b2 is conjunctive
   holds b2 . b1 = ((the_left_argument_of b2) . b1) '&' ((the_right_argument_of b2) . b1);

:: CQC_LANG:th 34
theorem
for b1 being Element of bound_QC-variables
for b2, b3 being Element of QC-WFF holds
(b2 '&' b3) . b1 = (b2 . b1) '&' (b3 . b1);

:: CQC_LANG:th 35
theorem
for b1 being Element of bound_QC-variables
for b2 being Element of QC-WFF
      st b2 is universal & bound_in b2 = b1
   holds b2 . b1 = b2;

:: CQC_LANG:th 36
theorem
for b1 being Element of bound_QC-variables
for b2 being Element of QC-WFF
      st b2 is universal & bound_in b2 <> b1
   holds b2 . b1 = All(bound_in b2,(the_scope_of b2) . b1);

:: CQC_LANG:th 37
theorem
for b1 being Element of bound_QC-variables
for b2 being Element of QC-WFF holds
   (All(b1,b2)) . b1 = All(b1,b2);

:: CQC_LANG:th 38
theorem
for b1, b2 being Element of bound_QC-variables
for b3 being Element of QC-WFF
      st b1 <> b2
   holds (All(b1,b3)) . b2 = All(b1,b3 . b2);

:: CQC_LANG:th 39
theorem
for b1 being Element of bound_QC-variables
for b2 being Element of QC-WFF
      st Free b2 = {}
   holds b2 . b1 = b2;

:: CQC_LANG:th 40
theorem
for b1 being Element of bound_QC-variables
for b2 being Element of CQC-WFF holds
   b2 . b1 = b2;

:: CQC_LANG:th 41
theorem
for b1 being Element of bound_QC-variables
for b2 being Element of QC-WFF holds
   Fixed (b2 . b1) = Fixed b2;

:: CQC_LANG:th 42
theorem
for b1, b2, b3 being set holds
(b1,b2):-> b3 = [b1,b2] .--> b3;

:: CQC_LANG:th 43
theorem
for b1, b2, b3 being set holds
((b1,b2):-> b3) .(b1,b2) = b3;

:: CQC_LANG:th 44
theorem
for b1, b2, b3 being set holds
(b1,b1)-->(b2,b3) = b1 .--> b3;

:: CQC_LANG:th 45
theorem
for b1, b2 being set holds
b1 .--> b2 = {[b1,b2]};

:: CQC_LANG:th 46
theorem
for b1 being Relation-like Function-like set
for b2, b3, b4 being set
      st b2 <> b4
   holds (b1 +* (b2 .--> b3)) . b4 = b1 . b4;

:: CQC_LANG:th 47
theorem
for b1 being Relation-like Function-like set
for b2, b3, b4, b5 being set
      st b2 <> b3
   holds (b1 +* ((b2,b3)-->(b4,b5))) . b2 = b4 & (b1 +* ((b2,b3)-->(b4,b5))) . b3 = b5;