Article ZF_LANG1, MML version 4.99.1005

:: ZF_LANG1:th 1
theorem
for b1, b2 being Element of VAR holds
Var1 (b1 '=' b2) = b1 & Var2 (b1 '=' b2) = b2;

:: ZF_LANG1:th 2
theorem
for b1, b2 being Element of VAR holds
Var1 (b1 'in' b2) = b1 & Var2 (b1 'in' b2) = b2;

:: ZF_LANG1:th 3
theorem
for b1 being ZF-formula-like FinSequence of NAT holds
   the_argument_of 'not' b1 = b1;

:: ZF_LANG1:th 4
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT holds
the_left_argument_of (b1 '&' b2) = b1 & the_right_argument_of (b1 '&' b2) = b2;

:: ZF_LANG1:th 5
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT holds
the_left_argument_of (b1 'or' b2) = b1 & the_right_argument_of (b1 'or' b2) = b2;

:: ZF_LANG1:th 6
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT holds
the_antecedent_of (b1 => b2) = b1 & the_consequent_of (b1 => b2) = b2;

:: ZF_LANG1:th 7
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT holds
the_left_side_of (b1 <=> b2) = b1 & the_right_side_of (b1 <=> b2) = b2;

:: ZF_LANG1:th 8
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2 being Element of VAR holds
   bound_in All(b2,b1) = b2 & the_scope_of All(b2,b1) = b1;

:: ZF_LANG1:th 9
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2 being Element of VAR holds
   bound_in Ex(b2,b1) = b2 & the_scope_of Ex(b2,b1) = b1;

:: ZF_LANG1:th 10
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT holds
b1 'or' b2 = ('not' b1) => b2;

:: ZF_LANG1:th 13
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2, b3 being Element of VAR holds
All(b2,b3,b1) is universal & bound_in All(b2,b3,b1) = b2 & the_scope_of All(b2,b3,b1) = All(b3,b1);

:: ZF_LANG1:th 14
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2, b3 being Element of VAR holds
Ex(b2,b3,b1) is existential & bound_in Ex(b2,b3,b1) = b2 & the_scope_of Ex(b2,b3,b1) = Ex(b3,b1);

:: ZF_LANG1:th 15
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2, b3, b4 being Element of VAR holds
All(b2,b3,b4,b1) = All(b2,All(b3,All(b4,b1))) &
 All(b2,b3,b4,b1) = All(b2,b3,All(b4,b1));

:: ZF_LANG1:th 16
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT
for b3, b4, b5, b6 being Element of VAR
      st All(b3,b4,b1) = All(b5,b6,b2)
   holds b3 = b5 & b4 = b6 & b1 = b2;

:: ZF_LANG1:th 17
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT
for b3, b4, b5, b6, b7, b8 being Element of VAR
      st All(b3,b4,b5,b1) = All(b6,b7,b8,b2)
   holds b3 = b6 & b4 = b7 & b5 = b8 & b1 = b2;

:: ZF_LANG1:th 19
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT
for b3, b4, b5, b6, b7 being Element of VAR
      st All(b3,b4,b5,b1) = All(b6,b7,b2)
   holds b3 = b6 & b4 = b7 & All(b5,b1) = b2;

:: ZF_LANG1:th 20
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT
for b3, b4, b5, b6 being Element of VAR
      st Ex(b3,b4,b1) = Ex(b5,b6,b2)
   holds b3 = b5 & b4 = b6 & b1 = b2;

:: ZF_LANG1:th 21
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2, b3, b4 being Element of VAR holds
Ex(b2,b3,b4,b1) = Ex(b2,Ex(b3,Ex(b4,b1))) &
 Ex(b2,b3,b4,b1) = Ex(b2,b3,Ex(b4,b1));

:: ZF_LANG1:th 22
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT
for b3, b4, b5, b6, b7, b8 being Element of VAR
      st Ex(b3,b4,b5,b1) = Ex(b6,b7,b8,b2)
   holds b3 = b6 & b4 = b7 & b5 = b8 & b1 = b2;

:: ZF_LANG1:th 24
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT
for b3, b4, b5, b6, b7 being Element of VAR
      st Ex(b3,b4,b5,b1) = Ex(b6,b7,b2)
   holds b3 = b6 & b4 = b7 & Ex(b5,b1) = b2;

:: ZF_LANG1:th 25
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2, b3, b4 being Element of VAR holds
All(b2,b3,b4,b1) is universal & bound_in All(b2,b3,b4,b1) = b2 & the_scope_of All(b2,b3,b4,b1) = All(b3,b4,b1);

:: ZF_LANG1:th 26
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2, b3, b4 being Element of VAR holds
Ex(b2,b3,b4,b1) is existential & bound_in Ex(b2,b3,b4,b1) = b2 & the_scope_of Ex(b2,b3,b4,b1) = Ex(b3,b4,b1);

:: ZF_LANG1:th 27
theorem
for b1 being ZF-formula-like FinSequence of NAT
      st b1 is disjunctive
   holds the_left_argument_of b1 = the_argument_of the_left_argument_of the_argument_of b1;

:: ZF_LANG1:th 28
theorem
for b1 being ZF-formula-like FinSequence of NAT
      st b1 is disjunctive
   holds the_right_argument_of b1 = the_argument_of the_right_argument_of the_argument_of b1;

:: ZF_LANG1:th 29
theorem
for b1 being ZF-formula-like FinSequence of NAT
      st b1 is conditional
   holds the_antecedent_of b1 = the_left_argument_of the_argument_of b1;

:: ZF_LANG1:th 30
theorem
for b1 being ZF-formula-like FinSequence of NAT
      st b1 is conditional
   holds the_consequent_of b1 = the_argument_of the_right_argument_of the_argument_of b1;

:: ZF_LANG1:th 31
theorem
for b1 being ZF-formula-like FinSequence of NAT
      st b1 is biconditional
   holds the_left_side_of b1 = the_antecedent_of the_left_argument_of b1 & the_left_side_of b1 = the_consequent_of the_right_argument_of b1;

