Article QC_LANG1, MML version 4.99.1005

:: QC_LANG1:th 1
theorem
for b1 being non empty set
for b2 being set
for b3 being Element of b1 holds
   [:{b3},b2:] c= [:b1,b2:];

:: QC_LANG1:th 2
theorem
for b1 being non empty set
for b2 being set
for b3, b4, b5 being Element of b1 holds
[:{b3,b4,b5},b2:] c= [:b1,b2:];

:: QC_LANG1:funcnot 1 => QC_LANG1:func 1
definition
  func QC-variables -> set equals
    [:{4,5,6},NAT:];
end;

:: QC_LANG1:def 1
theorem
QC-variables = [:{4,5,6},NAT:];

:: QC_LANG1:funcreg 1
registration
  cluster QC-variables -> non empty;
end;

:: QC_LANG1:th 4
theorem
QC-variables c= [:NAT,NAT:];

:: QC_LANG1:modenot 1
definition
  mode QC-variable is Element of QC-variables;
end;

:: QC_LANG1:funcnot 2 => QC_LANG1:func 2
definition
  func bound_QC-variables -> Element of bool QC-variables equals
    [:{4},NAT:];
end;

:: QC_LANG1:def 2
theorem
bound_QC-variables = [:{4},NAT:];

:: QC_LANG1:funcnot 3 => QC_LANG1:func 3
definition
  func fixed_QC-variables -> Element of bool QC-variables equals
    [:{5},NAT:];
end;

:: QC_LANG1:def 3
theorem
fixed_QC-variables = [:{5},NAT:];

:: QC_LANG1:funcnot 4 => QC_LANG1:func 4
definition
  func free_QC-variables -> Element of bool QC-variables equals
    [:{6},NAT:];
end;

:: QC_LANG1:def 4
theorem
free_QC-variables = [:{6},NAT:];

:: QC_LANG1:funcnot 5 => QC_LANG1:func 5
definition
  func QC-pred_symbols -> set equals
    {[b1,b2] where b1 is Element of NAT, b2 is Element of NAT: 7 <= b1};
end;

:: QC_LANG1:def 5
theorem
QC-pred_symbols = {[b1,b2] where b1 is Element of NAT, b2 is Element of NAT: 7 <= b1};

:: QC_LANG1:funcreg 2
registration
  cluster bound_QC-variables -> non empty;
end;

:: QC_LANG1:funcreg 3
registration
  cluster fixed_QC-variables -> non empty;
end;

:: QC_LANG1:funcreg 4
registration
  cluster free_QC-variables -> non empty;
end;

:: QC_LANG1:funcreg 5
registration
  cluster QC-pred_symbols -> non empty;
end;

:: QC_LANG1:th 10
theorem
QC-pred_symbols c= [:NAT,NAT:];

:: QC_LANG1:modenot 2
definition
  mode QC-pred_symbol is Element of QC-pred_symbols;
end;

:: QC_LANG1:funcnot 6 => QC_LANG1:func 6
definition
  let a1 be Element of QC-pred_symbols;
  func the_arity_of A1 -> Element of NAT means
    a1 `1 = 7 + it;
end;

:: QC_LANG1:def 6
theorem
for b1 being Element of QC-pred_symbols
for b2 being Element of NAT holds
      b2 = the_arity_of b1
   iff
      b1 `1 = 7 + b2;

:: QC_LANG1:funcnot 7 => QC_LANG1:func 7
definition
  let a1 be Element of NAT;
  func A1 -ary_QC-pred_symbols -> Element of bool QC-pred_symbols equals
    {b1 where b1 is Element of QC-pred_symbols: the_arity_of b1 = a1};
end;

:: QC_LANG1:def 7
theorem
for b1 being Element of NAT holds
   b1 -ary_QC-pred_symbols = {b2 where b2 is Element of QC-pred_symbols: the_arity_of b2 = b1};

:: QC_LANG1:funcreg 6
registration
  let a1 be Element of NAT;
  cluster a1 -ary_QC-pred_symbols -> non empty;
end;

:: QC_LANG1:modenot 3
definition
  mode bound_QC-variable is Element of bound_QC-variables;
end;

:: QC_LANG1:modenot 4
definition
  mode fixed_QC-variable is Element of fixed_QC-variables;
end;

:: QC_LANG1:modenot 5
definition
  mode free_QC-variable is Element of free_QC-variables;
end;

