Article ZF_LANG, MML version 4.99.1005

:: ZF_LANG:funcnot 1 => ZF_LANG:func 1
definition
  func VAR -> Element of bool NAT equals
    {b1 where b1 is Element of NAT: 5 <= b1};
end;

:: ZF_LANG:def 1
theorem
VAR = {b1 where b1 is Element of NAT: 5 <= b1};

:: ZF_LANG:funcreg 1
registration
  cluster VAR -> non empty;
end;

:: ZF_LANG:modenot 1
definition
  mode Variable is Element of VAR;
end;

:: ZF_LANG:funcnot 2 => ZF_LANG:func 2
definition
  let a1 be Element of NAT;
  func x. A1 -> Element of VAR equals
    5 + a1;
end;

:: ZF_LANG:def 2
theorem
for b1 being Element of NAT holds
   x. b1 = 5 + b1;

:: ZF_LANG:funcnot 3 => ZF_LANG:func 3
definition
  let a1 be Element of VAR;
  redefine func <*a1*> -> FinSequence of NAT;
end;

:: ZF_LANG:funcnot 4 => ZF_LANG:func 4
definition
  let a1, a2 be Element of VAR;
  func A1 '=' A2 -> FinSequence of NAT equals
    (<*0*> ^ <*a1*>) ^ <*a2*>;
end;

:: ZF_LANG:def 3
theorem
for b1, b2 being Element of VAR holds
b1 '=' b2 = (<*0*> ^ <*b1*>) ^ <*b2*>;

:: ZF_LANG:funcnot 5 => ZF_LANG:func 5
definition
  let a1, a2 be Element of VAR;
  func A1 'in' A2 -> FinSequence of NAT equals
    (<*1*> ^ <*a1*>) ^ <*a2*>;
end;

:: ZF_LANG:def 4
theorem
for b1, b2 being Element of VAR holds
b1 'in' b2 = (<*1*> ^ <*b1*>) ^ <*b2*>;

:: ZF_LANG:th 6
theorem
for b1, b2, b3, b4 being Element of VAR
      st b1 '=' b2 = b3 '=' b4
   holds b1 = b3 & b2 = b4;

:: ZF_LANG:th 7
theorem
for b1, b2, b3, b4 being Element of VAR
      st b1 'in' b2 = b3 'in' b4
   holds b1 = b3 & b2 = b4;

:: ZF_LANG:funcnot 6 => ZF_LANG:func 6
definition
  let a1 be FinSequence of NAT;
  func 'not' A1 -> FinSequence of NAT equals
    <*2*> ^ a1;
end;

:: ZF_LANG:def 5
theorem
for b1 being FinSequence of NAT holds
   'not' b1 = <*2*> ^ b1;

:: ZF_LANG:funcnot 7 => ZF_LANG:func 7
definition
  let a1, a2 be FinSequence of NAT;
  func A1 '&' A2 -> FinSequence of NAT equals
    (<*3*> ^ a1) ^ a2;
end;

:: ZF_LANG:def 6
theorem
for b1, b2 being FinSequence of NAT holds
b1 '&' b2 = (<*3*> ^ b1) ^ b2;

:: ZF_LANG:funcnot 8 => ZF_LANG:func 8
definition
  let a1 be Element of VAR;
  let a2 be FinSequence of NAT;
  func All(A1,A2) -> FinSequence of NAT equals
    (<*4*> ^ <*a1*>) ^ a2;
end;

:: ZF_LANG:def 7
theorem
for b1 being Element of VAR
for b2 being FinSequence of NAT holds
   All(b1,b2) = (<*4*> ^ <*b1*>) ^ b2;

:: ZF_LANG:th 12
theorem
for b1, b2 being FinSequence of NAT
for b3, b4 being Element of VAR
      st All(b3,b1) = All(b4,b2)
   holds b3 = b4 & b1 = b2;

:: ZF_LANG:funcnot 9 => ZF_LANG:func 9
definition
  func WFF -> non empty set means
    (for b1 being set
           st b1 in it
        holds b1 is FinSequence of NAT) &
     (for b1, b2 being Element of VAR holds
     b1 '=' b2 in it & b1 'in' b2 in it) &
     (for b1 being FinSequence of NAT
           st b1 in it
        holds 'not' b1 in it) &
     (for b1, b2 being FinSequence of NAT
           st b1 in it & b2 in it
        holds b1 '&' b2 in it) &
     (for b1 being Element of VAR
     for b2 being FinSequence of NAT
           st b2 in it
        holds All(b1,b2) in it) &
     (for b1 being non empty set
           st (for b2 being set
                    st b2 in b1
                 holds b2 is FinSequence of NAT) &
              (for b2, b3 being Element of VAR holds
              b2 '=' b3 in b1 & b2 'in' b3 in b1) &
              (for b2 being FinSequence of NAT
                    st b2 in b1
                 holds 'not' b2 in b1) &
              (for b2, b3 being FinSequence of NAT
                    st b2 in b1 & b3 in b1
                 holds b2 '&' b3 in b1) &
              (for b2 being Element of VAR
              for b3 being FinSequence of NAT
                    st b3 in b1
                 holds All(b2,b3) in b1)
        holds it c= b1);
end;

:: ZF_LANG:def 8
theorem
for b1 being non empty set holds
      b1 = WFF
   iff
      (for b2 being set
             st b2 in b1
          holds b2 is FinSequence of NAT) &
       (for b2, b3 being Element of VAR holds
       b2 '=' b3 in b1 & b2 'in' b3 in b1) &
       (for b2 being FinSequence of NAT
             st b2 in b1
          holds 'not' b2 in b1) &
       (for b2, b3 being FinSequence of NAT
             st b2 in b1 & b3 in b1
          holds b2 '&' b3 in b1) &
       (for b2 being Element of VAR
       for b3 being FinSequence of NAT
             st b3 in b1
          holds All(b2,b3) in b1) &
       (for b2 being non empty set
             st (for b3 being set
                      st b3 in b2
                   holds b3 is FinSequence of NAT) &
                (for b3, b4 being Element of VAR holds
                b3 '=' b4 in b2 & b3 'in' b4 in b2) &
                (for b3 being FinSequence of NAT
                      st b3 in b2
                   holds 'not' b3 in b2) &
                (for b3, b4 being FinSequence of NAT
                      st b3 in b2 & b4 in b2
                   holds b3 '&' b4 in b2) &
                (for b3 being Element of VAR
                for b4 being FinSequence of NAT
                      st b4 in b2
                   holds All(b3,b4) in b2)
          holds b1 c= b2);

:: ZF_LANG:attrnot 1 => ZF_LANG:attr 1
definition
  let a1 be FinSequence of NAT;
  attr a1 is ZF-formula-like means
    a1 is Element of WFF;
end;

:: ZF_LANG:dfs 9
definiens
  let a1 be FinSequence of NAT;