:: ZF_LANG1:th 32
theorem
for b1 being ZF-formula-like FinSequence of NAT
      st b1 is biconditional
   holds the_right_side_of b1 = the_consequent_of the_left_argument_of b1 & the_right_side_of b1 = the_antecedent_of the_right_argument_of b1;

:: ZF_LANG1:th 33
theorem
for b1 being ZF-formula-like FinSequence of NAT
      st b1 is existential
   holds bound_in b1 = bound_in the_argument_of b1 & the_scope_of b1 = the_argument_of the_scope_of the_argument_of b1;

:: ZF_LANG1:th 34
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT holds
the_argument_of (b1 'or' b2) = ('not' b1) '&' 'not' b2 &
 the_antecedent_of (b1 'or' b2) = 'not' b1 &
 the_consequent_of (b1 'or' b2) = b2;

:: ZF_LANG1:th 35
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT holds
the_argument_of (b1 => b2) = b1 '&' 'not' b2;

:: ZF_LANG1:th 36
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT holds
the_left_argument_of (b1 <=> b2) = b1 => b2 & the_right_argument_of (b1 <=> b2) = b2 => b1;

:: ZF_LANG1:th 37
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2 being Element of VAR holds
   the_argument_of Ex(b2,b1) = All(b2,'not' b1);

:: ZF_LANG1:th 38
theorem
for b1 being ZF-formula-like FinSequence of NAT
      st b1 is disjunctive
   holds b1 is conditional & b1 is negative & the_argument_of b1 is conjunctive & the_left_argument_of the_argument_of b1 is negative & the_right_argument_of the_argument_of b1 is negative;

:: ZF_LANG1:th 39
theorem
for b1 being ZF-formula-like FinSequence of NAT
      st b1 is conditional
   holds b1 is negative & the_argument_of b1 is conjunctive & the_right_argument_of the_argument_of b1 is negative;

:: ZF_LANG1:th 40
theorem
for b1 being ZF-formula-like FinSequence of NAT
      st b1 is biconditional
   holds b1 is conjunctive & the_left_argument_of b1 is conditional & the_right_argument_of b1 is conditional;

:: ZF_LANG1:th 41
theorem
for b1 being ZF-formula-like FinSequence of NAT
      st b1 is existential
   holds b1 is negative & the_argument_of b1 is universal & the_scope_of the_argument_of b1 is negative;

:: ZF_LANG1:th 42
theorem
for b1 being ZF-formula-like FinSequence of NAT holds
   (b1 is being_equality implies b1 is not being_membership & b1 is not negative & b1 is not conjunctive & b1 is not universal) &
    (b1 is being_membership implies b1 is not negative & b1 is not conjunctive & b1 is not universal) &
    (b1 is negative implies b1 is not conjunctive & b1 is not universal) &
    (b1 is conjunctive implies b1 is not universal);

:: ZF_LANG1:th 43
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT
      st b1 is_subformula_of b2
   holds len b1 <= len b2;

:: ZF_LANG1:th 44
theorem
for b1, b2, b3 being ZF-formula-like FinSequence of NAT
      st ((b1 is_proper_subformula_of b2 implies not b2 is_subformula_of b3) & (b1 is_subformula_of b2 implies not b2 is_proper_subformula_of b3) & (b1 is_subformula_of b2 implies not b2 is_immediate_constituent_of b3) & (b1 is_immediate_constituent_of b2 implies not b2 is_subformula_of b3) & (b1 is_proper_subformula_of b2 implies not b2 is_immediate_constituent_of b3) implies b1 is_immediate_constituent_of b2 & b2 is_proper_subformula_of b3)
   holds b1 is_proper_subformula_of b3;

:: ZF_LANG1:th 46
theorem
for b1 being ZF-formula-like FinSequence of NAT holds
   not b1 is_immediate_constituent_of b1;

:: ZF_LANG1:th 47
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT
      st b1 is_proper_subformula_of b2
   holds not b2 is_subformula_of b1;

:: ZF_LANG1:th 48
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT
      st b1 is_proper_subformula_of b2
   holds not b2 is_proper_subformula_of b1;

:: ZF_LANG1:th 49
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT
      st b1 is_subformula_of b2
   holds not b2 is_immediate_constituent_of b1;

:: ZF_LANG1:th 50
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT
      st b1 is_proper_subformula_of b2
   holds not b2 is_immediate_constituent_of b1;

:: ZF_LANG1:th 51
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT
      st 'not' b1 is_subformula_of b2
   holds b1 is_proper_subformula_of b2;

:: ZF_LANG1:th 52
theorem
for b1, b2, b3 being ZF-formula-like FinSequence of NAT
      st b1 '&' b2 is_subformula_of b3
   holds b1 is_proper_subformula_of b3 & b2 is_proper_subformula_of b3;

:: ZF_LANG1:th 53
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT
for b3 being Element of VAR
      st All(b3,b1) is_subformula_of b2
   holds b1 is_proper_subformula_of b2;

:: ZF_LANG1:th 54
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT holds
b1 '&' 'not' b2 is_proper_subformula_of b1 => b2 & b1 is_proper_subformula_of b1 => b2 & 'not' b2 is_proper_subformula_of b1 => b2 & b2 is_proper_subformula_of b1 => b2;

:: ZF_LANG1:th 55
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT holds
('not' b1) '&' 'not' b2 is_proper_subformula_of b1 'or' b2 &
 'not' b1 is_proper_subformula_of b1 'or' b2 &
 'not' b2 is_proper_subformula_of b1 'or' b2 &
 b1 is_proper_subformula_of b1 'or' b2 &
 b2 is_proper_subformula_of b1 'or' b2;

:: ZF_LANG1:th 56
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2 being Element of VAR holds
   All(b2,'not' b1) is_proper_subformula_of Ex(b2,b1) & 'not' b1 is_proper_subformula_of Ex(b2,b1);

:: ZF_LANG1:th 57
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT holds
   b1 is_subformula_of b2
iff
   b1 in Subformulae b2;

:: ZF_LANG1:th 58
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT
      st b1 in Subformulae b2
   holds Subformulae b1 c= Subformulae b2;