:: QC_LANG1:modenot 6
definition
  let a1 be Element of NAT;
  mode QC-pred_symbol of a1 is Element of a1 -ary_QC-pred_symbols;
end;

:: QC_LANG1:modenot 7 => QC_LANG1:mode 1
definition
  let a1 be Element of NAT;
  mode QC-variable_list of A1 -> FinSequence of QC-variables means
    len it = a1;
end;

:: QC_LANG1:dfs 8
definiens
  let a1 be Element of NAT;
  let a2 be FinSequence of QC-variables;
To prove
     a2 is QC-variable_list of a1
it is sufficient to prove
  thus len a2 = a1;

:: QC_LANG1:def 8
theorem
for b1 being Element of NAT
for b2 being FinSequence of QC-variables holds
      b2 is QC-variable_list of b1
   iff
      len b2 = b1;

:: QC_LANG1:attrnot 1 => QC_LANG1:attr 1
definition
  let a1 be set;
  attr a1 is QC-closed means
    a1 is Element of bool ([:NAT,NAT:] *) &
     (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 in a1) &
     <*[0,0]*> in a1 &
     (for b1 being FinSequence of [:NAT,NAT:]
           st b1 in a1
        holds <*[1,0]*> ^ b1 in a1) &
     (for b1, b2 being FinSequence of [:NAT,NAT:]
           st b1 in a1 & b2 in a1
        holds (<*[2,0]*> ^ b1) ^ b2 in a1) &
     (for b1 being Element of bound_QC-variables
     for b2 being FinSequence of [:NAT,NAT:]
           st b2 in a1
        holds (<*[3,0]*> ^ <*b1*>) ^ b2 in a1);
end;

:: QC_LANG1:dfs 9
definiens
  let a1 be set;
To prove
     a1 is QC-closed
it is sufficient to prove
  thus a1 is Element of bool ([:NAT,NAT:] *) &
     (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 in a1) &
     <*[0,0]*> in a1 &
     (for b1 being FinSequence of [:NAT,NAT:]
           st b1 in a1
        holds <*[1,0]*> ^ b1 in a1) &
     (for b1, b2 being FinSequence of [:NAT,NAT:]
           st b1 in a1 & b2 in a1
        holds (<*[2,0]*> ^ b1) ^ b2 in a1) &
     (for b1 being Element of bound_QC-variables
     for b2 being FinSequence of [:NAT,NAT:]
           st b2 in a1
        holds (<*[3,0]*> ^ <*b1*>) ^ b2 in a1);

:: QC_LANG1:def 9
theorem
for b1 being set holds
      b1 is QC-closed
   iff
      b1 is Element of bool ([:NAT,NAT:] *) &
       (for b2 being Element of NAT
       for b3 being Element of b2 -ary_QC-pred_symbols
       for b4 being QC-variable_list of b2 holds
          <*b3*> ^ b4 in b1) &
       <*[0,0]*> in b1 &
       (for b2 being FinSequence of [:NAT,NAT:]
             st b2 in b1
          holds <*[1,0]*> ^ b2 in b1) &
       (for b2, b3 being FinSequence of [:NAT,NAT:]
             st b2 in b1 & b3 in b1
          holds (<*[2,0]*> ^ b2) ^ b3 in b1) &
       (for b2 being Element of bound_QC-variables
       for b3 being FinSequence of [:NAT,NAT:]
             st b3 in b1
          holds (<*[3,0]*> ^ <*b2*>) ^ b3 in b1);

:: QC_LANG1:funcnot 8 => QC_LANG1:func 8
definition
  func QC-WFF -> non empty set means
    it is QC-closed &
     (for b1 being non empty set
           st b1 is QC-closed
        holds it c= b1);
end;

:: QC_LANG1:def 10
theorem
for b1 being non empty set holds
      b1 = QC-WFF
   iff
      b1 is QC-closed &
       (for b2 being non empty set
             st b2 is QC-closed
          holds b1 c= b2);

:: QC_LANG1:th 21
theorem
QC-WFF is QC-closed;

:: QC_LANG1:modenot 8
definition
  mode QC-formula is Element of QC-WFF;
end;

:: QC_LANG1:funcnot 9 => QC_LANG1:func 9
definition
  let a1 be Element of QC-pred_symbols;
  let a2 be FinSequence of QC-variables;
  assume the_arity_of a1 = len a2;
  func A1 ! A2 -> Element of QC-WFF equals
    <*a1*> ^ a2;
end;