To prove
     a1 is ZF-formula-like
it is sufficient to prove
  thus a1 is Element of WFF;

:: ZF_LANG:def 9
theorem
for b1 being FinSequence of NAT holds
      b1 is ZF-formula-like
   iff
      b1 is Element of WFF;

:: ZF_LANG:exreg 1
registration
  cluster Relation-like Function-like finite FinSequence-like ZF-formula-like FinSequence of NAT;
end;

:: ZF_LANG:modenot 2
definition
  mode ZF-formula is ZF-formula-like FinSequence of NAT;
end;

:: ZF_LANG:th 14
theorem
for b1 being set holds
      b1 is ZF-formula-like FinSequence of NAT
   iff
      b1 in WFF;

:: ZF_LANG:funcreg 2
registration
  let a1, a2 be Element of VAR;
  cluster a1 '=' a2 -> ZF-formula-like;
end;

:: ZF_LANG:funcreg 3
registration
  let a1, a2 be Element of VAR;
  cluster a1 'in' a2 -> ZF-formula-like;
end;

:: ZF_LANG:funcreg 4
registration
  let a1 be ZF-formula-like FinSequence of NAT;
  cluster 'not' a1 -> ZF-formula-like;
end;

:: ZF_LANG:funcreg 5
registration
  let a1, a2 be ZF-formula-like FinSequence of NAT;
  cluster a1 '&' a2 -> ZF-formula-like;
end;

:: ZF_LANG:funcreg 6
registration
  let a1 be Element of VAR;
  let a2 be ZF-formula-like FinSequence of NAT;
  cluster All(a1,a2) -> ZF-formula-like;
end;

:: ZF_LANG:attrnot 2 => ZF_LANG:attr 2
definition
  let a1 be ZF-formula-like FinSequence of NAT;
  attr a1 is being_equality means
    ex b1, b2 being Element of VAR st
       a1 = b1 '=' b2;
end;

:: ZF_LANG:dfs 10
definiens
  let a1 be ZF-formula-like FinSequence of NAT;
To prove
     a1 is being_equality
it is sufficient to prove
  thus ex b1, b2 being Element of VAR st
       a1 = b1 '=' b2;

:: ZF_LANG:def 10
theorem
for b1 being ZF-formula-like FinSequence of NAT holds
      b1 is being_equality
   iff
      ex b2, b3 being Element of VAR st
         b1 = b2 '=' b3;

:: ZF_LANG:attrnot 3 => ZF_LANG:attr 3
definition
  let a1 be ZF-formula-like FinSequence of NAT;
  attr a1 is being_membership means
    ex b1, b2 being Element of VAR st
       a1 = b1 'in' b2;
end;

:: ZF_LANG:dfs 11
definiens
  let a1 be ZF-formula-like FinSequence of NAT;
To prove
     a1 is being_membership
it is sufficient to prove
  thus ex b1, b2 being Element of VAR st
       a1 = b1 'in' b2;

:: ZF_LANG:def 11
theorem
for b1 being ZF-formula-like FinSequence of NAT holds
      b1 is being_membership
   iff
      ex b2, b3 being Element of VAR st
         b1 = b2 'in' b3;

:: ZF_LANG:attrnot 4 => ZF_LANG:attr 4
definition
  let a1 be ZF-formula-like FinSequence of NAT;
  attr a1 is negative means
    ex b1 being ZF-formula-like FinSequence of NAT st
       a1 = 'not' b1;
end;

:: ZF_LANG:dfs 12
definiens
  let a1 be ZF-formula-like FinSequence of NAT;
To prove
     a1 is negative
it is sufficient to prove
  thus ex b1 being ZF-formula-like FinSequence of NAT st
       a1 = 'not' b1;

:: ZF_LANG:def 12
theorem
for b1 being ZF-formula-like FinSequence of NAT holds
      b1 is negative
   iff
      ex b2 being ZF-formula-like FinSequence of NAT st
         b1 = 'not' b2;

:: ZF_LANG:attrnot 5 => ZF_LANG:attr 5
definition
  let a1 be ZF-formula-like FinSequence of NAT;
  attr a1 is conjunctive means
    ex b1, b2 being ZF-formula-like FinSequence of NAT st
       a1 = b1 '&' b2;
end;

:: ZF_LANG:dfs 13
definiens
  let a1 be ZF-formula-like FinSequence of NAT;
To prove
     a1 is conjunctive
it is sufficient to prove
  thus ex b1, b2 being ZF-formula-like FinSequence of NAT st
       a1 = b1 '&' b2;

:: ZF_LANG:def 13
theorem
for b1 being ZF-formula-like FinSequence of NAT holds
      b1 is conjunctive
   iff
      ex b2, b3 being ZF-formula-like FinSequence of NAT st
         b1 = b2 '&' b3;

:: ZF_LANG:attrnot 6 => ZF_LANG:attr 6
definition
  let a1 be ZF-formula-like FinSequence of NAT;
  attr a1 is universal means
    ex b1 being Element of VAR st
       ex b2 being ZF-formula-like FinSequence of NAT st
          a1 = All(b1,b2);
end;

:: ZF_LANG:dfs 14
definiens
  let a1 be ZF-formula-like FinSequence of NAT;
To prove
     a1 is universal
it is sufficient to prove
  thus ex b1 being Element of VAR st
       ex b2 being ZF-formula-like FinSequence of NAT st
          a1 = All(b1,b2);

:: ZF_LANG:def 14
theorem
for b1 being ZF-formula-like FinSequence of NAT holds
      b1 is universal
   iff
      ex b2 being Element of VAR st
         ex b3 being ZF-formula-like FinSequence of NAT st
            b1 = All(b2,b3);

:: ZF_LANG:prednot 1 => ZF_LANG:attr 2
notation
  let a1 be ZF-formula-like FinSequence of NAT;
  synonym a1 is_equality for being_equality;
end;

:: ZF_LANG:prednot 2 => ZF_LANG:attr 3
notation
  let a1 be ZF-formula-like FinSequence of NAT;
  synonym a1 is_membership for being_membership;
end;

:: ZF_LANG:th 16
theorem
for b1 being ZF-formula-like FinSequence of NAT holds
   (b1 is being_equality implies ex b2, b3 being Element of VAR st
       b1 = b2 '=' b3) &
    (for b2, b3 being Element of VAR holds
    b1 <> b2 '=' b3 or b1 is being_equality) &
    (b1 is being_membership implies ex b2, b3 being Element of VAR st
       b1 = b2 'in' b3) &
    (for b2, b3 being Element of VAR holds
    b1 <> b2 'in' b3 or b1 is being_membership) &
    (b1 is negative implies ex b2 being ZF-formula-like FinSequence of NAT st
       b1 = 'not' b2) &
    (for b2 being ZF-formula-like FinSequence of NAT holds
       b1 <> 'not' b2 or b1 is negative) &
    (b1 is conjunctive implies ex b2, b3 being ZF-formula-like FinSequence of NAT st
       b1 = b2 '&' b3) &
    (for b2, b3 being ZF-formula-like FinSequence of NAT holds
    b1 <> b2 '&' b3 or b1 is conjunctive) &
    (b1 is universal implies ex b2 being Element of VAR st
       ex b3 being ZF-formula-like FinSequence of NAT st
          b1 = All(b2,b3)) &
    (for b2 being Element of VAR
    for b3 being ZF-formula-like FinSequence of NAT holds
       b1 <> All(b2,b3) or b1 is universal);