:: ZF_LANG1:th 59
theorem
for b1 being ZF-formula-like FinSequence of NAT holds
   b1 in Subformulae b1;

:: ZF_LANG1:th 60
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT holds
Subformulae (b1 => b2) = ((Subformulae b1) \/ Subformulae b2) \/ {'not' b2,b1 '&' 'not' b2,b1 => b2};

:: ZF_LANG1:th 61
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT holds
Subformulae (b1 'or' b2) = ((Subformulae b1) \/ Subformulae b2) \/ {'not' b2,'not' b1,('not' b1) '&' 'not' b2,b1 'or' b2};

:: ZF_LANG1:th 62
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT holds
Subformulae (b1 <=> b2) = ((Subformulae b1) \/ Subformulae b2) \/ {'not' b2,b1 '&' 'not' b2,b1 => b2,'not' b1,b2 '&' 'not' b1,b2 => b1,b1 <=> b2};

:: ZF_LANG1:th 63
theorem
for b1, b2 being Element of VAR holds
Free (b1 '=' b2) = {b1,b2};

:: ZF_LANG1:th 64
theorem
for b1, b2 being Element of VAR holds
Free (b1 'in' b2) = {b1,b2};

:: ZF_LANG1:th 65
theorem
for b1 being ZF-formula-like FinSequence of NAT holds
   Free 'not' b1 = Free b1;

:: ZF_LANG1:th 66
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT holds
Free (b1 '&' b2) = (Free b1) \/ Free b2;

:: ZF_LANG1:th 67
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2 being Element of VAR holds
   Free All(b2,b1) = (Free b1) \ {b2};

:: ZF_LANG1:th 68
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT holds
Free (b1 'or' b2) = (Free b1) \/ Free b2;

:: ZF_LANG1:th 69
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT holds
Free (b1 => b2) = (Free b1) \/ Free b2;

:: ZF_LANG1:th 70
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT holds
Free (b1 <=> b2) = (Free b1) \/ Free b2;

:: ZF_LANG1:th 71
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2 being Element of VAR holds
   Free Ex(b2,b1) = (Free b1) \ {b2};

:: ZF_LANG1:th 72
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2, b3 being Element of VAR holds
Free All(b2,b3,b1) = (Free b1) \ {b2,b3};

:: ZF_LANG1:th 73
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2, b3, b4 being Element of VAR holds
Free All(b2,b3,b4,b1) = (Free b1) \ {b2,b3,b4};

:: ZF_LANG1:th 74
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2, b3 being Element of VAR holds
Free Ex(b2,b3,b1) = (Free b1) \ {b2,b3};

:: ZF_LANG1:th 75
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2, b3, b4 being Element of VAR holds
Free Ex(b2,b3,b4,b1) = (Free b1) \ {b2,b3,b4};

:: ZF_LANG1:sch 1
scheme ZF_LANG1:sch 1
for b1 being ZF-formula-like FinSequence of NAT holds
   P1[b1]
provided
   for b1, b2 being Element of VAR holds
   P1[b1 '=' b2] & P1[b1 'in' b2]
and
   for b1 being ZF-formula-like FinSequence of NAT
         st P1[b1]
      holds P1['not' b1]
and
   for b1, b2 being ZF-formula-like FinSequence of NAT
         st P1[b1] & P1[b2]
      holds P1[b1 '&' b2]
and
   for b1 being ZF-formula-like FinSequence of NAT
   for b2 being Element of VAR
         st P1[b1]
      holds P1[All(b2,b1)];


:: ZF_LANG1:funcnot 1 => ZF_LANG1:func 1
definition
  let a1 be non empty set;
  let a2 be Function-like quasi_total Relation of VAR,a1;
  let a3 be Element of VAR;
  let a4 be Element of a1;
  func A2 /(A3,A4) -> Function-like quasi_total Relation of VAR,a1 means
    it . a3 = a4 &
     (for b1 being Element of VAR
           st it . b1 <> a2 . b1
        holds a3 = b1);
end;

:: ZF_LANG1:def 1
theorem
for b1 being non empty set
for b2 being Function-like quasi_total Relation of VAR,b1
for b3 being Element of VAR
for b4 being Element of b1
for b5 being Function-like quasi_total Relation of VAR,b1 holds
      b5 = b2 /(b3,b4)
   iff
      b5 . b3 = b4 &
       (for b6 being Element of VAR
             st b5 . b6 <> b2 . b6
          holds b3 = b6);

:: ZF_LANG1:funcnot 2 => ZF_LANG1:func 2
definition
  let a1, a2, a3 be non empty set;
  let a4 be Function-like quasi_total Relation of a1,a2;
  assume a2 c= a3;
  func A3 ! A4 -> Function-like quasi_total Relation of a1,a3 equals
    a4;
end;

:: ZF_LANG1:def 2
theorem
for b1, b2, b3 being non empty set
for b4 being Function-like quasi_total Relation of b1,b2
      st b2 c= b3
   holds b3 ! b4 = b4;

:: ZF_LANG1:th 78
theorem
for b1 being Element of VAR
for b2 being non empty set
for b3, b4 being Element of b2
for b5 being Function-like quasi_total Relation of VAR,b2 holds
   (b5 /(b1,b3)) /(b1,b4) = b5 /(b1,b4) & b5 /(b1,b5 . b1) = b5;

:: ZF_LANG1:th 79
theorem
for b1, b2 being Element of VAR
for b3 being non empty set
for b4, b5 being Element of b3
for b6 being Function-like quasi_total Relation of VAR,b3
      st b1 <> b2
   holds (b6 /(b1,b4)) /(b2,b5) = (b6 /(b2,b5)) /(b1,b4);

:: ZF_LANG1:th 80
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2 being Element of VAR
for b3 being non empty set
for b4 being Function-like quasi_total Relation of VAR,b3 holds
      b3,b4 |= All(b2,b1)
   iff
      for b5 being Element of b3 holds
         b3,b4 /(b2,b5) |= b1;