:: QC_LANG1:def 11
theorem
for b1 being Element of QC-pred_symbols
for b2 being FinSequence of QC-variables
      st the_arity_of b1 = len b2
   holds b1 ! b2 = <*b1*> ^ b2;

:: QC_LANG1:th 23
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 = <*b2*> ^ b3;

:: QC_LANG1:funcnot 10 => QC_LANG1:func 10
definition
  let a1 be Element of QC-WFF;
  func @ A1 -> FinSequence of [:NAT,NAT:] equals
    a1;
end;

:: QC_LANG1:def 12
theorem
for b1 being Element of QC-WFF holds
   @ b1 = b1;

:: QC_LANG1:funcnot 11 => QC_LANG1:func 11
definition
  func VERUM -> Element of QC-WFF equals
    <*[0,0]*>;
end;

:: QC_LANG1:def 13
theorem
VERUM = <*[0,0]*>;

:: QC_LANG1:funcnot 12 => QC_LANG1:func 12
definition
  let a1 be Element of QC-WFF;
  func 'not' A1 -> Element of QC-WFF equals
    <*[1,0]*> ^ @ a1;
end;

:: QC_LANG1:def 14
theorem
for b1 being Element of QC-WFF holds
   'not' b1 = <*[1,0]*> ^ @ b1;

:: QC_LANG1:funcnot 13 => QC_LANG1:func 13
definition
  let a1, a2 be Element of QC-WFF;
  func A1 '&' A2 -> Element of QC-WFF equals
    (<*[2,0]*> ^ @ a1) ^ @ a2;
end;

:: QC_LANG1:def 15
theorem
for b1, b2 being Element of QC-WFF holds
b1 '&' b2 = (<*[2,0]*> ^ @ b1) ^ @ b2;

:: QC_LANG1:funcnot 14 => QC_LANG1:func 14
definition
  let a1 be Element of bound_QC-variables;
  let a2 be Element of QC-WFF;
  func All(A1,A2) -> Element of QC-WFF equals
    (<*[3,0]*> ^ <*a1*>) ^ @ a2;
end;

:: QC_LANG1:def 16
theorem
for b1 being Element of bound_QC-variables
for b2 being Element of QC-WFF holds
   All(b1,b2) = (<*[3,0]*> ^ <*b1*>) ^ @ b2;

:: QC_LANG1:sch 1
scheme QC_LANG1:sch 1
for b1 being Element of QC-WFF holds
   P1[b1]
provided
   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
      P1[b2 ! b3]
and
   P1[VERUM]
and
   for b1 being Element of QC-WFF
         st P1[b1]
      holds P1['not' b1]
and
   for b1, b2 being Element of QC-WFF
         st P1[b1] & P1[b2]
      holds P1[b1 '&' b2]
and
   for b1 being Element of bound_QC-variables
   for b2 being Element of QC-WFF
         st P1[b2]
      holds P1[All(b1,b2)];


:: QC_LANG1:attrnot 2 => QC_LANG1:attr 2
definition
  let a1 be Element of QC-WFF;
  attr a1 is atomic means
    ex b1 being Element of NAT st
       ex b2 being Element of b1 -ary_QC-pred_symbols st
          ex b3 being QC-variable_list of b1 st
             a1 = b2 ! b3;
end;

:: QC_LANG1:dfs 17
definiens
  let a1 be Element of QC-WFF;
To prove
     a1 is atomic
it is sufficient to prove
  thus ex b1 being Element of NAT st
       ex b2 being Element of b1 -ary_QC-pred_symbols st
          ex b3 being QC-variable_list of b1 st
             a1 = b2 ! b3;

:: QC_LANG1:def 17
theorem
for b1 being Element of QC-WFF holds
      b1 is atomic
   iff
      ex b2 being Element of NAT st
         ex b3 being Element of b2 -ary_QC-pred_symbols st
            ex b4 being QC-variable_list of b2 st
               b1 = b3 ! b4;

:: QC_LANG1:attrnot 3 => QC_LANG1:attr 3
definition
  let a1 be Element of QC-WFF;
  attr a1 is negative means
    ex b1 being Element of QC-WFF st
       a1 = 'not' b1;
end;

:: QC_LANG1:dfs 18
definiens
  let a1 be Element of QC-WFF;
To prove
     a1 is negative
it is sufficient to prove
  thus ex b1 being Element of QC-WFF st
       a1 = 'not' b1;