:: ZF_LANG:attrnot 7 => ZF_LANG:attr 7
definition
  let a1 be ZF-formula-like FinSequence of NAT;
  attr a1 is atomic means
    (a1 is not being_equality) implies a1 is being_membership;
end;

:: ZF_LANG:dfs 15
definiens
  let a1 be ZF-formula-like FinSequence of NAT;
To prove
     a1 is atomic
it is sufficient to prove
  thus (a1 is not being_equality) implies a1 is being_membership;

:: ZF_LANG:def 15
theorem
for b1 being ZF-formula-like FinSequence of NAT holds
      b1 is atomic
   iff
      (b1 is being_equality or b1 is being_membership);

:: ZF_LANG:funcnot 10 => ZF_LANG:func 10
definition
  let a1, a2 be ZF-formula-like FinSequence of NAT;
  func A1 'or' A2 -> ZF-formula-like FinSequence of NAT equals
    'not' (('not' a1) '&' 'not' a2);
end;

:: ZF_LANG:def 16
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT holds
b1 'or' b2 = 'not' (('not' b1) '&' 'not' b2);

:: ZF_LANG:funcnot 11 => ZF_LANG:func 11
definition
  let a1, a2 be ZF-formula-like FinSequence of NAT;
  func A1 => A2 -> ZF-formula-like FinSequence of NAT equals
    'not' (a1 '&' 'not' a2);
end;

:: ZF_LANG:def 17
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT holds
b1 => b2 = 'not' (b1 '&' 'not' b2);

:: ZF_LANG:funcnot 12 => ZF_LANG:func 12
definition
  let a1, a2 be ZF-formula-like FinSequence of NAT;
  func A1 <=> A2 -> ZF-formula-like FinSequence of NAT equals
    (a1 => a2) '&' (a2 => a1);
end;

:: ZF_LANG:def 18
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT holds
b1 <=> b2 = (b1 => b2) '&' (b2 => b1);

:: ZF_LANG:funcnot 13 => ZF_LANG:func 13
definition
  let a1 be Element of VAR;
  let a2 be ZF-formula-like FinSequence of NAT;
  func Ex(A1,A2) -> ZF-formula-like FinSequence of NAT equals
    'not' All(a1,'not' a2);
end;

:: ZF_LANG:def 19
theorem
for b1 being Element of VAR
for b2 being ZF-formula-like FinSequence of NAT holds
   Ex(b1,b2) = 'not' All(b1,'not' b2);

:: ZF_LANG:attrnot 8 => ZF_LANG:attr 8
definition
  let a1 be ZF-formula-like FinSequence of NAT;
  attr a1 is disjunctive means
    ex b1, b2 being ZF-formula-like FinSequence of NAT st
       a1 = b1 'or' b2;
end;

:: ZF_LANG:dfs 20
definiens
  let a1 be ZF-formula-like FinSequence of NAT;
To prove
     a1 is disjunctive
it is sufficient to prove
  thus ex b1, b2 being ZF-formula-like FinSequence of NAT st
       a1 = b1 'or' b2;

:: ZF_LANG:def 20
theorem
for b1 being ZF-formula-like FinSequence of NAT holds
      b1 is disjunctive
   iff
      ex b2, b3 being ZF-formula-like FinSequence of NAT st
         b1 = b2 'or' b3;

:: ZF_LANG:attrnot 9 => ZF_LANG:attr 9
definition
  let a1 be ZF-formula-like FinSequence of NAT;
  attr a1 is conditional means
    ex b1, b2 being ZF-formula-like FinSequence of NAT st
       a1 = b1 => b2;
end;

:: ZF_LANG:dfs 21
definiens
  let a1 be ZF-formula-like FinSequence of NAT;
To prove
     a1 is conditional
it is sufficient to prove
  thus ex b1, b2 being ZF-formula-like FinSequence of NAT st
       a1 = b1 => b2;

:: ZF_LANG:def 21
theorem
for b1 being ZF-formula-like FinSequence of NAT holds
      b1 is conditional
   iff
      ex b2, b3 being ZF-formula-like FinSequence of NAT st
         b1 = b2 => b3;

:: ZF_LANG:attrnot 10 => ZF_LANG:attr 10
definition
  let a1 be ZF-formula-like FinSequence of NAT;
  attr a1 is biconditional means
    ex b1, b2 being ZF-formula-like FinSequence of NAT st
       a1 = b1 <=> b2;
end;

:: ZF_LANG:dfs 22
definiens
  let a1 be ZF-formula-like FinSequence of NAT;
To prove
     a1 is biconditional
it is sufficient to prove
  thus ex b1, b2 being ZF-formula-like FinSequence of NAT st
       a1 = b1 <=> b2;

:: ZF_LANG:def 22
theorem
for b1 being ZF-formula-like FinSequence of NAT holds
      b1 is biconditional
   iff
      ex b2, b3 being ZF-formula-like FinSequence of NAT st
         b1 = b2 <=> b3;

:: ZF_LANG:attrnot 11 => ZF_LANG:attr 11
definition
  let a1 be ZF-formula-like FinSequence of NAT;
  attr a1 is existential means
    ex b1 being Element of VAR st
       ex b2 being ZF-formula-like FinSequence of NAT st
          a1 = Ex(b1,b2);
end;

:: ZF_LANG:dfs 23
definiens
  let a1 be ZF-formula-like FinSequence of NAT;
To prove
     a1 is existential
it is sufficient to prove
  thus ex b1 being Element of VAR st
       ex b2 being ZF-formula-like FinSequence of NAT st
          a1 = Ex(b1,b2);

:: ZF_LANG:def 23
theorem
for b1 being ZF-formula-like FinSequence of NAT holds
      b1 is existential
   iff
      ex b2 being Element of VAR st
         ex b3 being ZF-formula-like FinSequence of NAT st
            b1 = Ex(b2,b3);