:: ZF_LANG1:th 81
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2 being Element of VAR
for b3 being non empty set
for b4 being Element of b3
for b5 being Function-like quasi_total Relation of VAR,b3 holds
      b3,b5 |= All(b2,b1)
   iff
      b3,b5 /(b2,b4) |= All(b2,b1);

:: ZF_LANG1:th 82
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2 being Element of VAR
for b3 being non empty set
for b4 being Function-like quasi_total Relation of VAR,b3 holds
      b3,b4 |= Ex(b2,b1)
   iff
      ex b5 being Element of b3 st
         b3,b4 /(b2,b5) |= b1;

:: ZF_LANG1:th 83
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2 being Element of VAR
for b3 being non empty set
for b4 being Element of b3
for b5 being Function-like quasi_total Relation of VAR,b3 holds
      b3,b5 |= Ex(b2,b1)
   iff
      b3,b5 /(b2,b4) |= Ex(b2,b1);

:: ZF_LANG1:th 84
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2 being non empty set
for b3, b4 being Function-like quasi_total Relation of VAR,b2
      st (for b5 being Element of VAR
               st b5 in Free b1
            holds b4 . b5 = b3 . b5) &
         b2,b3 |= b1
   holds b2,b4 |= b1;

:: ZF_LANG1:th 85
theorem
for b1 being ZF-formula-like FinSequence of NAT holds
   Free b1 is finite;

:: ZF_LANG1:funcreg 1
registration
  let a1 be ZF-formula-like FinSequence of NAT;
  cluster Free a1 -> finite;
end;

:: ZF_LANG1:th 86
theorem
for b1, b2 being Element of NAT
      st x. b1 = x. b2
   holds b1 = b2;

:: ZF_LANG1:th 87
theorem
for b1 being Element of VAR holds
   ex b2 being Element of NAT st
      b1 = x. b2;

:: ZF_LANG1:th 89
theorem
for b1 being Element of VAR
for b2 being non empty set
for b3 being Function-like quasi_total Relation of VAR,b2 holds
   b2,b3 |= b1 '=' b1;

:: ZF_LANG1:th 90
theorem
for b1 being Element of VAR
for b2 being non empty set holds
   b2 |= b1 '=' b1;

:: ZF_LANG1:th 91
theorem
for b1 being Element of VAR
for b2 being non empty set
for b3 being Function-like quasi_total Relation of VAR,b2 holds
   not b2,b3 |= b1 'in' b1;

:: ZF_LANG1:th 92
theorem
for b1 being Element of VAR
for b2 being non empty set holds
   not b2 |= b1 'in' b1 & b2 |= 'not' (b1 'in' b1);

:: ZF_LANG1:th 93
theorem
for b1, b2 being Element of VAR
for b3 being non empty set holds
      b3 |= b1 '=' b2
   iff
      (b1 <> b2 implies ex b4 being set st
         {b4} = b3);

:: ZF_LANG1:th 94
theorem
for b1, b2 being Element of VAR
for b3 being non empty set holds
      b3 |= 'not' (b1 'in' b2)
   iff
      (b1 = b2 or for b4 being set
            st b4 in b3
         holds b4 misses b3);

:: ZF_LANG1:th 95
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2 being non empty set
for b3 being Function-like quasi_total Relation of VAR,b2
      st b1 is being_equality
   holds    b2,b3 |= b1
   iff
      b3 . Var1 b1 = b3 . Var2 b1;

:: ZF_LANG1:th 96
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2 being non empty set
for b3 being Function-like quasi_total Relation of VAR,b2
      st b1 is being_membership
   holds    b2,b3 |= b1
   iff
      b3 . Var1 b1 in b3 . Var2 b1;

:: ZF_LANG1:th 97
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2 being non empty set
for b3 being Function-like quasi_total Relation of VAR,b2
      st b1 is negative
   holds    b2,b3 |= b1
   iff
      not b2,b3 |= the_argument_of b1;

:: ZF_LANG1:th 98
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2 being non empty set
for b3 being Function-like quasi_total Relation of VAR,b2
      st b1 is conjunctive
   holds    b2,b3 |= b1
   iff
      b2,b3 |= the_left_argument_of b1 & b2,b3 |= the_right_argument_of b1;

:: ZF_LANG1:th 99
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2 being non empty set
for b3 being Function-like quasi_total Relation of VAR,b2
      st b1 is universal
   holds    b2,b3 |= b1
   iff
      for b4 being Element of b2 holds
         b2,b3 /(bound_in b1,b4) |= the_scope_of b1;

:: ZF_LANG1:th 100
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2 being non empty set
for b3 being Function-like quasi_total Relation of VAR,b2
      st b1 is disjunctive
   holds    b2,b3 |= b1
   iff
      (b2,b3 |= the_left_argument_of b1 or b2,b3 |= the_right_argument_of b1);

:: ZF_LANG1:th 101
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2 being non empty set
for b3 being Function-like quasi_total Relation of VAR,b2
      st b1 is conditional
   holds    b2,b3 |= b1
   iff
      (b2,b3 |= the_antecedent_of b1 implies b2,b3 |= the_consequent_of b1);

:: ZF_LANG1:th 102
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2 being non empty set
for b3 being Function-like quasi_total Relation of VAR,b2
      st b1 is biconditional
   holds    b2,b3 |= b1
   iff
         b2,b3 |= the_left_side_of b1
      iff
         b2,b3 |= the_right_side_of b1;

:: ZF_LANG1:th 103
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2 being non empty set
for b3 being Function-like quasi_total Relation of VAR,b2
      st b1 is existential
   holds    b2,b3 |= b1
   iff
      ex b4 being Element of b2 st
         b2,b3 /(bound_in b1,b4) |= the_scope_of b1;

:: ZF_LANG1:th 104
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2 being Element of VAR
for b3 being non empty set holds
      b3 |= Ex(b2,b1)
   iff
      for b4 being Function-like quasi_total Relation of VAR,b3 holds
         ex b5 being Element of b3 st
            b3,b4 /(b2,b5) |= b1;