:: QC_LANG1:def 18
theorem
for b1 being Element of QC-WFF holds
      b1 is negative
   iff
      ex b2 being Element of QC-WFF st
         b1 = 'not' b2;

:: QC_LANG1:attrnot 4 => QC_LANG1:attr 4
definition
  let a1 be Element of QC-WFF;
  attr a1 is conjunctive means
    ex b1, b2 being Element of QC-WFF st
       a1 = b1 '&' b2;
end;

:: QC_LANG1:dfs 19
definiens
  let a1 be Element of QC-WFF;
To prove
     a1 is conjunctive
it is sufficient to prove
  thus ex b1, b2 being Element of QC-WFF st
       a1 = b1 '&' b2;

:: QC_LANG1:def 19
theorem
for b1 being Element of QC-WFF holds
      b1 is conjunctive
   iff
      ex b2, b3 being Element of QC-WFF st
         b1 = b2 '&' b3;

:: QC_LANG1:attrnot 5 => QC_LANG1:attr 5
definition
  let a1 be Element of QC-WFF;
  attr a1 is universal means
    ex b1 being Element of bound_QC-variables st
       ex b2 being Element of QC-WFF st
          a1 = All(b1,b2);
end;

:: QC_LANG1:dfs 20
definiens
  let a1 be Element of QC-WFF;
To prove
     a1 is universal
it is sufficient to prove
  thus ex b1 being Element of bound_QC-variables st
       ex b2 being Element of QC-WFF st
          a1 = All(b1,b2);

:: QC_LANG1:def 20
theorem
for b1 being Element of QC-WFF holds
      b1 is universal
   iff
      ex b2 being Element of bound_QC-variables st
         ex b3 being Element of QC-WFF st
            b1 = All(b2,b3);

:: QC_LANG1:th 33
theorem
for b1 being Element of QC-WFF
      st b1 <> VERUM & b1 is not atomic & b1 is not negative & b1 is not conjunctive
   holds b1 is universal;

:: QC_LANG1:th 34
theorem
for b1 being Element of QC-WFF holds
   1 <= len @ b1;

:: QC_LANG1:th 35
theorem
for b1 being Element of NAT
for b2 being Element of b1 -ary_QC-pred_symbols holds
   the_arity_of b2 = b1;

:: QC_LANG1:th 36
theorem
for b1 being Element of QC-WFF holds
   (((@ b1) . 1) `1 = 0 implies b1 = VERUM) &
    (((@ b1) . 1) `1 = 1 implies b1 is negative) &
    (((@ b1) . 1) `1 = 2 implies b1 is conjunctive) &
    (((@ b1) . 1) `1 = 3 implies b1 is universal) &
    (for b2 being Element of NAT holds
       (@ b1) . 1 is not Element of b2 -ary_QC-pred_symbols or b1 is atomic);

:: QC_LANG1:th 37
theorem
for b1, b2 being Element of QC-WFF
for b3 being Relation-like Function-like FinSequence-like set
      st @ b1 = (@ b2) ^ b3
   holds @ b1 = @ b2;

:: QC_LANG1:funcnot 15 => QC_LANG1:func 15
definition
  let a1 be Element of QC-WFF;
  assume a1 is atomic;
  func the_pred_symbol_of A1 -> Element of QC-pred_symbols means
    ex b1 being Element of NAT st
       ex b2 being QC-variable_list of b1 st
          ex b3 being Element of b1 -ary_QC-pred_symbols st
             it = b3 & a1 = b3 ! b2;
end;

:: QC_LANG1:def 21
theorem
for b1 being Element of QC-WFF
   st b1 is atomic
for b2 being Element of QC-pred_symbols holds
      b2 = the_pred_symbol_of b1
   iff
      ex b3 being Element of NAT st
         ex b4 being QC-variable_list of b3 st
            ex b5 being Element of b3 -ary_QC-pred_symbols st
               b2 = b5 & b1 = b5 ! b4;

:: QC_LANG1:funcnot 16 => QC_LANG1:func 16
definition
  let a1 be Element of QC-WFF;
  assume a1 is atomic;
  func the_arguments_of A1 -> FinSequence of QC-variables means
    ex b1 being Element of NAT st
       ex b2 being Element of b1 -ary_QC-pred_symbols st
          ex b3 being QC-variable_list of b1 st
             it = b3 & a1 = b2 ! b3;
end;

:: QC_LANG1:def 22
theorem
for b1 being Element of QC-WFF
   st b1 is atomic