:: ZF_LANG:th 22
theorem
for b1 being ZF-formula-like FinSequence of NAT holds
   (b1 is disjunctive implies ex b2, b3 being ZF-formula-like FinSequence of NAT st
       b1 = b2 'or' b3) &
    (for b2, b3 being ZF-formula-like FinSequence of NAT holds
    b1 <> b2 'or' b3 or b1 is disjunctive) &
    (b1 is conditional implies ex b2, b3 being ZF-formula-like FinSequence of NAT st
       b1 = b2 => b3) &
    (for b2, b3 being ZF-formula-like FinSequence of NAT holds
    b1 <> b2 => b3 or b1 is conditional) &
    (b1 is biconditional implies ex b2, b3 being ZF-formula-like FinSequence of NAT st
       b1 = b2 <=> b3) &
    (for b2, b3 being ZF-formula-like FinSequence of NAT holds
    b1 <> b2 <=> b3 or b1 is biconditional) &
    (b1 is existential implies ex b2 being Element of VAR st
       ex b3 being ZF-formula-like FinSequence of NAT st
          b1 = Ex(b2,b3)) &
    (for b2 being Element of VAR
    for b3 being ZF-formula-like FinSequence of NAT holds
       b1 <> Ex(b2,b3) or b1 is existential);

:: ZF_LANG:funcnot 14 => ZF_LANG:func 14
definition
  let a1, a2 be Element of VAR;
  let a3 be ZF-formula-like FinSequence of NAT;
  func All(A1,A2,A3) -> ZF-formula-like FinSequence of NAT equals
    All(a1,All(a2,a3));
end;

:: ZF_LANG:def 24
theorem
for b1, b2 being Element of VAR
for b3 being ZF-formula-like FinSequence of NAT holds
   All(b1,b2,b3) = All(b1,All(b2,b3));

:: ZF_LANG:funcnot 15 => ZF_LANG:func 15
definition
  let a1, a2 be Element of VAR;
  let a3 be ZF-formula-like FinSequence of NAT;
  func Ex(A1,A2,A3) -> ZF-formula-like FinSequence of NAT equals
    Ex(a1,Ex(a2,a3));
end;

:: ZF_LANG:def 25
theorem
for b1, b2 being Element of VAR
for b3 being ZF-formula-like FinSequence of NAT holds
   Ex(b1,b2,b3) = Ex(b1,Ex(b2,b3));

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

:: ZF_LANG:funcnot 16 => ZF_LANG:func 16
definition
  let a1, a2, a3 be Element of VAR;
  let a4 be ZF-formula-like FinSequence of NAT;
  func All(A1,A2,A3,A4) -> ZF-formula-like FinSequence of NAT equals
    All(a1,All(a2,a3,a4));
end;

:: ZF_LANG:def 26
theorem
for b1, b2, b3 being Element of VAR
for b4 being ZF-formula-like FinSequence of NAT holds
   All(b1,b2,b3,b4) = All(b1,All(b2,b3,b4));

:: ZF_LANG:funcnot 17 => ZF_LANG:func 17
definition
  let a1, a2, a3 be Element of VAR;
  let a4 be ZF-formula-like FinSequence of NAT;
  func Ex(A1,A2,A3,A4) -> ZF-formula-like FinSequence of NAT equals
    Ex(a1,Ex(a2,a3,a4));
end;

:: ZF_LANG:def 27
theorem
for b1, b2, b3 being Element of VAR
for b4 being ZF-formula-like FinSequence of NAT holds
   Ex(b1,b2,b3,b4) = Ex(b1,Ex(b2,b3,b4));

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

:: ZF_LANG:th 25
theorem
for b1 being ZF-formula-like FinSequence of NAT
      st b1 is not being_equality & b1 is not being_membership & b1 is not negative & b1 is not conjunctive
   holds b1 is universal;

:: ZF_LANG:th 26
theorem
for b1 being ZF-formula-like FinSequence of NAT
      st b1 is not atomic & b1 is not negative & b1 is not conjunctive
   holds b1 is universal;

:: ZF_LANG:th 27
theorem
for b1 being ZF-formula-like FinSequence of NAT
      st b1 is atomic
   holds len b1 = 3;

:: ZF_LANG:th 28
theorem
for b1 being ZF-formula-like FinSequence of NAT
      st b1 is not atomic
   holds ex b2 being ZF-formula-like FinSequence of NAT st
      (len b2) + 1 <= len b1;

:: ZF_LANG:th 29
theorem
for b1 being ZF-formula-like FinSequence of NAT holds
   3 <= len b1;

:: ZF_LANG:th 30
theorem
for b1 being ZF-formula-like FinSequence of NAT
      st len b1 = 3
   holds b1 is atomic;

:: ZF_LANG:th 31
theorem
for b1, b2 being Element of VAR holds
(b1 '=' b2) . 1 = 0 & (b1 'in' b2) . 1 = 1;

:: ZF_LANG:th 33
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT holds
(b1 '&' b2) . 1 = 3;

:: ZF_LANG:th 34
theorem
for b1 being Element of VAR
for b2 being ZF-formula-like FinSequence of NAT holds
   (All(b1,b2)) . 1 = 4;

:: ZF_LANG:th 35
theorem
for b1 being ZF-formula-like FinSequence of NAT
      st b1 is being_equality
   holds b1 . 1 = 0;

:: ZF_LANG:th 36
theorem
for b1 being ZF-formula-like FinSequence of NAT
      st b1 is being_membership
   holds b1 . 1 = 1;

:: ZF_LANG:th 37
theorem
for b1 being ZF-formula-like FinSequence of NAT
      st b1 is negative
   holds b1 . 1 = 2;

:: ZF_LANG:th 38
theorem
for b1 being ZF-formula-like FinSequence of NAT
      st b1 is conjunctive
   holds b1 . 1 = 3;

:: ZF_LANG:th 39
theorem
for b1 being ZF-formula-like FinSequence of NAT
      st b1 is universal
   holds b1 . 1 = 4;

:: ZF_LANG:th 40
theorem
for b1 being ZF-formula-like FinSequence of NAT
      st (b1 is being_equality implies b1 . 1 <> 0) & (b1 is being_membership implies b1 . 1 <> 1) & (b1 is negative implies b1 . 1 <> 2) & (b1 is conjunctive implies b1 . 1 <> 3)
   holds b1 is universal & b1 . 1 = 4;

:: ZF_LANG:th 41
theorem
for b1 being ZF-formula-like FinSequence of NAT
      st b1 . 1 = 0
   holds b1 is being_equality;

:: ZF_LANG:th 42
theorem
for b1 being ZF-formula-like FinSequence of NAT
      st b1 . 1 = 1
   holds b1 is being_membership;

:: ZF_LANG:th 43
theorem
for b1 being ZF-formula-like FinSequence of NAT
      st b1 . 1 = 2
   holds b1 is negative;

:: ZF_LANG:th 44
theorem
for b1 being ZF-formula-like FinSequence of NAT
      st b1 . 1 = 3
   holds b1 is conjunctive;

:: ZF_LANG:th 45
theorem
for b1 being ZF-formula-like FinSequence of NAT
      st b1 . 1 = 4
   holds b1 is universal;