:: ZF_LANG1:th 105
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2 being Element of VAR
for b3 being non empty set
      st b3 |= b1
   holds b3 |= Ex(b2,b1);

:: ZF_LANG1:th 106
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2, b3 being Element of VAR
for b4 being non empty set holds
      b4 |= b1
   iff
      b4 |= All(b2,b3,b1);

:: ZF_LANG1:th 107
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2, b3 being Element of VAR
for b4 being non empty set
      st b4 |= b1
   holds b4 |= Ex(b2,b3,b1);

:: ZF_LANG1:th 108
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2, b3, b4 being Element of VAR
for b5 being non empty set holds
      b5 |= b1
   iff
      b5 |= All(b2,b3,b4,b1);

:: ZF_LANG1:th 109
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2, b3, b4 being Element of VAR
for b5 being non empty set
      st b5 |= b1
   holds b5 |= Ex(b2,b3,b4,b1);

:: ZF_LANG1:th 110
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT
for b3 being non empty set
for b4 being Function-like quasi_total Relation of VAR,b3 holds
   b3,b4 |= (b1 <=> b2) => (b1 => b2) & b3 |= (b1 <=> b2) => (b1 => b2);

:: ZF_LANG1:th 111
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT
for b3 being non empty set
for b4 being Function-like quasi_total Relation of VAR,b3 holds
   b3,b4 |= (b1 <=> b2) => (b2 => b1) & b3 |= (b1 <=> b2) => (b2 => b1);

:: ZF_LANG1:th 112
theorem
for b1, b2, b3 being ZF-formula-like FinSequence of NAT
for b4 being non empty set holds
   b4 |= (b1 => b2) => ((b2 => b3) => (b1 => b3));

:: ZF_LANG1:th 113
theorem
for b1, b2, b3 being ZF-formula-like FinSequence of NAT
for b4 being non empty set
for b5 being Function-like quasi_total Relation of VAR,b4
      st b4,b5 |= b1 => b2 & b4,b5 |= b2 => b3
   holds b4,b5 |= b1 => b3;

:: ZF_LANG1:th 114
theorem
for b1, b2, b3 being ZF-formula-like FinSequence of NAT
for b4 being non empty set
      st b4 |= b1 => b2 & b4 |= b2 => b3
   holds b4 |= b1 => b3;

:: ZF_LANG1:th 115
theorem
for b1, b2, b3 being ZF-formula-like FinSequence of NAT
for b4 being non empty set
for b5 being Function-like quasi_total Relation of VAR,b4 holds
   b4,b5 |= ((b1 => b2) '&' (b2 => b3)) => (b1 => b3) &
    b4 |= ((b1 => b2) '&' (b2 => b3)) => (b1 => b3);

:: ZF_LANG1:th 116
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT
for b3 being non empty set
for b4 being Function-like quasi_total Relation of VAR,b3 holds
   b3,b4 |= b1 => (b2 => b1) & b3 |= b1 => (b2 => b1);

:: ZF_LANG1:th 117
theorem
for b1, b2, b3 being ZF-formula-like FinSequence of NAT
for b4 being non empty set
for b5 being Function-like quasi_total Relation of VAR,b4 holds
   b4,b5 |= (b1 => (b2 => b3)) => ((b1 => b2) => (b1 => b3)) &
    b4 |= (b1 => (b2 => b3)) => ((b1 => b2) => (b1 => b3));

:: ZF_LANG1:th 118
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT
for b3 being non empty set
for b4 being Function-like quasi_total Relation of VAR,b3 holds
   b3,b4 |= (b1 '&' b2) => b1 & b3 |= (b1 '&' b2) => b1;

:: ZF_LANG1:th 119
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT
for b3 being non empty set
for b4 being Function-like quasi_total Relation of VAR,b3 holds
   b3,b4 |= (b1 '&' b2) => b2 & b3 |= (b1 '&' b2) => b2;

:: ZF_LANG1:th 120
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT
for b3 being non empty set
for b4 being Function-like quasi_total Relation of VAR,b3 holds
   b3,b4 |= (b1 '&' b2) => (b2 '&' b1) & b3 |= (b1 '&' b2) => (b2 '&' b1);

:: ZF_LANG1:th 121
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2 being non empty set
for b3 being Function-like quasi_total Relation of VAR,b2 holds
   b2,b3 |= b1 => (b1 '&' b1) & b2 |= b1 => (b1 '&' b1);

:: ZF_LANG1:th 122
theorem
for b1, b2, b3 being ZF-formula-like FinSequence of NAT
for b4 being non empty set
for b5 being Function-like quasi_total Relation of VAR,b4 holds
   b4,b5 |= (b1 => b2) => ((b1 => b3) => (b1 => (b2 '&' b3))) &
    b4 |= (b1 => b2) => ((b1 => b3) => (b1 => (b2 '&' b3)));

:: ZF_LANG1:th 123
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT
for b3 being non empty set
for b4 being Function-like quasi_total Relation of VAR,b3 holds
   b3,b4 |= b1 => (b1 'or' b2) & b3 |= b1 => (b1 'or' b2);

:: ZF_LANG1:th 124
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT
for b3 being non empty set
for b4 being Function-like quasi_total Relation of VAR,b3 holds
   b3,b4 |= b1 => (b2 'or' b1) & b3 |= b1 => (b2 'or' b1);

:: ZF_LANG1:th 125
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT
for b3 being non empty set
for b4 being Function-like quasi_total Relation of VAR,b3 holds
   b3,b4 |= (b1 'or' b2) => (b2 'or' b1) & b3 |= (b1 'or' b2) => (b2 'or' b1);

:: ZF_LANG1:th 126
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2 being non empty set
for b3 being Function-like quasi_total Relation of VAR,b2 holds
   b2,b3 |= b1 => (b1 'or' b1) & b2 |= b1 => (b1 'or' b1);

:: ZF_LANG1:th 127
theorem
for b1, b2, b3 being ZF-formula-like FinSequence of NAT
for b4 being non empty set
for b5 being Function-like quasi_total Relation of VAR,b4 holds
   b4,b5 |= (b1 => b2) => ((b3 => b2) => ((b1 'or' b3) => b2)) &
    b4 |= (b1 => b2) => ((b3 => b2) => ((b1 'or' b3) => b2));