for b2 being FinSequence of QC-variables holds
      b2 = the_arguments_of b1
   iff
      ex b3 being Element of NAT st
         ex b4 being Element of b3 -ary_QC-pred_symbols st
            ex b5 being QC-variable_list of b3 st
               b2 = b5 & b1 = b4 ! b5;

:: QC_LANG1:funcnot 17 => QC_LANG1:func 17
definition
  let a1 be Element of QC-WFF;
  assume a1 is negative;
  func the_argument_of A1 -> Element of QC-WFF means
    a1 = 'not' it;
end;

:: QC_LANG1:def 23
theorem
for b1 being Element of QC-WFF
   st b1 is negative
for b2 being Element of QC-WFF holds
      b2 = the_argument_of b1
   iff
      b1 = 'not' b2;

:: QC_LANG1:funcnot 18 => QC_LANG1:func 18
definition
  let a1 be Element of QC-WFF;
  assume a1 is conjunctive;
  func the_left_argument_of A1 -> Element of QC-WFF means
    ex b1 being Element of QC-WFF st
       a1 = it '&' b1;
end;

:: QC_LANG1:def 24
theorem
for b1 being Element of QC-WFF
   st b1 is conjunctive
for b2 being Element of QC-WFF holds
      b2 = the_left_argument_of b1
   iff
      ex b3 being Element of QC-WFF st
         b1 = b2 '&' b3;

:: QC_LANG1:funcnot 19 => QC_LANG1:func 19
definition
  let a1 be Element of QC-WFF;
  assume a1 is conjunctive;
  func the_right_argument_of A1 -> Element of QC-WFF means
    ex b1 being Element of QC-WFF st
       a1 = b1 '&' it;
end;

:: QC_LANG1:def 25
theorem
for b1 being Element of QC-WFF
   st b1 is conjunctive
for b2 being Element of QC-WFF holds
      b2 = the_right_argument_of b1
   iff
      ex b3 being Element of QC-WFF st
         b1 = b3 '&' b2;

:: QC_LANG1:funcnot 20 => QC_LANG1:func 20
definition
  let a1 be Element of QC-WFF;
  assume a1 is universal;
  func bound_in A1 -> Element of bound_QC-variables means
    ex b1 being Element of QC-WFF st
       a1 = All(it,b1);
end;

:: QC_LANG1:def 26
theorem
for b1 being Element of QC-WFF
   st b1 is universal
for b2 being Element of bound_QC-variables holds
      b2 = bound_in b1
   iff
      ex b3 being Element of QC-WFF st
         b1 = All(b2,b3);

:: QC_LANG1:funcnot 21 => QC_LANG1:func 21
definition
  let a1 be Element of QC-WFF;
  assume a1 is universal;
  func the_scope_of A1 -> Element of QC-WFF means
    ex b1 being Element of bound_QC-variables st
       a1 = All(b1,it);
end;

:: QC_LANG1:def 27
theorem
for b1 being Element of QC-WFF
   st b1 is universal
for b2 being Element of QC-WFF holds
      b2 = the_scope_of b1
   iff
      ex b3 being Element of bound_QC-variables st
         b1 = All(b3,b2);

:: QC_LANG1:th 45
theorem
for b1 being Element of QC-WFF
      st b1 is negative
   holds len @ the_argument_of b1 < len @ b1;

:: QC_LANG1:th 46
theorem
for b1 being Element of QC-WFF
      st b1 is conjunctive
   holds len @ the_left_argument_of b1 < len @ b1 &
    len @ the_right_argument_of b1 < len @ b1;

:: QC_LANG1:th 47
theorem
for b1 being Element of QC-WFF
      st b1 is universal
   holds len @ the_scope_of b1 < len @ b1;

:: QC_LANG1:sch 2
scheme QC_LANG1:sch 2
for b1 being Element of QC-WFF holds
   P1[b1]
provided
   for b1 being Element of QC-WFF holds
      (b1 is atomic implies P1[b1]) &
       P1[VERUM] &
       (b1 is negative & P1[the_argument_of b1] implies P1[b1]) &
       (b1 is conjunctive & P1[the_left_argument_of b1] & P1[the_right_argument_of b1] implies P1[b1]) &
       (b1 is universal & P1[the_scope_of b1] implies P1[b1]);


:: QC_LANG1:th 48
theorem
for b1 being Element of NAT
for b2 being Element of b1 -ary_QC-pred_symbols holds
   b2 `1 <> 0 & b2 `1 <> 1 & b2 `1 <> 2 & b2 `1 <> 3;