:: ZF_LANG:th 46
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT
for b3 being Relation-like Function-like FinSequence-like set
      st b1 = b2 ^ b3
   holds b1 = b2;

:: ZF_LANG:th 47
theorem
for b1, b2, b3, b4 being ZF-formula-like FinSequence of NAT
      st b1 '&' b2 = b3 '&' b4
   holds b1 = b3 & b2 = b4;

:: ZF_LANG:th 48
theorem
for b1, b2, b3, b4 being ZF-formula-like FinSequence of NAT
      st b1 'or' b2 = b3 'or' b4
   holds b1 = b3 & b2 = b4;

:: ZF_LANG:th 49
theorem
for b1, b2, b3, b4 being ZF-formula-like FinSequence of NAT
      st b1 => b2 = b3 => b4
   holds b1 = b3 & b2 = b4;

:: ZF_LANG:th 50
theorem
for b1, b2, b3, b4 being ZF-formula-like FinSequence of NAT
      st b1 <=> b2 = b3 <=> b4
   holds b1 = b3 & b2 = b4;

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

:: ZF_LANG:funcnot 18 => ZF_LANG:func 18
definition
  let a1 be ZF-formula-like FinSequence of NAT;
  assume a1 is atomic;
  func Var1 A1 -> Element of VAR equals
    a1 . 2;
end;

:: ZF_LANG:def 28
theorem
for b1 being ZF-formula-like FinSequence of NAT
      st b1 is atomic
   holds Var1 b1 = b1 . 2;

:: ZF_LANG:funcnot 19 => ZF_LANG:func 19
definition
  let a1 be ZF-formula-like FinSequence of NAT;
  assume a1 is atomic;
  func Var2 A1 -> Element of VAR equals
    a1 . 3;
end;

:: ZF_LANG:def 29
theorem
for b1 being ZF-formula-like FinSequence of NAT
      st b1 is atomic
   holds Var2 b1 = b1 . 3;

:: ZF_LANG:th 52
theorem
for b1 being ZF-formula-like FinSequence of NAT
      st b1 is atomic
   holds Var1 b1 = b1 . 2 & Var2 b1 = b1 . 3;

:: ZF_LANG:th 53
theorem
for b1 being ZF-formula-like FinSequence of NAT
      st b1 is being_equality
   holds b1 = (Var1 b1) '=' Var2 b1;

:: ZF_LANG:th 54
theorem
for b1 being ZF-formula-like FinSequence of NAT
      st b1 is being_membership
   holds b1 = (Var1 b1) 'in' Var2 b1;

:: ZF_LANG:funcnot 20 => ZF_LANG:func 20
definition
  let a1 be ZF-formula-like FinSequence of NAT;
  assume a1 is negative;
  func the_argument_of A1 -> ZF-formula-like FinSequence of NAT means
    'not' it = a1;
end;

:: ZF_LANG:def 30
theorem
for b1 being ZF-formula-like FinSequence of NAT
   st b1 is negative
for b2 being ZF-formula-like FinSequence of NAT holds
      b2 = the_argument_of b1
   iff
      'not' b2 = b1;

:: ZF_LANG:funcnot 21 => ZF_LANG:func 21
definition
  let a1 be ZF-formula-like FinSequence of NAT;
  assume (a1 is conjunctive or a1 is disjunctive);
  func the_left_argument_of A1 -> ZF-formula-like FinSequence of NAT means
    ex b1 being ZF-formula-like FinSequence of NAT st
       it '&' b1 = a1
    if a1 is conjunctive
    otherwise ex b1 being ZF-formula-like FinSequence of NAT st
       it 'or' b1 = a1;
end;

:: ZF_LANG:def 31
theorem
for b1 being ZF-formula-like FinSequence of NAT
   st (b1 is conjunctive or b1 is disjunctive)
for b2 being ZF-formula-like FinSequence of NAT holds
   (b1 is conjunctive implies    (b2 = the_left_argument_of b1
    iff
       ex b3 being ZF-formula-like FinSequence of NAT st
          b2 '&' b3 = b1)) &
    (b1 is conjunctive or    (b2 = the_left_argument_of b1
    iff
       ex b3 being ZF-formula-like FinSequence of NAT st
          b2 'or' b3 = b1));

:: ZF_LANG:funcnot 22 => ZF_LANG:func 22
definition
  let a1 be ZF-formula-like FinSequence of NAT;
  assume (a1 is conjunctive or a1 is disjunctive);
  func the_right_argument_of A1 -> ZF-formula-like FinSequence of NAT means
    ex b1 being ZF-formula-like FinSequence of NAT st
       b1 '&' it = a1
    if a1 is conjunctive
    otherwise ex b1 being ZF-formula-like FinSequence of NAT st
       b1 'or' it = a1;
end;

:: ZF_LANG:def 32
theorem
for b1 being ZF-formula-like FinSequence of NAT
   st (b1 is conjunctive or b1 is disjunctive)
for b2 being ZF-formula-like FinSequence of NAT holds
   (b1 is conjunctive implies    (b2 = the_right_argument_of b1
    iff
       ex b3 being ZF-formula-like FinSequence of NAT st
          b3 '&' b2 = b1)) &
    (b1 is conjunctive or    (b2 = the_right_argument_of b1
    iff
       ex b3 being ZF-formula-like FinSequence of NAT st
          b3 'or' b2 = b1));

:: ZF_LANG:th 56
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT
      st b1 is conjunctive
   holds (b2 = the_left_argument_of b1 implies ex b3 being ZF-formula-like FinSequence of NAT st
       b2 '&' b3 = b1) &
    (for b3 being ZF-formula-like FinSequence of NAT holds
       b2 '&' b3 <> b1 or b2 = the_left_argument_of b1) &
    (b2 = the_right_argument_of b1 implies ex b3 being ZF-formula-like FinSequence of NAT st
       b3 '&' b2 = b1) &
    (for b3 being ZF-formula-like FinSequence of NAT holds
       b3 '&' b2 <> b1 or b2 = the_right_argument_of b1);

:: ZF_LANG:th 57
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT
      st b1 is disjunctive
   holds (b2 = the_left_argument_of b1 implies ex b3 being ZF-formula-like FinSequence of NAT st
       b2 'or' b3 = b1) &
    (for b3 being ZF-formula-like FinSequence of NAT holds
       b2 'or' b3 <> b1 or b2 = the_left_argument_of b1) &
    (b2 = the_right_argument_of b1 implies ex b3 being ZF-formula-like FinSequence of NAT st
       b3 'or' b2 = b1) &
    (for b3 being ZF-formula-like FinSequence of NAT holds
       b3 'or' b2 <> b1 or b2 = the_right_argument_of b1);

:: ZF_LANG:th 58
theorem
for b1 being ZF-formula-like FinSequence of NAT
      st b1 is conjunctive
   holds b1 = (the_left_argument_of b1) '&' the_right_argument_of b1;

