Article QC_LANG3, MML version 4.99.1005

:: QC_LANG3:sch 1
scheme QC_LANG3:sch 1
{F1 -> non empty set,
  F2 -> Function-like quasi_total Relation of QC-WFF,F1(),
  F3 -> Function-like quasi_total Relation of QC-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
   for b1 being Element of QC-WFF
   for b2, b3 being Element of F1() holds
   (b1 = VERUM implies F2() . b1 = F4()) &
    (b1 is atomic implies F2() . b1 = F5(b1)) &
    (b1 is negative & b2 = F2() . the_argument_of b1 implies F2() . b1 = F6(b2)) &
    (b1 is conjunctive & b2 = F2() . the_left_argument_of b1 & b3 = F2() . the_right_argument_of b1 implies F2() . b1 = F7(b2, b3)) &
    (b1 is universal & b2 = F2() . the_scope_of b1 implies F2() . b1 = F8(b1, b2))
and
   for b1 being Element of QC-WFF
   for b2, b3 being Element of F1() holds
   (b1 = VERUM implies F3() . b1 = F4()) &
    (b1 is atomic implies F3() . b1 = F5(b1)) &
    (b1 is negative & b2 = F3() . the_argument_of b1 implies F3() . b1 = F6(b2)) &
    (b1 is conjunctive & b2 = F3() . the_left_argument_of b1 & b3 = F3() . the_right_argument_of b1 implies F3() . b1 = F7(b2, b3)) &
    (b1 is universal & b2 = F3() . the_scope_of b1 implies F3() . b1 = F8(b1, b2));


:: QC_LANG3:sch 2
scheme QC_LANG3:sch 2
{F1 -> non empty set,
  F2 -> Element of F1(),
  F3 -> Element of QC-WFF,
  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 QC-WFF,F1() st
       b1 = b2 . F3() &
        (for b3 being Element of QC-WFF
        for b4, b5 being Element of F1() holds
        (b3 = VERUM implies b2 . b3 = F2()) &
         (b3 is atomic implies b2 . b3 = F4(b3)) &
         (b3 is negative & b4 = b2 . the_argument_of b3 implies b2 . b3 = F5(b4)) &
         (b3 is conjunctive & b4 = b2 . the_left_argument_of b3 & b5 = b2 . the_right_argument_of b3 implies b2 . b3 = F6(b4, b5)) &
         (b3 is universal & b4 = b2 . the_scope_of b3 implies b2 . b3 = F7(b3, b4)))) &
 (for b1, b2 being Element of F1()
       st (ex b3 being Function-like quasi_total Relation of QC-WFF,F1() st
             b1 = b3 . F3() &
              (for b4 being Element of QC-WFF
              for b5, b6 being Element of F1() holds
              (b4 = VERUM implies b3 . b4 = F2()) &
               (b4 is atomic implies b3 . b4 = F4(b4)) &
               (b4 is negative & b5 = b3 . the_argument_of b4 implies b3 . b4 = F5(b5)) &
               (b4 is conjunctive & b5 = b3 . the_left_argument_of b4 & b6 = b3 . the_right_argument_of b4 implies b3 . b4 = F6(b5, b6)) &
               (b4 is universal & b5 = b3 . the_scope_of b4 implies b3 . b4 = F7(b4, b5)))) &
          (ex b3 being Function-like quasi_total Relation of QC-WFF,F1() st
             b2 = b3 . F3() &
              (for b4 being Element of QC-WFF
              for b5, b6 being Element of F1() holds
              (b4 = VERUM implies b3 . b4 = F2()) &
               (b4 is atomic implies b3 . b4 = F4(b4)) &
               (b4 is negative & b5 = b3 . the_argument_of b4 implies b3 . b4 = F5(b5)) &
               (b4 is conjunctive & b5 = b3 . the_left_argument_of b4 & b6 = b3 . the_right_argument_of b4 implies b3 . b4 = F6(b5, b6)) &
               (b4 is universal & b5 = b3 . the_scope_of b4 implies b3 . b4 = F7(b4, b5))))
    holds b1 = b2)


:: QC_LANG3:sch 3
scheme QC_LANG3:sch 3
{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 QC-WFF
   for b2 being Element of F1() holds
         b2 = F2(b1)
      iff
         ex b3 being Function-like quasi_total Relation of QC-WFF,F1() st
            b2 = b3 . b1 &
             (for b4 being Element of QC-WFF
             for b5, b6 being Element of F1() holds
             (b4 = VERUM implies b3 . b4 = F3()) &
              (b4 is atomic implies b3 . b4 = F4(b4)) &
              (b4 is negative & b5 = b3 . the_argument_of b4 implies b3 . b4 = F5(b5)) &
              (b4 is conjunctive & b5 = b3 . the_left_argument_of b4 & b6 = b3 . the_right_argument_of b4 implies b3 . b4 = F6(b5, b6)) &
              (b4 is universal & b5 = b3 . the_scope_of b4 implies b3 . b4 = F7(b4, b5)));


:: QC_LANG3:sch 4
scheme QC_LANG3:sch 4
{F1 -> non empty set,
  F2 -> Element of F1(),
  F3 -> Element of F1(),
  F4 -> Element of QC-WFF,
  F5 -> Element of F1(),
  F6 -> Element of F1(),
  F7 -> Element of F1(),
  F8 -> Element of F1()}:
F3(F4()) = F5(F4())
provided
   for b1 being Element of QC-WFF
   for b2 being Element of F1() holds
         b2 = F3(b1)
      iff
         ex b3 being Function-like quasi_total Relation of QC-WFF,F1() st
            b2 = b3 . b1 &
             (for b4 being Element of QC-WFF
             for b5, b6 being Element of F1() holds
             (b4 = VERUM implies b3 . b4 = F2()) &
              (b4 is atomic implies b3 . b4 = F5(b4)) &
              (b4 is negative & b5 = b3 . the_argument_of b4 implies b3 . b4 = F6(b5)) &
              (b4 is conjunctive & b5 = b3 . the_left_argument_of b4 & b6 = b3 . the_right_argument_of b4 implies b3 . b4 = F7(b5, b6)) &
              (b4 is universal & b5 = b3 . the_scope_of b4 implies b3 . b4 = F8(b4, b5)))
and
   F4() is atomic;


:: QC_LANG3:sch 5
scheme QC_LANG3:sch 5
{F1 -> non empty set,
  F2 -> Element of F1(),
  F3 -> Element of QC-WFF,
  F4 -> Element of F1(),
  F5 -> Element of F1(),
  F6 -> Element of F1(),
  F7 -> Element of F1(),
  F8 -> Element of F1()}:
F8(F3()) = F5(F8(the_argument_of F3()))
provided
   for b1 being Element of QC-WFF
   for b2 being Element of F1() holds
         b2 = F8(b1)
      iff
         ex b3 being Function-like quasi_total Relation of QC-WFF,F1() st
            b2 = b3 . b1 &
             (for b4 being Element of QC-WFF
             for b5, b6 being Element of F1() holds
             (b4 = VERUM implies b3 . b4 = F2()) &
              (b4 is atomic implies b3 . b4 = F4(b4)) &
              (b4 is negative & b5 = b3 . the_argument_of b4 implies b3 . b4 = F5(b5)) &
              (b4 is conjunctive & b5 = b3 . the_left_argument_of b4 & b6 = b3 . the_right_argument_of b4 implies b3 . b4 = F6(b5, b6)) &
              (b4 is universal & b5 = b3 . the_scope_of b4 implies b3 . b4 = F7(b4, b5)))
and
   F3() is negative;


:: QC_LANG3:sch 6
scheme QC_LANG3:sch 6
{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 QC-WFF}:
for b1, b2 being Element of F1()
      st b1 = F7(the_left_argument_of F8()) & b2 = F7(the_right_argument_of F8())
   holds F7(F8()) = F5(b1, b2)
provided
   for b1 being Element of QC-WFF
   for b2 being Element of F1() holds
         b2 = F7(b1)
      iff
         ex b3 being Function-like quasi_total Relation of QC-WFF,F1() st
            b2 = b3 . b1 &
             (for b4 being Element of QC-WFF
             for b5, b6 being Element of F1() holds
             (b4 = VERUM implies b3 . b4 = F2()) &
              (b4 is atomic implies b3 . b4 = F3(b4)) &
              (b4 is negative & b5 = b3 . the_argument_of b4 implies b3 . b4 = F4(b5)) &
              (b4 is conjunctive & b5 = b3 . the_left_argument_of b4 & b6 = b3 . the_right_argument_of b4 implies b3 . b4 = F5(b5, b6)) &
              (b4 is universal & b5 = b3 . the_scope_of b4 implies b3 . b4 = F6(b4, b5)))
and
   F8() is conjunctive;


:: QC_LANG3:sch 7
scheme QC_LANG3:sch 7
{F1 -> non empty set,
  F2 -> Element of F1(),
  F3 -> Element of QC-WFF,
  F4 -> Element of F1(),
  F5 -> Element of F1(),
  F6 -> Element of F1(),
  F7 -> Element of F1(),
  F8 -> Element of F1()}:
F8(F3()) = F7(F3(), F8(the_scope_of F3()))
provided
   for b1 being Element of QC-WFF
   for b2 being Element of F1() holds
         b2 = F8(b1)
      iff
         ex b3 being Function-like quasi_total Relation of QC-WFF,F1() st
            b2 = b3 . b1 &
             (for b4 being Element of QC-WFF
             for b5, b6 being Element of F1() holds
             (b4 = VERUM implies b3 . b4 = F2()) &
              (b4 is atomic implies b3 . b4 = F4(b4)) &
              (b4 is negative & b5 = b3 . the_argument_of b4 implies b3 . b4 = F5(b5)) &
              (b4 is conjunctive & b5 = b3 . the_left_argument_of b4 & b6 = b3 . the_right_argument_of b4 implies b3 . b4 = F6(b5, b6)) &
              (b4 is universal & b5 = b3 . the_scope_of b4 implies b3 . b4 = F7(b4, b5)))
and
   F3() is universal;


:: QC_LANG3:th 3
theorem
for b1 being Element of QC-pred_symbols holds
   b1 is Element of (the_arity_of b1) -ary_QC-pred_symbols;

:: QC_LANG3:funcnot 1 => QC_LANG3:func 1
definition
  let a1 be FinSequence of QC-variables;
  let a2 be non empty Element of bool QC-variables;
  func variables_in(A1,A2) -> Element of bool a2 equals
    {a1 . b1 where b1 is Element of NAT: 1 <= b1 & b1 <= len a1 & a1 . b1 in a2};
end;

:: QC_LANG3:def 2
theorem
for b1 being FinSequence of QC-variables
for b2 being non empty Element of bool QC-variables holds
   variables_in(b1,b2) = {b1 . b3 where b3 is Element of NAT: 1 <= b3 & b3 <= len b1 & b1 . b3 in b2};

:: QC_LANG3:th 6
theorem
for b1 being FinSequence of QC-variables holds
   still_not-bound_in b1 = variables_in(b1,bound_QC-variables);

:: QC_LANG3:th 7
theorem
still_not-bound_in VERUM = {};

:: QC_LANG3:th 8
theorem
for b1 being Element of QC-WFF
      st b1 is atomic
   holds still_not-bound_in b1 = still_not-bound_in the_arguments_of b1;

:: QC_LANG3:th 9
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
   still_not-bound_in (b2 ! b3) = still_not-bound_in b3;

:: QC_LANG3:th 10
theorem
for b1 being Element of QC-WFF
      st b1 is negative
   holds still_not-bound_in b1 = still_not-bound_in the_argument_of b1;

:: QC_LANG3:th 11
theorem
for b1 being Element of QC-WFF holds
   still_not-bound_in 'not' b1 = still_not-bound_in b1;

:: QC_LANG3:th 12
theorem
still_not-bound_in FALSUM = {};

:: QC_LANG3:th 13
theorem
for b1 being Element of QC-WFF
      st b1 is conjunctive
   holds still_not-bound_in b1 = (still_not-bound_in the_left_argument_of b1) \/ still_not-bound_in the_right_argument_of b1;

:: QC_LANG3:th 14
theorem
for b1, b2 being Element of QC-WFF holds
still_not-bound_in (b1 '&' b2) = (still_not-bound_in b1) \/ still_not-bound_in b2;

:: QC_LANG3:th 15
theorem
for b1 being Element of QC-WFF
      st b1 is universal
   holds still_not-bound_in b1 = (still_not-bound_in the_scope_of b1) \ {bound_in b1};

:: QC_LANG3:th 16
theorem
for b1 being Element of bound_QC-variables
for b2 being Element of QC-WFF holds
   still_not-bound_in All(b1,b2) = (still_not-bound_in b2) \ {b1};

:: QC_LANG3:th 17
theorem
for b1 being Element of QC-WFF
      st b1 is disjunctive
   holds still_not-bound_in b1 = (still_not-bound_in the_left_disjunct_of b1) \/ still_not-bound_in the_right_disjunct_of b1;

:: QC_LANG3:th 18
theorem
for b1, b2 being Element of QC-WFF holds
still_not-bound_in (b1 'or' b2) = (still_not-bound_in b1) \/ still_not-bound_in b2;

:: QC_LANG3:th 19
theorem
for b1 being Element of QC-WFF
      st b1 is conditional
   holds still_not-bound_in b1 = (still_not-bound_in the_antecedent_of b1) \/ still_not-bound_in the_right_disjunct_of b1;

:: QC_LANG3:th 20
theorem
for b1, b2 being Element of QC-WFF holds
still_not-bound_in (b1 => b2) = (still_not-bound_in b1) \/ still_not-bound_in b2;

:: QC_LANG3:th 21
theorem
for b1 being Element of QC-WFF
      st b1 is biconditional
   holds still_not-bound_in b1 = (still_not-bound_in the_left_side_of b1) \/ still_not-bound_in the_right_side_of b1;

:: QC_LANG3:th 22
theorem
for b1, b2 being Element of QC-WFF holds
still_not-bound_in (b1 <=> b2) = (still_not-bound_in b1) \/ still_not-bound_in b2;

:: QC_LANG3:th 23
theorem
for b1 being Element of bound_QC-variables
for b2 being Element of QC-WFF holds
   still_not-bound_in Ex(b1,b2) = (still_not-bound_in b2) \ {b1};

:: QC_LANG3:th 24
theorem
VERUM is closed & FALSUM is closed;

:: QC_LANG3:th 25
theorem
for b1 being Element of QC-WFF holds
      b1 is closed
   iff
      'not' b1 is closed;

:: QC_LANG3:th 26
theorem
for b1, b2 being Element of QC-WFF holds
   b1 is closed & b2 is closed
iff
   b1 '&' b2 is closed;

:: QC_LANG3:th 27
theorem
for b1 being Element of bound_QC-variables
for b2 being Element of QC-WFF holds
      All(b1,b2) is closed
   iff
      still_not-bound_in b2 c= {b1};

:: QC_LANG3:th 28
theorem
for b1 being Element of bound_QC-variables
for b2 being Element of QC-WFF
      st b2 is closed
   holds All(b1,b2) is closed;

:: QC_LANG3:th 29
theorem
for b1, b2 being Element of QC-WFF holds
   b1 is closed & b2 is closed
iff
   b1 'or' b2 is closed;

:: QC_LANG3:th 30
theorem
for b1, b2 being Element of QC-WFF holds
   b1 is closed & b2 is closed
iff
   b1 => b2 is closed;

:: QC_LANG3:th 31
theorem
for b1, b2 being Element of QC-WFF holds
   b1 is closed & b2 is closed
iff
   b1 <=> b2 is closed;

:: QC_LANG3:th 32
theorem
for b1 being Element of bound_QC-variables
for b2 being Element of QC-WFF holds
      Ex(b1,b2) is closed
   iff
      still_not-bound_in b2 c= {b1};

:: QC_LANG3:th 33
theorem
for b1 being Element of bound_QC-variables
for b2 being Element of QC-WFF
      st b2 is closed
   holds Ex(b1,b2) is closed;

:: QC_LANG3:funcnot 2 => QC_LANG3:func 2
definition
  let a1 be Element of NAT;
  func x. A1 -> Element of bound_QC-variables equals
    [4,a1];
end;

:: QC_LANG3:def 3
theorem
for b1 being Element of NAT holds
   x. b1 = [4,b1];

:: QC_LANG3:th 36
theorem
for b1 being Element of bound_QC-variables holds
   ex b2 being Element of NAT st
      x. b2 = b1;

:: QC_LANG3:funcnot 3 => QC_LANG3:func 3
definition
  let a1 be Element of NAT;
  func a. A1 -> Element of free_QC-variables equals
    [6,a1];
end;

:: QC_LANG3:def 4
theorem
for b1 being Element of NAT holds
   a. b1 = [6,b1];

:: QC_LANG3:th 39
theorem
for b1 being Element of free_QC-variables holds
   ex b2 being Element of NAT st
      a. b2 = b1;

:: QC_LANG3:th 40
theorem
for b1 being Element of fixed_QC-variables
for b2 being Element of free_QC-variables holds
   b1 <> b2;

:: QC_LANG3:th 41
theorem
for b1 being Element of fixed_QC-variables
for b2 being Element of bound_QC-variables holds
   b1 <> b2;

:: QC_LANG3:th 42
theorem
for b1 being Element of free_QC-variables
for b2 being Element of bound_QC-variables holds
   b1 <> b2;

:: QC_LANG3:funcnot 4 => QC_LANG3:func 4
definition
  let a1 be non empty Element of bool QC-variables;
  let a2 be Element of QC-WFF;
  func Vars(A2,A1) -> Element of bool a1 means
    ex b1 being Function-like quasi_total Relation of QC-WFF,bool a1 st
       it = b1 . a2 &
        (for b2 being Element of QC-WFF
        for b3, b4 being Element of bool a1 holds
        (b2 = VERUM implies b1 . b2 = {} a1) &
         (b2 is atomic implies b1 . b2 = variables_in(the_arguments_of b2,a1)) &
         (b2 is negative & b3 = b1 . the_argument_of b2 implies b1 . b2 = b3) &
         (b2 is conjunctive & b3 = b1 . the_left_argument_of b2 & b4 = b1 . the_right_argument_of b2 implies b1 . b2 = b3 \/ b4) &
         (b2 is universal & b3 = b1 . the_scope_of b2 implies b1 . b2 = b3));
end;

:: QC_LANG3:def 5
theorem
for b1 being non empty Element of bool QC-variables
for b2 being Element of QC-WFF
for b3 being Element of bool b1 holds
      b3 = Vars(b2,b1)
   iff
      ex b4 being Function-like quasi_total Relation of QC-WFF,bool b1 st
         b3 = b4 . b2 &
          (for b5 being Element of QC-WFF
          for b6, b7 being Element of bool b1 holds
          (b5 = VERUM implies b4 . b5 = {} b1) &
           (b5 is atomic implies b4 . b5 = variables_in(the_arguments_of b5,b1)) &
           (b5 is negative & b6 = b4 . the_argument_of b5 implies b4 . b5 = b6) &
           (b5 is conjunctive & b6 = b4 . the_left_argument_of b5 & b7 = b4 . the_right_argument_of b5 implies b4 . b5 = b6 \/ b7) &
           (b5 is universal & b6 = b4 . the_scope_of b5 implies b4 . b5 = b6));

:: QC_LANG3:th 46
theorem
for b1 being non empty Element of bool QC-variables holds
   Vars(VERUM,b1) = {};

:: QC_LANG3:th 47
theorem
for b1 being Element of QC-WFF
for b2 being non empty Element of bool QC-variables
      st b1 is atomic
   holds Vars(b1,b2) = variables_in(the_arguments_of b1,b2) &
    Vars(b1,b2) = {(the_arguments_of b1) . b3 where b3 is Element of NAT: 1 <= b3 & b3 <= len the_arguments_of b1 & (the_arguments_of b1) . b3 in b2};

:: QC_LANG3:th 48
theorem
for b1 being Element of NAT
for b2 being non empty Element of bool QC-variables
for b3 being Element of b1 -ary_QC-pred_symbols
for b4 being QC-variable_list of b1 holds
   Vars(b3 ! b4,b2) = variables_in(b4,b2) &
    Vars(b3 ! b4,b2) = {b4 . b5 where b5 is Element of NAT: 1 <= b5 & b5 <= len b4 & b4 . b5 in b2};

:: QC_LANG3:th 49
theorem
for b1 being Element of QC-WFF
for b2 being non empty Element of bool QC-variables
      st b1 is negative
   holds Vars(b1,b2) = Vars(the_argument_of b1,b2);

:: QC_LANG3:th 50
theorem
for b1 being Element of QC-WFF
for b2 being non empty Element of bool QC-variables holds
   Vars('not' b1,b2) = Vars(b1,b2);

:: QC_LANG3:th 51
theorem
for b1 being non empty Element of bool QC-variables holds
   Vars(FALSUM,b1) = {};

:: QC_LANG3:th 52
theorem
for b1 being Element of QC-WFF
for b2 being non empty Element of bool QC-variables
      st b1 is conjunctive
   holds Vars(b1,b2) = (Vars(the_left_argument_of b1,b2)) \/ Vars(the_right_argument_of b1,b2);

:: QC_LANG3:th 53
theorem
for b1, b2 being Element of QC-WFF
for b3 being non empty Element of bool QC-variables holds
   Vars(b1 '&' b2,b3) = (Vars(b1,b3)) \/ Vars(b2,b3);

:: QC_LANG3:th 54
theorem
for b1 being Element of QC-WFF
for b2 being non empty Element of bool QC-variables
      st b1 is universal
   holds Vars(b1,b2) = Vars(the_scope_of b1,b2);

:: QC_LANG3:th 55
theorem
for b1 being Element of bound_QC-variables
for b2 being Element of QC-WFF
for b3 being non empty Element of bool QC-variables holds
   Vars(All(b1,b2),b3) = Vars(b2,b3);

:: QC_LANG3:th 56
theorem
for b1 being Element of QC-WFF
for b2 being non empty Element of bool QC-variables
      st b1 is disjunctive
   holds Vars(b1,b2) = (Vars(the_left_disjunct_of b1,b2)) \/ Vars(the_right_disjunct_of b1,b2);

:: QC_LANG3:th 57
theorem
for b1, b2 being Element of QC-WFF
for b3 being non empty Element of bool QC-variables holds
   Vars(b1 'or' b2,b3) = (Vars(b1,b3)) \/ Vars(b2,b3);

:: QC_LANG3:th 58
theorem
for b1 being Element of QC-WFF
for b2 being non empty Element of bool QC-variables
      st b1 is conditional
   holds Vars(b1,b2) = (Vars(the_antecedent_of b1,b2)) \/ Vars(the_right_disjunct_of b1,b2);

:: QC_LANG3:th 59
theorem
for b1, b2 being Element of QC-WFF
for b3 being non empty Element of bool QC-variables holds
   Vars(b1 => b2,b3) = (Vars(b1,b3)) \/ Vars(b2,b3);

:: QC_LANG3:th 60
theorem
for b1 being Element of QC-WFF
for b2 being non empty Element of bool QC-variables
      st b1 is biconditional
   holds Vars(b1,b2) = (Vars(the_left_side_of b1,b2)) \/ Vars(the_right_side_of b1,b2);

:: QC_LANG3:th 61
theorem
for b1, b2 being Element of QC-WFF
for b3 being non empty Element of bool QC-variables holds
   Vars(b1 <=> b2,b3) = (Vars(b1,b3)) \/ Vars(b2,b3);

:: QC_LANG3:th 62
theorem
for b1 being Element of QC-WFF
for b2 being non empty Element of bool QC-variables
      st b1 is existential
   holds Vars(b1,b2) = Vars(the_argument_of the_scope_of the_argument_of b1,b2);

:: QC_LANG3:th 63
theorem
for b1 being Element of bound_QC-variables
for b2 being Element of QC-WFF
for b3 being non empty Element of bool QC-variables holds
   Vars(Ex(b1,b2),b3) = Vars(b2,b3);

:: QC_LANG3:funcnot 5 => QC_LANG3:func 5
definition
  let a1 be Element of QC-WFF;
  func Free A1 -> Element of bool free_QC-variables equals
    Vars(a1,free_QC-variables);
end;

:: QC_LANG3:def 6
theorem
for b1 being Element of QC-WFF holds
   Free b1 = Vars(b1,free_QC-variables);

:: QC_LANG3:th 65
theorem
Free VERUM = {};

:: QC_LANG3:th 66
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
   Free (b2 ! b3) = {b3 . b4 where b4 is Element of NAT: 1 <= b4 & b4 <= len b3 & b3 . b4 in free_QC-variables};

:: QC_LANG3:th 67
theorem
for b1 being Element of QC-WFF holds
   Free 'not' b1 = Free b1;

:: QC_LANG3:th 68
theorem
Free FALSUM = {};

:: QC_LANG3:th 69
theorem
for b1, b2 being Element of QC-WFF holds
Free (b1 '&' b2) = (Free b1) \/ Free b2;

:: QC_LANG3:th 70
theorem
for b1 being Element of bound_QC-variables
for b2 being Element of QC-WFF holds
   Free All(b1,b2) = Free b2;

:: QC_LANG3:th 71
theorem
for b1, b2 being Element of QC-WFF holds
Free (b1 'or' b2) = (Free b1) \/ Free b2;

:: QC_LANG3:th 72
theorem
for b1, b2 being Element of QC-WFF holds
Free (b1 => b2) = (Free b1) \/ Free b2;

:: QC_LANG3:th 73
theorem
for b1, b2 being Element of QC-WFF holds
Free (b1 <=> b2) = (Free b1) \/ Free b2;

:: QC_LANG3:th 74
theorem
for b1 being Element of bound_QC-variables
for b2 being Element of QC-WFF holds
   Free Ex(b1,b2) = Free b2;

:: QC_LANG3:funcnot 6 => QC_LANG3:func 6
definition
  let a1 be Element of QC-WFF;
  func Fixed A1 -> Element of bool fixed_QC-variables equals
    Vars(a1,fixed_QC-variables);
end;

:: QC_LANG3:def 7
theorem
for b1 being Element of QC-WFF holds
   Fixed b1 = Vars(b1,fixed_QC-variables);

:: QC_LANG3:th 76
theorem
Fixed VERUM = {};

:: QC_LANG3:th 77
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
   Fixed (b2 ! b3) = {b3 . b4 where b4 is Element of NAT: 1 <= b4 & b4 <= len b3 & b3 . b4 in fixed_QC-variables};

:: QC_LANG3:th 78
theorem
for b1 being Element of QC-WFF holds
   Fixed 'not' b1 = Fixed b1;

:: QC_LANG3:th 79
theorem
Fixed FALSUM = {};

:: QC_LANG3:th 80
theorem
for b1, b2 being Element of QC-WFF holds
Fixed (b1 '&' b2) = (Fixed b1) \/ Fixed b2;

:: QC_LANG3:th 81
theorem
for b1 being Element of bound_QC-variables
for b2 being Element of QC-WFF holds
   Fixed All(b1,b2) = Fixed b2;

:: QC_LANG3:th 82
theorem
for b1, b2 being Element of QC-WFF holds
Fixed (b1 'or' b2) = (Fixed b1) \/ Fixed b2;

:: QC_LANG3:th 83
theorem
for b1, b2 being Element of QC-WFF holds
Fixed (b1 => b2) = (Fixed b1) \/ Fixed b2;

:: QC_LANG3:th 84
theorem
for b1, b2 being Element of QC-WFF holds
Fixed (b1 <=> b2) = (Fixed b1) \/ Fixed b2;

:: QC_LANG3:th 85
theorem
for b1 being Element of bound_QC-variables
for b2 being Element of QC-WFF holds
   Fixed Ex(b1,b2) = Fixed b2;