:: ZF_LANG1:th 128
theorem
for b1, b2, b3 being ZF-formula-like FinSequence of NAT
for b4 being non empty set
for b5 being Function-like quasi_total Relation of VAR,b4 holds
   b4,b5 |= ((b1 => b2) '&' (b3 => b2)) => ((b1 'or' b3) => b2) &
    b4 |= ((b1 => b2) '&' (b3 => b2)) => ((b1 'or' b3) => b2);

:: ZF_LANG1:th 129
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT
for b3 being non empty set
for b4 being Function-like quasi_total Relation of VAR,b3 holds
   b3,b4 |= (b1 => 'not' b2) => (b2 => 'not' b1) &
    b3 |= (b1 => 'not' b2) => (b2 => 'not' b1);

:: ZF_LANG1:th 130
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT
for b3 being non empty set
for b4 being Function-like quasi_total Relation of VAR,b3 holds
   b3,b4 |= ('not' b1) => (b1 => b2) & b3 |= ('not' b1) => (b1 => b2);

:: ZF_LANG1:th 131
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT
for b3 being non empty set
for b4 being Function-like quasi_total Relation of VAR,b3 holds
   b3,b4 |= ((b1 => b2) '&' (b1 => 'not' b2)) => 'not' b1 &
    b3 |= ((b1 => b2) '&' (b1 => 'not' b2)) => 'not' b1;

:: ZF_LANG1:th 133
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT
for b3 being non empty set
      st b3 |= b1 => b2 & b3 |= b1
   holds b3 |= b2;

:: ZF_LANG1:th 134
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT
for b3 being non empty set
for b4 being Function-like quasi_total Relation of VAR,b3 holds
   b3,b4 |= ('not' (b1 '&' b2)) => (('not' b1) 'or' 'not' b2) &
    b3 |= ('not' (b1 '&' b2)) => (('not' b1) 'or' 'not' b2);

:: ZF_LANG1:th 135
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT
for b3 being non empty set
for b4 being Function-like quasi_total Relation of VAR,b3 holds
   b3,b4 |= (('not' b1) 'or' 'not' b2) => 'not' (b1 '&' b2) &
    b3 |= (('not' b1) 'or' 'not' b2) => 'not' (b1 '&' b2);

:: ZF_LANG1:th 136
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT
for b3 being non empty set
for b4 being Function-like quasi_total Relation of VAR,b3 holds
   b3,b4 |= ('not' (b1 'or' b2)) => (('not' b1) '&' 'not' b2) &
    b3 |= ('not' (b1 'or' b2)) => (('not' b1) '&' 'not' b2);

:: ZF_LANG1:th 137
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT
for b3 being non empty set
for b4 being Function-like quasi_total Relation of VAR,b3 holds
   b3,b4 |= (('not' b1) '&' 'not' b2) => 'not' (b1 'or' b2) &
    b3 |= (('not' b1) '&' 'not' b2) => 'not' (b1 'or' b2);

:: ZF_LANG1:th 138
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2 being Element of VAR
for b3 being non empty set holds
   b3 |= (All(b2,b1)) => b1;

:: ZF_LANG1:th 139
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2 being Element of VAR
for b3 being non empty set holds
   b3 |= b1 => Ex(b2,b1);

:: ZF_LANG1:th 140
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT
for b3 being Element of VAR
for b4 being non empty set
      st not b3 in Free b1
   holds b4 |= (All(b3,b1 => b2)) => (b1 => All(b3,b2));

:: ZF_LANG1:th 141
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT
for b3 being Element of VAR
for b4 being non empty set
      st not b3 in Free b1 & b4 |= b1 => b2
   holds b4 |= b1 => All(b3,b2);

:: ZF_LANG1:th 142
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT
for b3 being Element of VAR
for b4 being non empty set
      st not b3 in Free b1
   holds b4 |= (All(b3,b2 => b1)) => ((Ex(b3,b2)) => b1);

:: ZF_LANG1:th 143
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT
for b3 being Element of VAR
for b4 being non empty set
      st not b3 in Free b1 & b4 |= b2 => b1
   holds b4 |= (Ex(b3,b2)) => b1;

:: ZF_LANG1:th 144
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT
for b3 being Element of VAR
for b4 being non empty set
      st b4 |= b1 => All(b3,b2)
   holds b4 |= b1 => b2;

:: ZF_LANG1:th 145
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT
for b3 being Element of VAR
for b4 being non empty set
      st b4 |= (Ex(b3,b1)) => b2
   holds b4 |= b1 => b2;

:: ZF_LANG1:th 146
theorem
WFF c= bool [:NAT,NAT:];

:: ZF_LANG1:funcnot 3 => ZF_LANG1:func 3
definition
  let a1 be ZF-formula-like FinSequence of NAT;
  func variables_in A1 -> set equals
    (proj2 a1) \ {0,1,2,3,4};
end;

:: ZF_LANG1:def 3
theorem
for b1 being ZF-formula-like FinSequence of NAT holds
   variables_in b1 = (proj2 b1) \ {0,1,2,3,4};

:: ZF_LANG1:th 148
theorem
for b1 being Element of VAR holds
   b1 <> 0 & b1 <> 1 & b1 <> 2 & b1 <> 3 & b1 <> 4;

:: ZF_LANG1:th 149
theorem
for b1 being Element of VAR holds
   not b1 in {0,1,2,3,4};

:: ZF_LANG1:th 150
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2 being set
      st b2 in variables_in b1
   holds b2 <> 0 & b2 <> 1 & b2 <> 2 & b2 <> 3 & b2 <> 4;

:: ZF_LANG1:th 151
theorem
for b1, b2 being Element of VAR holds
variables_in (b1 '=' b2) = {b1,b2};

:: ZF_LANG1:th 152
theorem
for b1, b2 being Element of VAR holds
variables_in (b1 'in' b2) = {b1,b2};