:: ZF_LANG:th 59
theorem
for b1 being ZF-formula-like FinSequence of NAT
      st b1 is disjunctive
   holds b1 = (the_left_argument_of b1) 'or' the_right_argument_of b1;

:: ZF_LANG:funcnot 23 => ZF_LANG:func 23
definition
  let a1 be ZF-formula-like FinSequence of NAT;
  assume (a1 is universal or a1 is existential);
  func bound_in A1 -> Element of VAR means
    ex b1 being ZF-formula-like FinSequence of NAT st
       All(it,b1) = a1
    if a1 is universal
    otherwise ex b1 being ZF-formula-like FinSequence of NAT st
       Ex(it,b1) = a1;
end;

:: ZF_LANG:def 33
theorem
for b1 being ZF-formula-like FinSequence of NAT
   st (b1 is universal or b1 is existential)
for b2 being Element of VAR holds
   (b1 is universal implies    (b2 = bound_in b1
    iff
       ex b3 being ZF-formula-like FinSequence of NAT st
          All(b2,b3) = b1)) &
    (b1 is universal or    (b2 = bound_in b1
    iff
       ex b3 being ZF-formula-like FinSequence of NAT st
          Ex(b2,b3) = b1));

:: ZF_LANG:funcnot 24 => ZF_LANG:func 24
definition
  let a1 be ZF-formula-like FinSequence of NAT;
  assume (a1 is universal or a1 is existential);
  func the_scope_of A1 -> ZF-formula-like FinSequence of NAT means
    ex b1 being Element of VAR st
       All(b1,it) = a1
    if a1 is universal
    otherwise ex b1 being Element of VAR st
       Ex(b1,it) = a1;
end;

:: ZF_LANG:def 34
theorem
for b1 being ZF-formula-like FinSequence of NAT
   st (b1 is universal or b1 is existential)
for b2 being ZF-formula-like FinSequence of NAT holds
   (b1 is universal implies    (b2 = the_scope_of b1
    iff
       ex b3 being Element of VAR st
          All(b3,b2) = b1)) &
    (b1 is universal or    (b2 = the_scope_of b1
    iff
       ex b3 being Element of VAR st
          Ex(b3,b2) = b1));

:: ZF_LANG:th 60
theorem
for b1 being Element of VAR
for b2, b3 being ZF-formula-like FinSequence of NAT
      st b2 is universal
   holds (b1 = bound_in b2 implies ex b4 being ZF-formula-like FinSequence of NAT st
       All(b1,b4) = b2) &
    (for b4 being ZF-formula-like FinSequence of NAT holds
       All(b1,b4) <> b2 or b1 = bound_in b2) &
    (b3 = the_scope_of b2 implies ex b4 being Element of VAR st
       All(b4,b3) = b2) &
    (for b4 being Element of VAR holds
       All(b4,b3) <> b2 or b3 = the_scope_of b2);

:: ZF_LANG:th 61
theorem
for b1 being Element of VAR
for b2, b3 being ZF-formula-like FinSequence of NAT
      st b2 is existential
   holds (b1 = bound_in b2 implies ex b4 being ZF-formula-like FinSequence of NAT st
       Ex(b1,b4) = b2) &
    (for b4 being ZF-formula-like FinSequence of NAT holds
       Ex(b1,b4) <> b2 or b1 = bound_in b2) &
    (b3 = the_scope_of b2 implies ex b4 being Element of VAR st
       Ex(b4,b3) = b2) &
    (for b4 being Element of VAR holds
       Ex(b4,b3) <> b2 or b3 = the_scope_of b2);

:: ZF_LANG:th 62
theorem
for b1 being ZF-formula-like FinSequence of NAT
      st b1 is universal
   holds b1 = All(bound_in b1,the_scope_of b1);

:: ZF_LANG:th 63
theorem
for b1 being ZF-formula-like FinSequence of NAT
      st b1 is existential
   holds b1 = Ex(bound_in b1,the_scope_of b1);

:: ZF_LANG:funcnot 25 => ZF_LANG:func 25
definition
  let a1 be ZF-formula-like FinSequence of NAT;
  assume a1 is conditional;
  func the_antecedent_of A1 -> ZF-formula-like FinSequence of NAT means
    ex b1 being ZF-formula-like FinSequence of NAT st
       a1 = it => b1;
end;

:: ZF_LANG:def 35
theorem
for b1 being ZF-formula-like FinSequence of NAT
   st b1 is conditional
for b2 being ZF-formula-like FinSequence of NAT holds
      b2 = the_antecedent_of b1
   iff
      ex b3 being ZF-formula-like FinSequence of NAT st
         b1 = b2 => b3;

:: ZF_LANG:funcnot 26 => ZF_LANG:func 26
definition
  let a1 be ZF-formula-like FinSequence of NAT;
  assume a1 is conditional;
  func the_consequent_of A1 -> ZF-formula-like FinSequence of NAT means
    ex b1 being ZF-formula-like FinSequence of NAT st
       a1 = b1 => it;
end;

:: ZF_LANG:def 36
theorem
for b1 being ZF-formula-like FinSequence of NAT
   st b1 is conditional
for b2 being ZF-formula-like FinSequence of NAT holds
      b2 = the_consequent_of b1
   iff
      ex b3 being ZF-formula-like FinSequence of NAT st
         b1 = b3 => b2;

:: ZF_LANG:th 64
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT
      st b1 is conditional
   holds (b2 = the_antecedent_of b1 implies ex b3 being ZF-formula-like FinSequence of NAT st
       b1 = b2 => b3) &
    (for b3 being ZF-formula-like FinSequence of NAT holds
       b1 <> b2 => b3 or b2 = the_antecedent_of b1) &
    (b2 = the_consequent_of b1 implies ex b3 being ZF-formula-like FinSequence of NAT st
       b1 = b3 => b2) &
    (for b3 being ZF-formula-like FinSequence of NAT holds
       b1 <> b3 => b2 or b2 = the_consequent_of b1);

:: ZF_LANG:th 65
theorem
for b1 being ZF-formula-like FinSequence of NAT
      st b1 is conditional
   holds b1 = (the_antecedent_of b1) => the_consequent_of b1;

:: ZF_LANG:funcnot 27 => ZF_LANG:func 27
definition
  let a1 be ZF-formula-like FinSequence of NAT;
  assume a1 is biconditional;
  func the_left_side_of A1 -> ZF-formula-like FinSequence of NAT means
    ex b1 being ZF-formula-like FinSequence of NAT st
       a1 = it <=> b1;
end;

:: ZF_LANG:def 37
theorem
for b1 being ZF-formula-like FinSequence of NAT
   st b1 is biconditional
for b2 being ZF-formula-like FinSequence of NAT holds
      b2 = the_left_side_of b1
   iff
      ex b3 being ZF-formula-like FinSequence of NAT st
         b1 = b2 <=> b3;