:: QC_LANG1:th 49
theorem
for b1 being Element of QC-WFF holds
   ((@ VERUM) . 1) `1 = 0 &
    (b1 is atomic implies ex b2 being Element of NAT st
       (@ b1) . 1 is Element of b2 -ary_QC-pred_symbols) &
    (b1 is negative implies ((@ b1) . 1) `1 = 1) &
    (b1 is conjunctive implies ((@ b1) . 1) `1 = 2) &
    (b1 is universal implies ((@ b1) . 1) `1 = 3);

:: QC_LANG1:th 50
theorem
for b1 being Element of QC-WFF
      st b1 is atomic
   holds ((@ b1) . 1) `1 <> 0 & ((@ b1) . 1) `1 <> 1 & ((@ b1) . 1) `1 <> 2 & ((@ b1) . 1) `1 <> 3;

:: QC_LANG1:th 51
theorem
VERUM is not atomic &
 VERUM is not negative &
 VERUM is not conjunctive &
 VERUM is not universal &
 (for b1 being Element of QC-WFF holds
    (b1 is atomic implies b1 is not negative) & (b1 is atomic implies b1 is not conjunctive) & (b1 is atomic implies b1 is not universal) & (b1 is negative implies b1 is not conjunctive) & (b1 is negative implies b1 is not universal) & (b1 is conjunctive implies b1 is not universal));

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


:: QC_LANG1:funcnot 22 => QC_LANG1:func 22
definition
  let a1 be FinSequence of QC-variables;
  func still_not-bound_in A1 -> Element of bool bound_QC-variables equals
    {a1 . b1 where b1 is Element of NAT: 1 <= b1 & b1 <= len a1 & a1 . b1 in bound_QC-variables};
end;

:: QC_LANG1:def 28
theorem
for b1 being FinSequence of QC-variables holds
   still_not-bound_in b1 = {b1 . b2 where b2 is Element of NAT: 1 <= b2 & b2 <= len b1 & b1 . b2 in bound_QC-variables};

:: QC_LANG1:funcnot 23 => QC_LANG1:func 23
definition
  let a1 be Element of QC-WFF;
  func still_not-bound_in A1 -> Element of bool bound_QC-variables means
    ex b1 being Function-like quasi_total Relation of QC-WFF,bool bound_QC-variables st
       it = b1 . a1 &
        (for b2 being Element of QC-WFF holds
           b1 . VERUM = {} &
            (b2 is atomic implies b1 . b2 = {(the_arguments_of b2) . b3 where b3 is Element of NAT: 1 <= b3 & b3 <= len the_arguments_of b2 & (the_arguments_of b2) . b3 in bound_QC-variables}) &
            (b2 is negative implies b1 . b2 = 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 = (b1 . the_scope_of b2) \ {bound_in b2}));
end;

:: QC_LANG1:def 29
theorem
for b1 being Element of QC-WFF
for b2 being Element of bool bound_QC-variables holds
      b2 = still_not-bound_in b1
   iff
      ex b3 being Function-like quasi_total Relation of QC-WFF,bool bound_QC-variables st
         b2 = b3 . b1 &
          (for b4 being Element of QC-WFF holds
             b3 . VERUM = {} &
              (b4 is atomic implies b3 . b4 = {(the_arguments_of b4) . b5 where b5 is Element of NAT: 1 <= b5 & b5 <= len the_arguments_of b4 & (the_arguments_of b4) . b5 in bound_QC-variables}) &
              (b4 is negative implies b3 . b4 = b3 . the_argument_of b4) &
              (b4 is conjunctive implies b3 . b4 = (b3 . the_left_argument_of b4) \/ (b3 . the_right_argument_of b4)) &
              (b4 is universal implies b3 . b4 = (b3 . the_scope_of b4) \ {bound_in b4}));

:: QC_LANG1:attrnot 6 => QC_LANG1:attr 6
definition
  let a1 be Element of QC-WFF;
  attr a1 is closed means
    still_not-bound_in a1 = {};
end;

:: QC_LANG1:dfs 30
definiens
  let a1 be Element of QC-WFF;
To prove
     a1 is closed
it is sufficient to prove
  thus still_not-bound_in a1 = {};

:: QC_LANG1:def 30
theorem
for b1 being Element of QC-WFF holds
      b1 is closed
   iff
      still_not-bound_in b1 = {};