:: ZF_LANG1:th 153
theorem
for b1 being ZF-formula-like FinSequence of NAT holds
   variables_in 'not' b1 = variables_in b1;

:: ZF_LANG1:th 154
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT holds
variables_in (b1 '&' b2) = (variables_in b1) \/ variables_in b2;

:: ZF_LANG1:th 155
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2 being Element of VAR holds
   variables_in All(b2,b1) = (variables_in b1) \/ {b2};

:: ZF_LANG1:th 156
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT holds
variables_in (b1 'or' b2) = (variables_in b1) \/ variables_in b2;

:: ZF_LANG1:th 157
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT holds
variables_in (b1 => b2) = (variables_in b1) \/ variables_in b2;

:: ZF_LANG1:th 158
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT holds
variables_in (b1 <=> b2) = (variables_in b1) \/ variables_in b2;

:: ZF_LANG1:th 159
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2 being Element of VAR holds
   variables_in Ex(b2,b1) = (variables_in b1) \/ {b2};

:: ZF_LANG1:th 160
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2, b3 being Element of VAR holds
variables_in All(b2,b3,b1) = (variables_in b1) \/ {b2,b3};

:: ZF_LANG1:th 161
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2, b3 being Element of VAR holds
variables_in Ex(b2,b3,b1) = (variables_in b1) \/ {b2,b3};

:: ZF_LANG1:th 162
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2, b3, b4 being Element of VAR holds
variables_in All(b2,b3,b4,b1) = (variables_in b1) \/ {b2,b3,b4};

:: ZF_LANG1:th 163
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2, b3, b4 being Element of VAR holds
variables_in Ex(b2,b3,b4,b1) = (variables_in b1) \/ {b2,b3,b4};

:: ZF_LANG1:th 164
theorem
for b1 being ZF-formula-like FinSequence of NAT holds
   Free b1 c= variables_in b1;

:: ZF_LANG1:funcnot 4 => ZF_LANG1:func 4
definition
  let a1 be ZF-formula-like FinSequence of NAT;
  redefine func variables_in a1 -> non empty Element of bool VAR;
end;

:: ZF_LANG1:funcnot 5 => ZF_LANG1:func 5
definition
  let a1 be ZF-formula-like FinSequence of NAT;
  let a2, a3 be Element of VAR;
  func A1 /(A2,A3) -> Relation-like Function-like set means
    proj1 it = dom a1 &
     (for b1 being set
           st b1 in dom a1
        holds (a1 . b1 = a2 implies it . b1 = a3) &
         (a1 . b1 = a2 or it . b1 = a1 . b1));
end;

:: ZF_LANG1:def 4
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2, b3 being Element of VAR
for b4 being Relation-like Function-like set holds
      b4 = b1 /(b2,b3)
   iff
      proj1 b4 = dom b1 &
       (for b5 being set
             st b5 in dom b1
          holds (b1 . b5 = b2 implies b4 . b5 = b3) &
           (b1 . b5 = b2 or b4 . b5 = b1 . b5));

:: ZF_LANG1:th 166
theorem
for b1, b2, b3, b4, b5, b6 being Element of VAR holds
   (b1 '=' b2) /(b3,b4) = b5 '=' b6
iff
   ((b1 <> b3 & b2 <> b3 & b5 = b1 implies b6 <> b2) &
    (b1 = b3 & b2 <> b3 & b5 = b4 implies b6 <> b2) &
    (b1 <> b3 & b2 = b3 & b5 = b1 implies b6 <> b4) implies b1 = b3 & b2 = b3 & b5 = b4 & b6 = b4);

:: ZF_LANG1:th 167
theorem
for b1, b2, b3, b4 being Element of VAR holds
ex b5, b6 being Element of VAR st
   (b1 '=' b2) /(b3,b4) = b5 '=' b6;

:: ZF_LANG1:th 168
theorem
for b1, b2, b3, b4, b5, b6 being Element of VAR holds
   (b1 'in' b2) /(b3,b4) = b5 'in' b6
iff
   ((b1 <> b3 & b2 <> b3 & b5 = b1 implies b6 <> b2) &
    (b1 = b3 & b2 <> b3 & b5 = b4 implies b6 <> b2) &
    (b1 <> b3 & b2 = b3 & b5 = b1 implies b6 <> b4) implies b1 = b3 & b2 = b3 & b5 = b4 & b6 = b4);

:: ZF_LANG1:th 169
theorem
for b1, b2, b3, b4 being Element of VAR holds
ex b5, b6 being Element of VAR st
   (b1 'in' b2) /(b3,b4) = b5 'in' b6;

:: ZF_LANG1:th 170
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT
for b3, b4 being Element of VAR holds
   'not' b1 = ('not' b2) /(b3,b4)
iff
   b1 = b2 /(b3,b4);

:: ZF_LANG1:th 171
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2, b3 being Element of VAR holds
b1 /(b2,b3) in WFF;

:: ZF_LANG1:funcnot 6 => ZF_LANG1:func 6
definition
  let a1 be ZF-formula-like FinSequence of NAT;
  let a2, a3 be Element of VAR;
  redefine func a1 /(a2,a3) -> ZF-formula-like FinSequence of NAT;
end;

:: ZF_LANG1:th 172
theorem
for b1, b2, b3, b4 being ZF-formula-like FinSequence of NAT
for b5, b6 being Element of VAR holds
   b1 '&' b2 = (b3 '&' b4) /(b5,b6)
iff
   b1 = b3 /(b5,b6) & b2 = b4 /(b5,b6);

:: ZF_LANG1:th 173
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT
for b3, b4, b5 being Element of VAR
      st b3 <> b4
   holds    All(b3,b1) = (All(b3,b2)) /(b4,b5)
   iff
      b1 = b2 /(b4,b5);

:: ZF_LANG1:th 174
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT
for b3, b4 being Element of VAR holds
   All(b3,b1) = (All(b4,b2)) /(b4,b3)
iff
   b1 = b2 /(b4,b3);