:: ZF_LANG:funcnot 28 => ZF_LANG:func 28
definition
  let a1 be ZF-formula-like FinSequence of NAT;
  assume a1 is biconditional;
  func the_right_side_of A1 -> ZF-formula-like FinSequence of NAT means
    ex b1 being ZF-formula-like FinSequence of NAT st
       a1 = b1 <=> it;
end;

:: ZF_LANG:def 38
theorem
for b1 being ZF-formula-like FinSequence of NAT
   st b1 is biconditional
for b2 being ZF-formula-like FinSequence of NAT holds
      b2 = the_right_side_of b1
   iff
      ex b3 being ZF-formula-like FinSequence of NAT st
         b1 = b3 <=> b2;

:: ZF_LANG:th 66
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT
      st b1 is biconditional
   holds (b2 = the_left_side_of b1 implies ex b3 being ZF-formula-like FinSequence of NAT st
       b1 = b2 <=> b3) &
    (for b3 being ZF-formula-like FinSequence of NAT holds
       b1 <> b2 <=> b3 or b2 = the_left_side_of b1) &
    (b2 = the_right_side_of b1 implies ex b3 being ZF-formula-like FinSequence of NAT st
       b1 = b3 <=> b2) &
    (for b3 being ZF-formula-like FinSequence of NAT holds
       b1 <> b3 <=> b2 or b2 = the_right_side_of b1);

:: ZF_LANG:th 67
theorem
for b1 being ZF-formula-like FinSequence of NAT
      st b1 is biconditional
   holds b1 = (the_left_side_of b1) <=> the_right_side_of b1;

:: ZF_LANG:prednot 3 => ZF_LANG:pred 1
definition
  let a1, a2 be ZF-formula-like FinSequence of NAT;
  pred A1 is_immediate_constituent_of A2 means
    (a2 <> 'not' a1 &
     (for b1 being ZF-formula-like FinSequence of NAT holds
        a2 <> a1 '&' b1 & a2 <> b1 '&' a1)) implies ex b1 being Element of VAR st
       a2 = All(b1,a1);
end;

:: ZF_LANG:dfs 39
definiens
  let a1, a2 be ZF-formula-like FinSequence of NAT;
To prove
     a1 is_immediate_constituent_of a2
it is sufficient to prove
  thus (a2 <> 'not' a1 &
     (for b1 being ZF-formula-like FinSequence of NAT holds
        a2 <> a1 '&' b1 & a2 <> b1 '&' a1)) implies ex b1 being Element of VAR st
       a2 = All(b1,a1);

:: ZF_LANG:def 39
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT holds
   b1 is_immediate_constituent_of b2
iff
   (b2 <> 'not' b1 &
    (for b3 being ZF-formula-like FinSequence of NAT holds
       b2 <> b1 '&' b3 & b2 <> b3 '&' b1) implies ex b3 being Element of VAR st
      b2 = All(b3,b1));

:: ZF_LANG:th 69
theorem
for b1, b2 being Element of VAR
for b3 being ZF-formula-like FinSequence of NAT holds
   not b3 is_immediate_constituent_of b1 '=' b2;

:: ZF_LANG:th 70
theorem
for b1, b2 being Element of VAR
for b3 being ZF-formula-like FinSequence of NAT holds
   not b3 is_immediate_constituent_of b1 'in' b2;

:: ZF_LANG:th 71
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT holds
   b1 is_immediate_constituent_of 'not' b2
iff
   b1 = b2;

:: ZF_LANG:th 72
theorem
for b1, b2, b3 being ZF-formula-like FinSequence of NAT holds
   b1 is_immediate_constituent_of b2 '&' b3
iff
   (b1 = b2 or b1 = b3);

:: ZF_LANG:th 73
theorem
for b1 being Element of VAR
for b2, b3 being ZF-formula-like FinSequence of NAT holds
   b2 is_immediate_constituent_of All(b1,b3)
iff
   b2 = b3;

:: ZF_LANG:th 74
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT
      st b1 is atomic
   holds not b2 is_immediate_constituent_of b1;

:: ZF_LANG:th 75
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT
      st b1 is negative
   holds    b2 is_immediate_constituent_of b1
   iff
      b2 = the_argument_of b1;

:: ZF_LANG:th 76
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT
      st b1 is conjunctive
   holds    b2 is_immediate_constituent_of b1
   iff
      (b2 = the_left_argument_of b1 or b2 = the_right_argument_of b1);

:: ZF_LANG:th 77
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT
      st b1 is universal
   holds    b2 is_immediate_constituent_of b1
   iff
      b2 = the_scope_of b1;

:: ZF_LANG:prednot 4 => ZF_LANG:pred 2
definition
  let a1, a2 be ZF-formula-like FinSequence of NAT;
  pred A1 is_subformula_of A2 means
    ex b1 being Element of NAT st
       ex b2 being Relation-like Function-like FinSequence-like set st
          1 <= b1 &
           len b2 = b1 &
           b2 . 1 = a1 &
           b2 . b1 = a2 &
           (for b3 being Element of NAT
                 st 1 <= b3 & b3 < b1
              holds ex b4, b5 being ZF-formula-like FinSequence of NAT st
                 b2 . b3 = b4 & b2 . (b3 + 1) = b5 & b4 is_immediate_constituent_of b5);
end;

:: ZF_LANG:dfs 40
definiens
  let a1, a2 be ZF-formula-like FinSequence of NAT;
To prove
     a1 is_subformula_of a2
it is sufficient to prove
  thus ex b1 being Element of NAT st
       ex b2 being Relation-like Function-like FinSequence-like set st
          1 <= b1 &
           len b2 = b1 &
           b2 . 1 = a1 &
           b2 . b1 = a2 &
           (for b3 being Element of NAT
                 st 1 <= b3 & b3 < b1
              holds ex b4, b5 being ZF-formula-like FinSequence of NAT st
                 b2 . b3 = b4 & b2 . (b3 + 1) = b5 & b4 is_immediate_constituent_of b5);

:: ZF_LANG:def 40
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT holds
   b1 is_subformula_of b2
iff
   ex b3 being Element of NAT st
      ex b4 being Relation-like Function-like FinSequence-like set st
         1 <= b3 &
          len b4 = b3 &
          b4 . 1 = b1 &
          b4 . b3 = b2 &
          (for b5 being Element of NAT
                st 1 <= b5 & b5 < b3
             holds ex b6, b7 being ZF-formula-like FinSequence of NAT st
                b4 . b5 = b6 & b4 . (b5 + 1) = b7 & b6 is_immediate_constituent_of b7);

:: ZF_LANG:th 79
theorem
for b1 being ZF-formula-like FinSequence of NAT holds
   b1 is_subformula_of b1;

:: ZF_LANG:prednot 5 => ZF_LANG:pred 3
definition
  let a1, a2 be ZF-formula-like FinSequence of NAT;
  pred A1 is_proper_subformula_of A2 means
    a1 is_subformula_of a2 & a1 <> a2;