:: ZF_LANG1:th 175
theorem
for b1, b2, b3, b4 being ZF-formula-like FinSequence of NAT
for b5, b6 being Element of VAR holds
   b1 'or' b2 = (b3 'or' b4) /(b5,b6)
iff
   b1 = b3 /(b5,b6) & b2 = b4 /(b5,b6);

:: ZF_LANG1:th 176
theorem
for b1, b2, b3, b4 being ZF-formula-like FinSequence of NAT
for b5, b6 being Element of VAR holds
   b1 => b2 = (b3 => b4) /(b5,b6)
iff
   b1 = b3 /(b5,b6) & b2 = b4 /(b5,b6);

:: ZF_LANG1:th 177
theorem
for b1, b2, b3, b4 being ZF-formula-like FinSequence of NAT
for b5, b6 being Element of VAR holds
   b1 <=> b2 = (b3 <=> b4) /(b5,b6)
iff
   b1 = b3 /(b5,b6) & b2 = b4 /(b5,b6);

:: ZF_LANG1:th 178
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT
for b3, b4, b5 being Element of VAR
      st b3 <> b4
   holds    Ex(b3,b1) = (Ex(b3,b2)) /(b4,b5)
   iff
      b1 = b2 /(b4,b5);

:: ZF_LANG1:th 179
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT
for b3, b4 being Element of VAR holds
   Ex(b3,b1) = (Ex(b4,b2)) /(b4,b3)
iff
   b1 = b2 /(b4,b3);

:: ZF_LANG1:th 180
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2, b3 being Element of VAR holds
   b1 is being_equality
iff
   b1 /(b2,b3) is being_equality;

:: ZF_LANG1:th 181
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2, b3 being Element of VAR holds
   b1 is being_membership
iff
   b1 /(b2,b3) is being_membership;

:: ZF_LANG1:th 182
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2, b3 being Element of VAR holds
   b1 is negative
iff
   b1 /(b2,b3) is negative;

:: ZF_LANG1:th 183
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2, b3 being Element of VAR holds
   b1 is conjunctive
iff
   b1 /(b2,b3) is conjunctive;

:: ZF_LANG1:th 184
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2, b3 being Element of VAR holds
   b1 is universal
iff
   b1 /(b2,b3) is universal;

:: ZF_LANG1:th 185
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2, b3 being Element of VAR
      st b1 is negative
   holds the_argument_of (b1 /(b2,b3)) = (the_argument_of b1) /(b2,b3);

:: ZF_LANG1:th 186
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2, b3 being Element of VAR
      st b1 is conjunctive
   holds the_left_argument_of (b1 /(b2,b3)) = (the_left_argument_of b1) /(b2,b3) &
    the_right_argument_of (b1 /(b2,b3)) = (the_right_argument_of b1) /(b2,b3);

:: ZF_LANG1:th 187
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2, b3 being Element of VAR
      st b1 is universal
   holds the_scope_of (b1 /(b2,b3)) = (the_scope_of b1) /(b2,b3) &
    (bound_in b1 = b2 implies bound_in (b1 /(b2,b3)) = b3) &
    (bound_in b1 = b2 or bound_in (b1 /(b2,b3)) = bound_in b1);

:: ZF_LANG1:th 188
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2, b3 being Element of VAR holds
   b1 is disjunctive
iff
   b1 /(b2,b3) is disjunctive;

:: ZF_LANG1:th 189
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2, b3 being Element of VAR holds
   b1 is conditional
iff
   b1 /(b2,b3) is conditional;

:: ZF_LANG1:th 190
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2, b3 being Element of VAR
      st b1 is biconditional
   holds b1 /(b2,b3) is biconditional;

:: ZF_LANG1:th 191
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2, b3 being Element of VAR holds
   b1 is existential
iff
   b1 /(b2,b3) is existential;

:: ZF_LANG1:th 192
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2, b3 being Element of VAR
      st b1 is disjunctive
   holds the_left_argument_of (b1 /(b2,b3)) = (the_left_argument_of b1) /(b2,b3) &
    the_right_argument_of (b1 /(b2,b3)) = (the_right_argument_of b1) /(b2,b3);

:: ZF_LANG1:th 193
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2, b3 being Element of VAR
      st b1 is conditional
   holds the_antecedent_of (b1 /(b2,b3)) = (the_antecedent_of b1) /(b2,b3) &
    the_consequent_of (b1 /(b2,b3)) = (the_consequent_of b1) /(b2,b3);

:: ZF_LANG1:th 194
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2, b3 being Element of VAR
      st b1 is biconditional
   holds the_left_side_of (b1 /(b2,b3)) = (the_left_side_of b1) /(b2,b3) &
    the_right_side_of (b1 /(b2,b3)) = (the_right_side_of b1) /(b2,b3);

:: ZF_LANG1:th 195
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2, b3 being Element of VAR
      st b1 is existential
   holds the_scope_of (b1 /(b2,b3)) = (the_scope_of b1) /(b2,b3) &
    (bound_in b1 = b2 implies bound_in (b1 /(b2,b3)) = b3) &
    (bound_in b1 = b2 or bound_in (b1 /(b2,b3)) = bound_in b1);

:: ZF_LANG1:th 196
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2, b3 being Element of VAR
      st not b2 in variables_in b1
   holds b1 /(b2,b3) = b1;

:: ZF_LANG1:th 197
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2 being Element of VAR holds
   b1 /(b2,b2) = b1;

:: ZF_LANG1:th 198
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2, b3 being Element of VAR
      st b2 <> b3
   holds not b2 in variables_in (b1 /(b2,b3));

:: ZF_LANG1:th 199
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2, b3 being Element of VAR
      st b2 in variables_in b1
   holds b3 in variables_in (b1 /(b2,b3));

:: ZF_LANG1:th 200
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2, b3, b4 being Element of VAR
      st b2 <> b3
   holds (b1 /(b2,b3)) /(b2,b4) = b1 /(b2,b3);

:: ZF_LANG1:th 201
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2, b3 being Element of VAR holds
variables_in (b1 /(b2,b3)) c= ((variables_in b1) \ {b2}) \/ {b3};