end;

:: ZF_LANG:dfs 41
definiens
  let a1, a2 be ZF-formula-like FinSequence of NAT;
To prove
     a1 is_proper_subformula_of a2
it is sufficient to prove
  thus a1 is_subformula_of a2 & a1 <> a2;

:: ZF_LANG:def 41
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT holds
   b1 is_proper_subformula_of b2
iff
   b1 is_subformula_of b2 & b1 <> b2;

:: ZF_LANG:th 81
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT
      st b1 is_immediate_constituent_of b2
   holds len b1 < len b2;

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

:: ZF_LANG:th 83
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT
      st b1 is_proper_subformula_of b2
   holds len b1 < len b2;

:: ZF_LANG:th 84
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT
      st b1 is_proper_subformula_of b2
   holds ex b3 being ZF-formula-like FinSequence of NAT st
      b3 is_immediate_constituent_of b2;

:: ZF_LANG:th 85
theorem
for b1, b2, b3 being ZF-formula-like FinSequence of NAT
      st b1 is_proper_subformula_of b2 & b2 is_proper_subformula_of b3
   holds b1 is_proper_subformula_of b3;

:: ZF_LANG:th 86
theorem
for b1, b2, b3 being ZF-formula-like FinSequence of NAT
      st b1 is_subformula_of b2 & b2 is_subformula_of b3
   holds b1 is_subformula_of b3;

:: ZF_LANG:th 87
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT
      st b1 is_subformula_of b2 & b2 is_subformula_of b1
   holds b1 = b2;

:: ZF_LANG:th 88
theorem
for b1, b2 being Element of VAR
for b3 being ZF-formula-like FinSequence of NAT holds
   not b3 is_proper_subformula_of b1 '=' b2;

:: ZF_LANG:th 89
theorem
for b1, b2 being Element of VAR
for b3 being ZF-formula-like FinSequence of NAT holds
   not b3 is_proper_subformula_of b1 'in' b2;

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

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

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

:: ZF_LANG:th 93
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT
      st b1 is atomic
   holds not b2 is_proper_subformula_of b1;

:: ZF_LANG:th 94
theorem
for b1 being ZF-formula-like FinSequence of NAT
      st b1 is negative
   holds the_argument_of b1 is_proper_subformula_of b1;

:: ZF_LANG:th 95
theorem
for b1 being ZF-formula-like FinSequence of NAT
      st b1 is conjunctive
   holds the_left_argument_of b1 is_proper_subformula_of b1 & the_right_argument_of b1 is_proper_subformula_of b1;

:: ZF_LANG:th 96
theorem
for b1 being ZF-formula-like FinSequence of NAT
      st b1 is universal
   holds the_scope_of b1 is_proper_subformula_of b1;

:: ZF_LANG:th 97
theorem
for b1, b2 being Element of VAR
for b3 being ZF-formula-like FinSequence of NAT holds
      b3 is_subformula_of b1 '=' b2
   iff
      b3 = b1 '=' b2;

:: ZF_LANG:th 98
theorem
for b1, b2 being Element of VAR
for b3 being ZF-formula-like FinSequence of NAT holds
      b3 is_subformula_of b1 'in' b2
   iff
      b3 = b1 'in' b2;

:: ZF_LANG:funcnot 29 => ZF_LANG:func 29
definition
  let a1 be ZF-formula-like FinSequence of NAT;
  func Subformulae A1 -> set means
    for b1 being set holds
          b1 in it
       iff
          ex b2 being ZF-formula-like FinSequence of NAT st
             b2 = b1 & b2 is_subformula_of a1;
end;

:: ZF_LANG:def 42
theorem
for b1 being ZF-formula-like FinSequence of NAT
for b2 being set holds
      b2 = Subformulae b1
   iff
      for b3 being set holds
            b3 in b2
         iff
            ex b4 being ZF-formula-like FinSequence of NAT st
               b4 = b3 & b4 is_subformula_of b1;

:: ZF_LANG:th 100
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT
      st b1 in Subformulae b2
   holds b1 is_subformula_of b2;

:: ZF_LANG:th 101
theorem
for b1, b2 being ZF-formula-like FinSequence of NAT
      st b1 is_subformula_of b2
   holds Subformulae b1 c= Subformulae b2;

:: ZF_LANG:th 102
theorem
for b1, b2 being Element of VAR holds
Subformulae (b1 '=' b2) = {b1 '=' b2};

:: ZF_LANG:th 103
theorem
for b1, b2 being Element of VAR holds
Subformulae (b1 'in' b2) = {b1 'in' b2};

:: ZF_LANG:th 104
theorem
for b1 being ZF-formula-like FinSequence of NAT holds
   Subformulae 'not' b1 = (Subformulae b1) \/ {'not' b1};

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

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

:: ZF_LANG:th 107
theorem
for b1 being ZF-formula-like FinSequence of NAT holds
      b1 is atomic
   iff
      Subformulae b1 = {b1};

:: ZF_LANG:th 108
theorem
for b1 being ZF-formula-like FinSequence of NAT
      st b1 is negative
   holds Subformulae b1 = (Subformulae the_argument_of b1) \/ {b1};

:: ZF_LANG:th 109
theorem
for b1 being ZF-formula-like FinSequence of NAT
      st b1 is conjunctive
   holds Subformulae b1 = ((Subformulae the_left_argument_of b1) \/ Subformulae the_right_argument_of b1) \/ {b1};

:: ZF_LANG:th 110
theorem
for b1 being ZF-formula-like FinSequence of NAT
      st b1 is universal
   holds Subformulae b1 = (Subformulae the_scope_of b1) \/ {b1};

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

:: ZF_LANG:sch 1
scheme ZF_LANG:sch 1
for b1 being ZF-formula-like FinSequence of NAT holds
   P1[b1]
provided
   for b1 being ZF-formula-like FinSequence of NAT
         st b1 is atomic
      holds P1[b1]
and
   for b1 being ZF-formula-like FinSequence of NAT
         st b1 is negative & P1[the_argument_of b1]
      holds P1[b1]
and
   for b1 being ZF-formula-like FinSequence of NAT
         st b1 is conjunctive & P1[the_left_argument_of b1] & P1[the_right_argument_of b1]
      holds P1[b1]
and
   for b1 being ZF-formula-like FinSequence of NAT
         st b1 is universal & P1[the_scope_of b1]
      holds P1[b1];


:: ZF_LANG:sch 2
scheme ZF_LANG:sch 2
for b1 being ZF-formula-like FinSequence of NAT holds
   P1[b1]
provided
   for b1 being ZF-formula-like FinSequence of NAT
         st for b2 being ZF-formula-like FinSequence of NAT
                 st b2 is_proper_subformula_of b1
              holds P1[b2]
      holds P1[b1];