:: ZF_LANG semantic presentation

definition
func VAR -> Subset of NAT equals :: ZF_LANG:def 1
{ b1 where B is Nat : 5 <= b1 } ;
coherence
{ b1 where B is Nat : 5 <= b1 } is Subset of NAT
proof end;
end;

:: deftheorem Def1 defines VAR ZF_LANG:def 1 :
VAR = { b1 where B is Nat : 5 <= b1 } ;

registration
cluster VAR -> non empty ;
coherence
not VAR is empty
proof end;
end;

definition
mode Variable is Element of VAR ;
end;

definition
let c1 be Nat;
func x. c1 -> Variable equals :: ZF_LANG:def 2
5 + a1;
coherence
5 + c1 is Variable
proof end;
end;

:: deftheorem Def2 defines x. ZF_LANG:def 2 :
for b1 being Nat holds x. b1 = 5 + b1;

definition
let c1 be Variable;
redefine func <* as <*c1*> -> FinSequence of NAT ;
coherence
<*c1*> is FinSequence of NAT
proof end;
end;

definition
let c1, c2 be Variable;
func c1 '=' c2 -> FinSequence of NAT equals :: ZF_LANG:def 3
(<*0*> ^ <*a1*>) ^ <*a2*>;
coherence
(<*0*> ^ <*c1*>) ^ <*c2*> is FinSequence of NAT
;
func c1 'in' c2 -> FinSequence of NAT equals :: ZF_LANG:def 4
(<*1*> ^ <*a1*>) ^ <*a2*>;
coherence
(<*1*> ^ <*c1*>) ^ <*c2*> is FinSequence of NAT
;
end;

:: deftheorem Def3 defines '=' ZF_LANG:def 3 :
for b1, b2 being Variable holds b1 '=' b2 = (<*0*> ^ <*b1*>) ^ <*b2*>;

:: deftheorem Def4 defines 'in' ZF_LANG:def 4 :
for b1, b2 being Variable holds b1 'in' b2 = (<*1*> ^ <*b1*>) ^ <*b2*>;

theorem Th1: :: ZF_LANG:1
canceled;

theorem Th2: :: ZF_LANG:2
canceled;

theorem Th3: :: ZF_LANG:3
canceled;

theorem Th4: :: ZF_LANG:4
canceled;

theorem Th5: :: ZF_LANG:5
canceled;

theorem Th6: :: ZF_LANG:6
for b1, b2, b3, b4 being Variable holds
( b1 '=' b2 = b3 '=' b4 implies ( b1 = b3 & b2 = b4 ) )
proof end;

theorem Th7: :: ZF_LANG:7
for b1, b2, b3, b4 being Variable holds
( b1 'in' b2 = b3 'in' b4 implies ( b1 = b3 & b2 = b4 ) )
proof end;

definition
let c1 be FinSequence of NAT ;
func 'not' c1 -> FinSequence of NAT equals :: ZF_LANG:def 5
<*2*> ^ a1;
coherence
<*2*> ^ c1 is FinSequence of NAT
;
let c2 be FinSequence of NAT ;
func c1 '&' c2 -> FinSequence of NAT equals :: ZF_LANG:def 6
(<*3*> ^ a1) ^ a2;
coherence
(<*3*> ^ c1) ^ c2 is FinSequence of NAT
;
end;

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

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

theorem Th8: :: ZF_LANG:8
canceled;

theorem Th9: :: ZF_LANG:9
canceled;

theorem Th10: :: ZF_LANG:10
for b1, b2 being FinSequence of NAT holds
( 'not' b1 = 'not' b2 implies b1 = b2 ) by FINSEQ_1:46;

definition
let c1 be Variable;
let c2 be FinSequence of NAT ;
func All c1,c2 -> FinSequence of NAT equals :: ZF_LANG:def 7
(<*4*> ^ <*a1*>) ^ a2;
coherence
(<*4*> ^ <*c1*>) ^ c2 is FinSequence of NAT
;
end;

:: deftheorem Def7 defines All ZF_LANG:def 7 :
for b1 being Variable
for b2 being FinSequence of NAT holds All b1,b2 = (<*4*> ^ <*b1*>) ^ b2;

theorem Th11: :: ZF_LANG:11
canceled;

theorem Th12: :: ZF_LANG:12
for b1, b2 being FinSequence of NAT
for b3, b4 being Variable holds
( All b3,b1 = All b4,b2 implies ( b3 = b4 & b1 = b2 ) )
proof end;

definition
func WFF -> non empty set means :Def8: :: ZF_LANG:def 8
( ( for b1 being set holds
( b1 in a1 implies b1 is FinSequence of NAT ) ) & ( for b1, b2 being Variable holds
( b1 '=' b2 in a1 & b1 'in' b2 in a1 ) ) & ( for b1 being FinSequence of NAT holds
( b1 in a1 implies 'not' b1 in a1 ) ) & ( for b1, b2 being FinSequence of NAT holds
( b1 in a1 & b2 in a1 implies b1 '&' b2 in a1 ) ) & ( for b1 being Variable
for b2 being FinSequence of NAT holds
( b2 in a1 implies All b1,b2 in a1 ) ) & ( for b1 being non empty set holds
( ( for b2 being set holds
( b2 in b1 implies b2 is FinSequence of NAT ) ) & ( for b2, b3 being Variable holds
( b2 '=' b3 in b1 & b2 'in' b3 in b1 ) ) & ( for b2 being FinSequence of NAT holds
( b2 in b1 implies 'not' b2 in b1 ) ) & ( for b2, b3 being FinSequence of NAT holds
( b2 in b1 & b3 in b1 implies b2 '&' b3 in b1 ) ) & ( for b2 being Variable
for b3 being FinSequence of NAT holds
( b3 in b1 implies All b2,b3 in b1 ) ) implies a1 c= b1 ) ) );
existence
ex b1 being non empty set st
( ( for b2 being set holds
( b2 in b1 implies b2 is FinSequence of NAT ) ) & ( for b2, b3 being Variable holds
( b2 '=' b3 in b1 & b2 'in' b3 in b1 ) ) & ( for b2 being FinSequence of NAT holds
( b2 in b1 implies 'not' b2 in b1 ) ) & ( for b2, b3 being FinSequence of NAT holds
( b2 in b1 & b3 in b1 implies b2 '&' b3 in b1 ) ) & ( for b2 being Variable
for b3 being FinSequence of NAT holds
( b3 in b1 implies All b2,b3 in b1 ) ) & ( for b2 being non empty set holds
( ( for b3 being set holds
( b3 in b2 implies b3 is FinSequence of NAT ) ) & ( for b3, b4 being Variable holds
( b3 '=' b4 in b2 & b3 'in' b4 in b2 ) ) & ( for b3 being FinSequence of NAT holds
( b3 in b2 implies 'not' b3 in b2 ) ) & ( for b3, b4 being FinSequence of NAT holds
( b3 in b2 & b4 in b2 implies b3 '&' b4 in b2 ) ) & ( for b3 being Variable
for b4 being FinSequence of NAT holds
( b4 in b2 implies All b3,b4 in b2 ) ) implies b1 c= b2 ) ) )
proof end;
uniqueness
for b1, b2 being non empty set holds
( ( for b3 being set holds
( b3 in b1 implies b3 is FinSequence of NAT ) ) & ( for b3, b4 being Variable holds
( b3 '=' b4 in b1 & b3 'in' b4 in b1 ) ) & ( for b3 being FinSequence of NAT holds
( b3 in b1 implies 'not' b3 in b1 ) ) & ( for b3, b4 being FinSequence of NAT holds
( b3 in b1 & b4 in b1 implies b3 '&' b4 in b1 ) ) & ( for b3 being Variable
for b4 being FinSequence of NAT holds
( b4 in b1 implies All b3,b4 in b1 ) ) & ( for b3 being non empty set holds
( ( for b4 being set holds
( b4 in b3 implies b4 is FinSequence of NAT ) ) & ( for b4, b5 being Variable holds
( b4 '=' b5 in b3 & b4 'in' b5 in b3 ) ) & ( for b4 being FinSequence of NAT holds
( b4 in b3 implies 'not' b4 in b3 ) ) & ( for b4, b5 being FinSequence of NAT holds
( b4 in b3 & b5 in b3 implies b4 '&' b5 in b3 ) ) & ( for b4 being Variable
for b5 being FinSequence of NAT holds
( b5 in b3 implies All b4,b5 in b3 ) ) implies b1 c= b3 ) ) & ( for b3 being set holds
( b3 in b2 implies b3 is FinSequence of NAT ) ) & ( for b3, b4 being Variable holds
( b3 '=' b4 in b2 & b3 'in' b4 in b2 ) ) & ( for b3 being FinSequence of NAT holds
( b3 in b2 implies 'not' b3 in b2 ) ) & ( for b3, b4 being FinSequence of NAT holds
( b3 in b2 & b4 in b2 implies b3 '&' b4 in b2 ) ) & ( for b3 being Variable
for b4 being FinSequence of NAT holds
( b4 in b2 implies All b3,b4 in b2 ) ) & ( for b3 being non empty set holds
( ( for b4 being set holds
( b4 in b3 implies b4 is FinSequence of NAT ) ) & ( for b4, b5 being Variable holds
( b4 '=' b5 in b3 & b4 'in' b5 in b3 ) ) & ( for b4 being FinSequence of NAT holds
( b4 in b3 implies 'not' b4 in b3 ) ) & ( for b4, b5 being FinSequence of NAT holds
( b4 in b3 & b5 in b3 implies b4 '&' b5 in b3 ) ) & ( for b4 being Variable
for b5 being FinSequence of NAT holds
( b5 in b3 implies All b4,b5 in b3 ) ) implies b2 c= b3 ) ) implies b1 = b2 )
proof end;
end;

:: deftheorem Def8 defines WFF ZF_LANG:def 8 :
for b1 being non empty set holds
( b1 = WFF iff ( ( for b2 being set holds
( b2 in b1 implies b2 is FinSequence of NAT ) ) & ( for b2, b3 being Variable holds
( b2 '=' b3 in b1 & b2 'in' b3 in b1 ) ) & ( for b2 being FinSequence of NAT holds
( b2 in b1 implies 'not' b2 in b1 ) ) & ( for b2, b3 being FinSequence of NAT holds
( b2 in b1 & b3 in b1 implies b2 '&' b3 in b1 ) ) & ( for b2 being Variable
for b3 being FinSequence of NAT holds
( b3 in b1 implies All b2,b3 in b1 ) ) & ( for b2 being non empty set holds
( ( for b3 being set holds
( b3 in b2 implies b3 is FinSequence of NAT ) ) & ( for b3, b4 being Variable holds
( b3 '=' b4 in b2 & b3 'in' b4 in b2 ) ) & ( for b3 being FinSequence of NAT holds
( b3 in b2 implies 'not' b3 in b2 ) ) & ( for b3, b4 being FinSequence of NAT holds
( b3 in b2 & b4 in b2 implies b3 '&' b4 in b2 ) ) & ( for b3 being Variable
for b4 being FinSequence of NAT holds
( b4 in b2 implies All b3,b4 in b2 ) ) implies b1 c= b2 ) ) ) );

definition
let c1 be FinSequence of NAT ;
attr a1 is ZF-formula-like means :Def9: :: ZF_LANG:def 9
a1 is Element of WFF ;
end;

:: deftheorem Def9 defines ZF-formula-like ZF_LANG:def 9 :
for b1 being FinSequence of NAT holds
( b1 is ZF-formula-like iff b1 is Element of WFF );

registration
cluster ZF-formula-like FinSequence of NAT ;
existence
ex b1 being FinSequence of NAT st b1 is ZF-formula-like
proof end;
end;

definition
mode ZF-formula is ZF-formula-like FinSequence of NAT ;
end;

theorem Th13: :: ZF_LANG:13
canceled;

theorem Th14: :: ZF_LANG:14
for b1 being set holds
( b1 is ZF-formula iff b1 in WFF )
proof end;

registration
let c1, c2 be Variable;
cluster a1 '=' a2 -> ZF-formula-like ;
coherence
c1 '=' c2 is ZF-formula-like
proof end;
cluster a1 'in' a2 -> ZF-formula-like ;
coherence
c1 'in' c2 is ZF-formula-like
proof end;
end;

registration
let c1 be ZF-formula;
cluster 'not' a1 -> ZF-formula-like ;
coherence
'not' c1 is ZF-formula-like
proof end;
let c2 be ZF-formula;
cluster a1 '&' a2 -> ZF-formula-like ;
coherence
c1 '&' c2 is ZF-formula-like
proof end;
end;

registration
let c1 be Variable;
let c2 be ZF-formula;
cluster All a1,a2 -> ZF-formula-like ;
coherence
All c1,c2 is ZF-formula-like
proof end;
end;

definition
let c1 be ZF-formula;
attr a1 is being_equality means :Def10: :: ZF_LANG:def 10
ex b1, b2 being Variable st a1 = b1 '=' b2;
attr a1 is being_membership means :Def11: :: ZF_LANG:def 11
ex b1, b2 being Variable st a1 = b1 'in' b2;
attr a1 is negative means :Def12: :: ZF_LANG:def 12
ex b1 being ZF-formula st a1 = 'not' b1;
attr a1 is conjunctive means :Def13: :: ZF_LANG:def 13
ex b1, b2 being ZF-formula st a1 = b1 '&' b2;
attr a1 is universal means :Def14: :: ZF_LANG:def 14
ex b1 being Variableex b2 being ZF-formula st a1 = All b1,b2;
end;

:: deftheorem Def10 defines being_equality ZF_LANG:def 10 :
for b1 being ZF-formula holds
( b1 is being_equality iff ex b2, b3 being Variable st b1 = b2 '=' b3 );

:: deftheorem Def11 defines being_membership ZF_LANG:def 11 :
for b1 being ZF-formula holds
( b1 is being_membership iff ex b2, b3 being Variable st b1 = b2 'in' b3 );

:: deftheorem Def12 defines negative ZF_LANG:def 12 :
for b1 being ZF-formula holds
( b1 is negative iff ex b2 being ZF-formula st b1 = 'not' b2 );

:: deftheorem Def13 defines conjunctive ZF_LANG:def 13 :
for b1 being ZF-formula holds
( b1 is conjunctive iff ex b2, b3 being ZF-formula st b1 = b2 '&' b3 );

:: deftheorem Def14 defines universal ZF_LANG:def 14 :
for b1 being ZF-formula holds
( b1 is universal iff ex b2 being Variableex b3 being ZF-formula st b1 = All b2,b3 );

notation
let c1 be ZF-formula;
synonym c1 is_equality for being_equality c1;
synonym c1 is_membership for being_membership c1;
end;

theorem Th15: :: ZF_LANG:15
canceled;

theorem Th16: :: ZF_LANG:16
for b1 being ZF-formula holds
( not ( b1 is_equality & ( for b2, b3 being Variable holds
not b1 = b2 '=' b3 ) ) & ( ex b2, b3 being Variable st b1 = b2 '=' b3 implies b1 is_equality ) & not ( b1 is_membership & ( for b2, b3 being Variable holds
not b1 = b2 'in' b3 ) ) & ( ex b2, b3 being Variable st b1 = b2 'in' b3 implies b1 is_membership ) & not ( b1 is negative & ( for b2 being ZF-formula holds
not b1 = 'not' b2 ) ) & ( ex b2 being ZF-formula st b1 = 'not' b2 implies b1 is negative ) & not ( b1 is conjunctive & ( for b2, b3 being ZF-formula holds
not b1 = b2 '&' b3 ) ) & ( ex b2, b3 being ZF-formula st b1 = b2 '&' b3 implies b1 is conjunctive ) & not ( b1 is universal & ( for b2 being Variable
for b3 being ZF-formula holds
not b1 = All b2,b3 ) ) & ( ex b2 being Variableex b3 being ZF-formula st b1 = All b2,b3 implies b1 is universal ) ) by Def10, Def11, Def12, Def13, Def14;

definition
let c1 be ZF-formula;
attr a1 is atomic means :Def15: :: ZF_LANG:def 15
( a1 is_equality or a1 is_membership );
end;

:: deftheorem Def15 defines atomic ZF_LANG:def 15 :
for b1 being ZF-formula holds
( b1 is atomic iff ( b1 is_equality or b1 is_membership ) );

definition
let c1, c2 be ZF-formula;
func c1 'or' c2 -> ZF-formula equals :: ZF_LANG:def 16
'not' (('not' a1) '&' ('not' a2));
coherence
'not' (('not' c1) '&' ('not' c2)) is ZF-formula
;
func c1 => c2 -> ZF-formula equals :: ZF_LANG:def 17
'not' (a1 '&' ('not' a2));
coherence
'not' (c1 '&' ('not' c2)) is ZF-formula
;
end;

:: deftheorem Def16 defines 'or' ZF_LANG:def 16 :
for b1, b2 being ZF-formula holds b1 'or' b2 = 'not' (('not' b1) '&' ('not' b2));

:: deftheorem Def17 defines => ZF_LANG:def 17 :
for b1, b2 being ZF-formula holds b1 => b2 = 'not' (b1 '&' ('not' b2));

definition
let c1, c2 be ZF-formula;
func c1 <=> c2 -> ZF-formula equals :: ZF_LANG:def 18
(a1 => a2) '&' (a2 => a1);
coherence
(c1 => c2) '&' (c2 => c1) is ZF-formula
;
end;

:: deftheorem Def18 defines <=> ZF_LANG:def 18 :
for b1, b2 being ZF-formula holds b1 <=> b2 = (b1 => b2) '&' (b2 => b1);

definition
let c1 be Variable;
let c2 be ZF-formula;
func Ex c1,c2 -> ZF-formula equals :: ZF_LANG:def 19
'not' (All a1,('not' a2));
coherence
'not' (All c1,('not' c2)) is ZF-formula
;
end;

:: deftheorem Def19 defines Ex ZF_LANG:def 19 :
for b1 being Variable
for b2 being ZF-formula holds Ex b1,b2 = 'not' (All b1,('not' b2));

definition
let c1 be ZF-formula;
attr a1 is disjunctive means :Def20: :: ZF_LANG:def 20
ex b1, b2 being ZF-formula st a1 = b1 'or' b2;
attr a1 is conditional means :Def21: :: ZF_LANG:def 21
ex b1, b2 being ZF-formula st a1 = b1 => b2;
attr a1 is biconditional means :Def22: :: ZF_LANG:def 22
ex b1, b2 being ZF-formula st a1 = b1 <=> b2;
attr a1 is existential means :Def23: :: ZF_LANG:def 23
ex b1 being Variableex b2 being ZF-formula st a1 = Ex b1,b2;
end;

:: deftheorem Def20 defines disjunctive ZF_LANG:def 20 :
for b1 being ZF-formula holds
( b1 is disjunctive iff ex b2, b3 being ZF-formula st b1 = b2 'or' b3 );

:: deftheorem Def21 defines conditional ZF_LANG:def 21 :
for b1 being ZF-formula holds
( b1 is conditional iff ex b2, b3 being ZF-formula st b1 = b2 => b3 );

:: deftheorem Def22 defines biconditional ZF_LANG:def 22 :
for b1 being ZF-formula holds
( b1 is biconditional iff ex b2, b3 being ZF-formula st b1 = b2 <=> b3 );

:: deftheorem Def23 defines existential ZF_LANG:def 23 :
for b1 being ZF-formula holds
( b1 is existential iff ex b2 being Variableex b3 being ZF-formula st b1 = Ex b2,b3 );

theorem Th17: :: ZF_LANG:17
canceled;

theorem Th18: :: ZF_LANG:18
canceled;

theorem Th19: :: ZF_LANG:19
canceled;

theorem Th20: :: ZF_LANG:20
canceled;

theorem Th21: :: ZF_LANG:21
canceled;

theorem Th22: :: ZF_LANG:22
for b1 being ZF-formula holds
( not ( b1 is disjunctive & ( for b2, b3 being ZF-formula holds
not b1 = b2 'or' b3 ) ) & ( ex b2, b3 being ZF-formula st b1 = b2 'or' b3 implies b1 is disjunctive ) & not ( b1 is conditional & ( for b2, b3 being ZF-formula holds
not b1 = b2 => b3 ) ) & ( ex b2, b3 being ZF-formula st b1 = b2 => b3 implies b1 is conditional ) & not ( b1 is biconditional & ( for b2, b3 being ZF-formula holds
not b1 = b2 <=> b3 ) ) & ( ex b2, b3 being ZF-formula st b1 = b2 <=> b3 implies b1 is biconditional ) & not ( b1 is existential & ( for b2 being Variable
for b3 being ZF-formula holds
not b1 = Ex b2,b3 ) ) & ( ex b2 being Variableex b3 being ZF-formula st b1 = Ex b2,b3 implies b1 is existential ) ) by Def20, Def21, Def22, Def23;

definition
let c1, c2 be Variable;
let c3 be ZF-formula;
func All c1,c2,c3 -> ZF-formula equals :: ZF_LANG:def 24
All a1,(All a2,a3);
coherence
All c1,(All c2,c3) is ZF-formula
;
func Ex c1,c2,c3 -> ZF-formula equals :: ZF_LANG:def 25
Ex a1,(Ex a2,a3);
coherence
Ex c1,(Ex c2,c3) is ZF-formula
;
end;

:: deftheorem Def24 defines All ZF_LANG:def 24 :
for b1, b2 being Variable
for b3 being ZF-formula holds All b1,b2,b3 = All b1,(All b2,b3);

:: deftheorem Def25 defines Ex ZF_LANG:def 25 :
for b1, b2 being Variable
for b3 being ZF-formula holds Ex b1,b2,b3 = Ex b1,(Ex b2,b3);

theorem Th23: :: ZF_LANG:23
for b1, b2 being Variable
for b3 being ZF-formula holds
( All b1,b2,b3 = All b1,(All b2,b3) & Ex b1,b2,b3 = Ex b1,(Ex b2,b3) ) ;

definition
let c1, c2, c3 be Variable;
let c4 be ZF-formula;
func All c1,c2,c3,c4 -> ZF-formula equals :: ZF_LANG:def 26
All a1,(All a2,a3,a4);
coherence
All c1,(All c2,c3,c4) is ZF-formula
;
func Ex c1,c2,c3,c4 -> ZF-formula equals :: ZF_LANG:def 27
Ex a1,(Ex a2,a3,a4);
coherence
Ex c1,(Ex c2,c3,c4) is ZF-formula
;
end;

:: deftheorem Def26 defines All ZF_LANG:def 26 :
for b1, b2, b3 being Variable
for b4 being ZF-formula holds All b1,b2,b3,b4 = All b1,(All b2,b3,b4);

:: deftheorem Def27 defines Ex ZF_LANG:def 27 :
for b1, b2, b3 being Variable
for b4 being ZF-formula holds Ex b1,b2,b3,b4 = Ex b1,(Ex b2,b3,b4);

theorem Th24: :: ZF_LANG:24
for b1, b2, b3 being Variable
for b4 being ZF-formula holds
( All b1,b2,b3,b4 = All b1,(All b2,b3,b4) & Ex b1,b2,b3,b4 = Ex b1,(Ex b2,b3,b4) ) ;

theorem Th25: :: ZF_LANG:25
for b1 being ZF-formula holds
not ( not b1 is_equality & not b1 is_membership & not b1 is negative & not b1 is conjunctive & not b1 is universal )
proof end;

theorem Th26: :: ZF_LANG:26
for b1 being ZF-formula holds
not ( not b1 is atomic & not b1 is negative & not b1 is conjunctive & not b1 is universal )
proof end;

theorem Th27: :: ZF_LANG:27
for b1 being ZF-formula holds
( b1 is atomic implies len b1 = 3 )
proof end;

theorem Th28: :: ZF_LANG:28
for b1 being ZF-formula holds
not ( not b1 is atomic & ( for b2 being ZF-formula holds
not (len b2) + 1 <= len b1 ) )
proof end;

theorem Th29: :: ZF_LANG:29
for b1 being ZF-formula holds 3 <= len b1
proof end;

theorem Th30: :: ZF_LANG:30
for b1 being ZF-formula holds
( len b1 = 3 implies b1 is atomic )
proof end;

theorem Th31: :: ZF_LANG:31
for b1, b2 being Variable holds
( (b1 '=' b2) . 1 = 0 & (b1 'in' b2) . 1 = 1 )
proof end;

theorem Th32: :: ZF_LANG:32
for b1 being ZF-formula holds ('not' b1) . 1 = 2 by FINSEQ_1:58;

theorem Th33: :: ZF_LANG:33
for b1, b2 being ZF-formula holds (b1 '&' b2) . 1 = 3
proof end;

theorem Th34: :: ZF_LANG:34
for b1 being Variable
for b2 being ZF-formula holds (All b1,b2) . 1 = 4
proof end;

theorem Th35: :: ZF_LANG:35
for b1 being ZF-formula holds
( b1 is_equality implies b1 . 1 = 0 )
proof end;

theorem Th36: :: ZF_LANG:36
for b1 being ZF-formula holds
( b1 is_membership implies b1 . 1 = 1 )
proof end;

theorem Th37: :: ZF_LANG:37
for b1 being ZF-formula holds
( b1 is negative implies b1 . 1 = 2 )
proof end;

theorem Th38: :: ZF_LANG:38
for b1 being ZF-formula holds
( b1 is conjunctive implies b1 . 1 = 3 )
proof end;

theorem Th39: :: ZF_LANG:39
for b1 being ZF-formula holds
( b1 is universal implies b1 . 1 = 4 )
proof end;

theorem Th40: :: ZF_LANG:40
for b1 being ZF-formula holds
not ( not ( b1 is_equality & b1 . 1 = 0 ) & not ( b1 is_membership & b1 . 1 = 1 ) & not ( b1 is negative & b1 . 1 = 2 ) & not ( b1 is conjunctive & b1 . 1 = 3 ) & not ( b1 is universal & b1 . 1 = 4 ) )
proof end;

theorem Th41: :: ZF_LANG:41
for b1 being ZF-formula holds
( b1 . 1 = 0 implies b1 is_equality ) by Th40;

theorem Th42: :: ZF_LANG:42
for b1 being ZF-formula holds
( b1 . 1 = 1 implies b1 is_membership ) by Th40;

theorem Th43: :: ZF_LANG:43
for b1 being ZF-formula holds
( b1 . 1 = 2 implies b1 is negative ) by Th40;

theorem Th44: :: ZF_LANG:44
for b1 being ZF-formula holds
( b1 . 1 = 3 implies b1 is conjunctive ) by Th40;

theorem Th45: :: ZF_LANG:45
for b1 being ZF-formula holds
( b1 . 1 = 4 implies b1 is universal ) by Th40;

theorem Th46: :: ZF_LANG:46
for b1, b2 being ZF-formula
for b3 being FinSequence holds
( b1 = b2 ^ b3 implies b1 = b2 )
proof end;

theorem Th47: :: ZF_LANG:47
for b1, b2, b3, b4 being ZF-formula holds
( b1 '&' b2 = b3 '&' b4 implies ( b1 = b3 & b2 = b4 ) )
proof end;

theorem Th48: :: ZF_LANG:48
for b1, b2, b3, b4 being ZF-formula holds
( b1 'or' b2 = b3 'or' b4 implies ( b1 = b3 & b2 = b4 ) )
proof end;

theorem Th49: :: ZF_LANG:49
for b1, b2, b3, b4 being ZF-formula holds
( b1 => b2 = b3 => b4 implies ( b1 = b3 & b2 = b4 ) )
proof end;

theorem Th50: :: ZF_LANG:50
for b1, b2, b3, b4 being ZF-formula holds
( b1 <=> b2 = b3 <=> b4 implies ( b1 = b3 & b2 = b4 ) )
proof end;

theorem Th51: :: ZF_LANG:51
for b1, b2 being Variable
for b3, b4 being ZF-formula holds
( Ex b1,b3 = Ex b2,b4 implies ( b1 = b2 & b3 = b4 ) )
proof end;

definition
let c1 be ZF-formula;
assume E36: c1 is atomic ;
func Var1 c1 -> Variable equals :Def28: :: ZF_LANG:def 28
a1 . 2;
coherence
c1 . 2 is Variable
proof end;
func Var2 c1 -> Variable equals :Def29: :: ZF_LANG:def 29
a1 . 3;
coherence
c1 . 3 is Variable
proof end;
end;

:: deftheorem Def28 defines Var1 ZF_LANG:def 28 :
for b1 being ZF-formula holds
( b1 is atomic implies Var1 b1 = b1 . 2 );

:: deftheorem Def29 defines Var2 ZF_LANG:def 29 :
for b1 being ZF-formula holds
( b1 is atomic implies Var2 b1 = b1 . 3 );

theorem Th52: :: ZF_LANG:52
for b1 being ZF-formula holds
( b1 is atomic implies ( Var1 b1 = b1 . 2 & Var2 b1 = b1 . 3 ) ) by Def28, Def29;

theorem Th53: :: ZF_LANG:53
for b1 being ZF-formula holds
( b1 is_equality implies b1 = (Var1 b1) '=' (Var2 b1) )
proof end;

theorem Th54: :: ZF_LANG:54
for b1 being ZF-formula holds
( b1 is_membership implies b1 = (Var1 b1) 'in' (Var2 b1) )
proof end;

definition
let c1 be ZF-formula;
assume E40: c1 is negative ;
func the_argument_of c1 -> ZF-formula means :Def30: :: ZF_LANG:def 30
'not' a2 = a1;
existence
ex b1 being ZF-formula st 'not' b1 = c1
by E40, Def12;
uniqueness
for b1, b2 being ZF-formula holds
( 'not' b1 = c1 & 'not' b2 = c1 implies b1 = b2 )
by Th10;
end;

:: deftheorem Def30 defines the_argument_of ZF_LANG:def 30 :
for b1 being ZF-formula holds
( b1 is negative implies for b2 being ZF-formula holds
( b2 = the_argument_of b1 iff 'not' b2 = b1 ) );

definition
let c1 be ZF-formula;
assume E41: ( c1 is conjunctive or c1 is disjunctive ) ;
func the_left_argument_of c1 -> ZF-formula means :Def31: :: ZF_LANG:def 31
ex b1 being ZF-formula st a2 '&' b1 = a1 if a1 is conjunctive
otherwise ex b1 being ZF-formula st a2 'or' b1 = a1;
existence
( not ( c1 is conjunctive & ( for b1, b2 being ZF-formula holds
not b1 '&' b2 = c1 ) ) & not ( not c1 is conjunctive & ( for b1, b2 being ZF-formula holds
not b1 'or' b2 = c1 ) ) )
by E41, Def13, Def20;
uniqueness
for b1, b2 being ZF-formula holds
( ( c1 is conjunctive & ex b3 being ZF-formula st b1 '&' b3 = c1 & ex b3 being ZF-formula st b2 '&' b3 = c1 implies b1 = b2 ) & ( not c1 is conjunctive & ex b3 being ZF-formula st b1 'or' b3 = c1 & ex b3 being ZF-formula st b2 'or' b3 = c1 implies b1 = b2 ) )
by Th47, Th48;
consistency
for b1 being ZF-formula holds
verum
;
func the_right_argument_of c1 -> ZF-formula means :Def32: :: ZF_LANG:def 32
ex b1 being ZF-formula st b1 '&' a2 = a1 if a1 is conjunctive
otherwise ex b1 being ZF-formula st b1 'or' a2 = a1;
existence
( not ( c1 is conjunctive & ( for b1, b2 being ZF-formula holds
not b2 '&' b1 = c1 ) ) & not ( not c1 is conjunctive & ( for b1, b2 being ZF-formula holds
not b2 'or' b1 = c1 ) ) )
proof end;
uniqueness
for b1, b2 being ZF-formula holds
( ( c1 is conjunctive & ex b3 being ZF-formula st b3 '&' b1 = c1 & ex b3 being ZF-formula st b3 '&' b2 = c1 implies b1 = b2 ) & ( not c1 is conjunctive & ex b3 being ZF-formula st b3 'or' b1 = c1 & ex b3 being ZF-formula st b3 'or' b2 = c1 implies b1 = b2 ) )
by Th47, Th48;
consistency
for b1 being ZF-formula holds
verum
;
end;

:: deftheorem Def31 defines the_left_argument_of ZF_LANG:def 31 :
for b1 being ZF-formula holds
( ( b1 is conjunctive or b1 is disjunctive ) implies for b2 being ZF-formula holds
( ( b1 is conjunctive implies ( b2 = the_left_argument_of b1 iff ex b3 being ZF-formula st b2 '&' b3 = b1 ) ) & ( not b1 is conjunctive implies ( b2 = the_left_argument_of b1 iff ex b3 being ZF-formula st b2 'or' b3 = b1 ) ) ) );

:: deftheorem Def32 defines the_right_argument_of ZF_LANG:def 32 :
for b1 being ZF-formula holds
( ( b1 is conjunctive or b1 is disjunctive ) implies for b2 being ZF-formula holds
( ( b1 is conjunctive implies ( b2 = the_right_argument_of b1 iff ex b3 being ZF-formula st b3 '&' b2 = b1 ) ) & ( not b1 is conjunctive implies ( b2 = the_right_argument_of b1 iff ex b3 being ZF-formula st b3 'or' b2 = b1 ) ) ) );

theorem Th55: :: ZF_LANG:55
canceled;

theorem Th56: :: ZF_LANG:56
for b1, b2 being ZF-formula holds
( b1 is conjunctive implies ( not ( b2 = the_left_argument_of b1 & ( for b3 being ZF-formula holds
not b2 '&' b3 = b1 ) ) & ( ex b3 being ZF-formula st b2 '&' b3 = b1 implies b2 = the_left_argument_of b1 ) & not ( b2 = the_right_argument_of b1 & ( for b3 being ZF-formula holds
not b3 '&' b2 = b1 ) ) & ( ex b3 being ZF-formula st b3 '&' b2 = b1 implies b2 = the_right_argument_of b1 ) ) ) by Def31, Def32;

theorem Th57: :: ZF_LANG:57
for b1, b2 being ZF-formula holds
( b1 is disjunctive implies ( not ( b2 = the_left_argument_of b1 & ( for b3 being ZF-formula holds
not b2 'or' b3 = b1 ) ) & ( ex b3 being ZF-formula st b2 'or' b3 = b1 implies b2 = the_left_argument_of b1 ) & not ( b2 = the_right_argument_of b1 & ( for b3 being ZF-formula holds
not b3 'or' b2 = b1 ) ) & ( ex b3 being ZF-formula st b3 'or' b2 = b1 implies b2 = the_right_argument_of b1 ) ) )
proof end;

theorem Th58: :: ZF_LANG:58
for b1 being ZF-formula holds
( b1 is conjunctive implies b1 = (the_left_argument_of b1) '&' (the_right_argument_of b1) )
proof end;

theorem Th59: :: ZF_LANG:59
for b1 being ZF-formula holds
( b1 is disjunctive implies b1 = (the_left_argument_of b1) 'or' (the_right_argument_of b1) )
proof end;

definition
let c1 be ZF-formula;
assume E45: ( c1 is universal or c1 is existential ) ;
func bound_in c1 -> Variable means :Def33: :: ZF_LANG:def 33
ex b1 being ZF-formula st All a2,b1 = a1 if a1 is universal
otherwise ex b1 being ZF-formula st Ex a2,b1 = a1;
existence
( not ( c1 is universal & ( for b1 being Variable
for b2 being ZF-formula holds
not All b1,b2 = c1 ) ) & not ( not c1 is universal & ( for b1 being Variable
for b2 being ZF-formula holds
not Ex b1,b2 = c1 ) ) )
by E45, Def14, Def23;
uniqueness
for b1, b2 being Variable holds
( ( c1 is universal & ex b3 being ZF-formula st All b1,b3 = c1 & ex b3 being ZF-formula st All b2,b3 = c1 implies b1 = b2 ) & ( not c1 is universal & ex b3 being ZF-formula st Ex b1,b3 = c1 & ex b3 being ZF-formula st Ex b2,b3 = c1 implies b1 = b2 ) )
by Th12, Th51;
consistency
for b1 being Variable holds
verum
;
func the_scope_of c1 -> ZF-formula means :Def34: :: ZF_LANG:def 34
ex b1 being Variable st All b1,a2 = a1 if a1 is universal
otherwise ex b1 being Variable st Ex b1,a2 = a1;
existence
( not ( c1 is universal & ( for b1 being ZF-formula
for b2 being Variable holds
not All b2,b1 = c1 ) ) & not ( not c1 is universal & ( for b1 being ZF-formula
for b2 being Variable holds
not Ex b2,b1 = c1 ) ) )
proof end;
uniqueness
for b1, b2 being ZF-formula holds
( ( c1 is universal & ex b3 being Variable st All b3,b1 = c1 & ex b3 being Variable st All b3,b2 = c1 implies b1 = b2 ) & ( not c1 is universal & ex b3 being Variable st Ex b3,b1 = c1 & ex b3 being Variable st Ex b3,b2 = c1 implies b1 = b2 ) )
by Th12, Th51;
consistency
for b1 being ZF-formula holds
verum
;
end;

:: deftheorem Def33 defines bound_in ZF_LANG:def 33 :
for b1 being ZF-formula holds
( ( b1 is universal or b1 is existential ) implies for b2 being Variable holds
( ( b1 is universal implies ( b2 = bound_in b1 iff ex b3 being ZF-formula st All b2,b3 = b1 ) ) & ( not b1 is universal implies ( b2 = bound_in b1 iff ex b3 being ZF-formula st Ex b2,b3 = b1 ) ) ) );

:: deftheorem Def34 defines the_scope_of ZF_LANG:def 34 :
for b1 being ZF-formula holds
( ( b1 is universal or b1 is existential ) implies for b2 being ZF-formula holds
( ( b1 is universal implies ( b2 = the_scope_of b1 iff ex b3 being Variable st All b3,b2 = b1 ) ) & ( not b1 is universal implies ( b2 = the_scope_of b1 iff ex b3 being Variable st Ex b3,b2 = b1 ) ) ) );

theorem Th60: :: ZF_LANG:60
for b1 being Variable
for b2, b3 being ZF-formula holds
( b2 is universal implies ( not ( b1 = bound_in b2 & ( for b4 being ZF-formula holds
not All b1,b4 = b2 ) ) & ( ex b4 being ZF-formula st All b1,b4 = b2 implies b1 = bound_in b2 ) & not ( b3 = the_scope_of b2 & ( for b4 being Variable holds
not All b4,b3 = b2 ) ) & ( ex b4 being Variable st All b4,b3 = b2 implies b3 = the_scope_of b2 ) ) ) by Def33, Def34;

theorem Th61: :: ZF_LANG:61
for b1 being Variable
for b2, b3 being ZF-formula holds
( b2 is existential implies ( not ( b1 = bound_in b2 & ( for b4 being ZF-formula holds
not Ex b1,b4 = b2 ) ) & ( ex b4 being ZF-formula st Ex b1,b4 = b2 implies b1 = bound_in b2 ) & not ( b3 = the_scope_of b2 & ( for b4 being Variable holds
not Ex b4,b3 = b2 ) ) & ( ex b4 being Variable st Ex b4,b3 = b2 implies b3 = the_scope_of b2 ) ) )
proof end;

theorem Th62: :: ZF_LANG:62
for b1 being ZF-formula holds
( b1 is universal implies b1 = All (bound_in b1),(the_scope_of b1) )
proof end;

theorem Th63: :: ZF_LANG:63
for b1 being ZF-formula holds
( b1 is existential implies b1 = Ex (bound_in b1),(the_scope_of b1) )
proof end;

definition
let c1 be ZF-formula;
assume E49: c1 is conditional ;
func the_antecedent_of c1 -> ZF-formula means :Def35: :: ZF_LANG:def 35
ex b1 being ZF-formula st a1 = a2 => b1;
existence
ex b1, b2 being ZF-formula st c1 = b1 => b2
by E49, Def21;
uniqueness
for b1, b2 being ZF-formula holds
( ex b3 being ZF-formula st c1 = b1 => b3 & ex b3 being ZF-formula st c1 = b2 => b3 implies b1 = b2 )
by Th49;
func the_consequent_of c1 -> ZF-formula means :Def36: :: ZF_LANG:def 36
ex b1 being ZF-formula st a1 = b1 => a2;
existence
ex b1, b2 being ZF-formula st c1 = b2 => b1
proof end;
uniqueness
for b1, b2 being ZF-formula holds
( ex b3 being ZF-formula st c1 = b3 => b1 & ex b3 being ZF-formula st c1 = b3 => b2 implies b1 = b2 )
by Th49;
end;

:: deftheorem Def35 defines the_antecedent_of ZF_LANG:def 35 :
for b1 being ZF-formula holds
( b1 is conditional implies for b2 being ZF-formula holds
( b2 = the_antecedent_of b1 iff ex b3 being ZF-formula st b1 = b2 => b3 ) );

:: deftheorem Def36 defines the_consequent_of ZF_LANG:def 36 :
for b1 being ZF-formula holds
( b1 is conditional implies for b2 being ZF-formula holds
( b2 = the_consequent_of b1 iff ex b3 being ZF-formula st b1 = b3 => b2 ) );

theorem Th64: :: ZF_LANG:64
for b1, b2 being ZF-formula holds
( b1 is conditional implies ( not ( b2 = the_antecedent_of b1 & ( for b3 being ZF-formula holds
not b1 = b2 => b3 ) ) & ( ex b3 being ZF-formula st b1 = b2 => b3 implies b2 = the_antecedent_of b1 ) & not ( b2 = the_consequent_of b1 & ( for b3 being ZF-formula holds
not b1 = b3 => b2 ) ) & ( ex b3 being ZF-formula st b1 = b3 => b2 implies b2 = the_consequent_of b1 ) ) ) by Def35, Def36;

theorem Th65: :: ZF_LANG:65
for b1 being ZF-formula holds
( b1 is conditional implies b1 = (the_antecedent_of b1) => (the_consequent_of b1) )
proof end;

definition
let c1 be ZF-formula;
assume E51: c1 is biconditional ;
func the_left_side_of c1 -> ZF-formula means :Def37: :: ZF_LANG:def 37
ex b1 being ZF-formula st a1 = a2 <=> b1;
existence
ex b1, b2 being ZF-formula st c1 = b1 <=> b2
by E51, Def22;
uniqueness
for b1, b2 being ZF-formula holds
( ex b3 being ZF-formula st c1 = b1 <=> b3 & ex b3 being ZF-formula st c1 = b2 <=> b3 implies b1 = b2 )
by Th50;
func the_right_side_of c1 -> ZF-formula means :Def38: :: ZF_LANG:def 38
ex b1 being ZF-formula st a1 = b1 <=> a2;
existence
ex b1, b2 being ZF-formula st c1 = b2 <=> b1
proof end;
uniqueness
for b1, b2 being ZF-formula holds
( ex b3 being ZF-formula st c1 = b3 <=> b1 & ex b3 being ZF-formula st c1 = b3 <=> b2 implies b1 = b2 )
by Th50;
end;

:: deftheorem Def37 defines the_left_side_of ZF_LANG:def 37 :
for b1 being ZF-formula holds
( b1 is biconditional implies for b2 being ZF-formula holds
( b2 = the_left_side_of b1 iff ex b3 being ZF-formula st b1 = b2 <=> b3 ) );

:: deftheorem Def38 defines the_right_side_of ZF_LANG:def 38 :
for b1 being ZF-formula holds
( b1 is biconditional implies for b2 being ZF-formula holds
( b2 = the_right_side_of b1 iff ex b3 being ZF-formula st b1 = b3 <=> b2 ) );

theorem Th66: :: ZF_LANG:66
for b1, b2 being ZF-formula holds
( b1 is biconditional implies ( not ( b2 = the_left_side_of b1 & ( for b3 being ZF-formula holds
not b1 = b2 <=> b3 ) ) & ( ex b3 being ZF-formula st b1 = b2 <=> b3 implies b2 = the_left_side_of b1 ) & not ( b2 = the_right_side_of b1 & ( for b3 being ZF-formula holds
not b1 = b3 <=> b2 ) ) & ( ex b3 being ZF-formula st b1 = b3 <=> b2 implies b2 = the_right_side_of b1 ) ) ) by Def37, Def38;

theorem Th67: :: ZF_LANG:67
for b1 being ZF-formula holds
( b1 is biconditional implies b1 = (the_left_side_of b1) <=> (the_right_side_of b1) )
proof end;

definition
let c1, c2 be ZF-formula;
pred c1 is_immediate_constituent_of c2 means :Def39: :: ZF_LANG:def 39
not ( not a2 = 'not' a1 & ( for b1 being ZF-formula holds
( not a2 = a1 '&' b1 & not a2 = b1 '&' a1 ) ) & ( for b1 being Variable holds
not a2 = All b1,a1 ) );
end;

:: deftheorem Def39 defines is_immediate_constituent_of ZF_LANG:def 39 :
for b1, b2 being ZF-formula holds
( b1 is_immediate_constituent_of b2 iff not ( not b2 = 'not' b1 & ( for b3 being ZF-formula holds
( not b2 = b1 '&' b3 & not b2 = b3 '&' b1 ) ) & ( for b3 being Variable holds
not b2 = All b3,b1 ) ) );

theorem Th68: :: ZF_LANG:68
canceled;

theorem Th69: :: ZF_LANG:69
for b1, b2 being Variable
for b3 being ZF-formula holds
not b3 is_immediate_constituent_of b1 '=' b2
proof end;

theorem Th70: :: ZF_LANG:70
for b1, b2 being Variable
for b3 being ZF-formula holds
not b3 is_immediate_constituent_of b1 'in' b2
proof end;

theorem Th71: :: ZF_LANG:71
for b1, b2 being ZF-formula holds
( b1 is_immediate_constituent_of 'not' b2 iff b1 = b2 )
proof end;

theorem Th72: :: ZF_LANG:72
for b1, b2, b3 being ZF-formula holds
( b1 is_immediate_constituent_of b2 '&' b3 iff ( b1 = b2 or b1 = b3 ) )
proof end;

theorem Th73: :: ZF_LANG:73
for b1 being Variable
for b2, b3 being ZF-formula holds
( b2 is_immediate_constituent_of All b1,b3 iff b2 = b3 )
proof end;

theorem Th74: :: ZF_LANG:74
for b1, b2 being ZF-formula holds
not ( b1 is atomic & b2 is_immediate_constituent_of b1 )
proof end;

theorem Th75: :: ZF_LANG:75
for b1, b2 being ZF-formula holds
( b1 is negative implies ( b2 is_immediate_constituent_of b1 iff b2 = the_argument_of b1 ) )
proof end;

theorem Th76: :: ZF_LANG:76
for b1, b2 being ZF-formula holds
( b1 is conjunctive implies ( b2 is_immediate_constituent_of b1 iff ( b2 = the_left_argument_of b1 or b2 = the_right_argument_of b1 ) ) )
proof end;

theorem Th77: :: ZF_LANG:77
for b1, b2 being ZF-formula holds
( b1 is universal implies ( b2 is_immediate_constituent_of b1 iff b2 = the_scope_of b1 ) )
proof end;

definition
let c1, c2 be ZF-formula;
pred c1 is_subformula_of c2 means :Def40: :: ZF_LANG:def 40
ex b1 being Natex b2 being FinSequence st
( 1 <= b1 & len b2 = b1 & b2 . 1 = a1 & b2 . b1 = a2 & ( for b3 being Nat holds
not ( 1 <= b3 & b3 < b1 & ( for b4, b5 being ZF-formula holds
not ( b2 . b3 = b4 & b2 . (b3 + 1) = b5 & b4 is_immediate_constituent_of b5 ) ) ) ) );
end;

:: deftheorem Def40 defines is_subformula_of ZF_LANG:def 40 :
for b1, b2 being ZF-formula holds
( b1 is_subformula_of b2 iff ex b3 being Natex b4 being FinSequence st
( 1 <= b3 & len b4 = b3 & b4 . 1 = b1 & b4 . b3 = b2 & ( for b5 being Nat holds
not ( 1 <= b5 & b5 < b3 & ( for b6, b7 being ZF-formula holds
not ( b4 . b5 = b6 & b4 . (b5 + 1) = b7 & b6 is_immediate_constituent_of b7 ) ) ) ) ) );

theorem Th78: :: ZF_LANG:78
canceled;

theorem Th79: :: ZF_LANG:79
for b1 being ZF-formula holds b1 is_subformula_of b1
proof end;

definition
let c1, c2 be ZF-formula;
pred c1 is_proper_subformula_of c2 means :Def41: :: ZF_LANG:def 41
( a1 is_subformula_of a2 & a1 <> a2 );
end;

:: deftheorem Def41 defines is_proper_subformula_of ZF_LANG:def 41 :
for b1, b2 being ZF-formula holds
( b1 is_proper_subformula_of b2 iff ( b1 is_subformula_of b2 & b1 <> b2 ) );

theorem Th80: :: ZF_LANG:80
canceled;

theorem Th81: :: ZF_LANG:81
for b1, b2 being ZF-formula holds
not ( b1 is_immediate_constituent_of b2 & not len b1 < len b2 )
proof end;

theorem Th82: :: ZF_LANG:82
for b1, b2 being ZF-formula holds
( b1 is_immediate_constituent_of b2 implies b1 is_proper_subformula_of b2 )
proof end;

theorem Th83: :: ZF_LANG:83
for b1, b2 being ZF-formula holds
not ( b1 is_proper_subformula_of b2 & not len b1 < len b2 )
proof end;

theorem Th84: :: ZF_LANG:84
for b1, b2 being ZF-formula holds
not ( b1 is_proper_subformula_of b2 & ( for b3 being ZF-formula holds
not b3 is_immediate_constituent_of b2 ) )
proof end;

theorem Th85: :: ZF_LANG:85
for b1, b2, b3 being ZF-formula holds
( b1 is_proper_subformula_of b2 & b2 is_proper_subformula_of b3 implies b1 is_proper_subformula_of b3 )
proof end;

theorem Th86: :: ZF_LANG:86
for b1, b2, b3 being ZF-formula holds
( b1 is_subformula_of b2 & b2 is_subformula_of b3 implies b1 is_subformula_of b3 )
proof end;

theorem Th87: :: ZF_LANG:87
for b1, b2 being ZF-formula holds
( b1 is_subformula_of b2 & b2 is_subformula_of b1 implies b1 = b2 )
proof end;

theorem Th88: :: ZF_LANG:88
for b1, b2 being Variable
for b3 being ZF-formula holds
not b3 is_proper_subformula_of b1 '=' b2
proof end;

theorem Th89: :: ZF_LANG:89
for b1, b2 being Variable
for b3 being ZF-formula holds
not b3 is_proper_subformula_of b1 'in' b2
proof end;

theorem Th90: :: ZF_LANG:90
for b1, b2 being ZF-formula holds
( b1 is_proper_subformula_of 'not' b2 implies b1 is_subformula_of b2 )
proof end;

theorem Th91: :: ZF_LANG:91
for b1, b2, b3 being ZF-formula holds
not ( b1 is_proper_subformula_of b2 '&' b3 & not b1 is_subformula_of b2 & not b1 is_subformula_of b3 )
proof end;

theorem Th92: :: ZF_LANG:92
for b1 being Variable
for b2, b3 being ZF-formula holds
( b2 is_proper_subformula_of All b1,b3 implies b2 is_subformula_of b3 )
proof end;

theorem Th93: :: ZF_LANG:93
for b1, b2 being ZF-formula holds
not ( b1 is atomic & b2 is_proper_subformula_of b1 )
proof end;

theorem Th94: :: ZF_LANG:94
for b1 being ZF-formula holds
( b1 is negative implies the_argument_of b1 is_proper_subformula_of b1 )
proof end;

theorem Th95: :: ZF_LANG:95
for b1 being ZF-formula holds
( b1 is conjunctive implies ( the_left_argument_of b1 is_proper_subformula_of b1 & the_right_argument_of b1 is_proper_subformula_of b1 ) )
proof end;

theorem Th96: :: ZF_LANG:96
for b1 being ZF-formula holds
( b1 is universal implies the_scope_of b1 is_proper_subformula_of b1 )
proof end;

theorem Th97: :: ZF_LANG:97
for b1, b2 being Variable
for b3 being ZF-formula holds
( b3 is_subformula_of b1 '=' b2 iff b3 = b1 '=' b2 )
proof end;

theorem Th98: :: ZF_LANG:98
for b1, b2 being Variable
for b3 being ZF-formula holds
( b3 is_subformula_of b1 'in' b2 iff b3 = b1 'in' b2 )
proof end;

definition
let c1 be ZF-formula;
func Subformulae c1 -> set means :Def42: :: ZF_LANG:def 42
for b1 being set holds
( b1 in a2 iff ex b2 being ZF-formula st
( b2 = b1 & b2 is_subformula_of a1 ) );
existence
ex b1 being set st
for b2 being set holds
( b2 in b1 iff ex b3 being ZF-formula st
( b3 = b2 & b3 is_subformula_of c1 ) )
proof end;
uniqueness
for b1, b2 being set holds
( ( for b3 being set holds
( b3 in b1 iff ex b4 being ZF-formula st
( b4 = b3 & b4 is_subformula_of c1 ) ) ) & ( for b3 being set holds
( b3 in b2 iff ex b4 being ZF-formula st
( b4 = b3 & b4 is_subformula_of c1 ) ) ) implies b1 = b2 )
proof end;
end;

:: deftheorem Def42 defines Subformulae ZF_LANG:def 42 :
for b1 being ZF-formula
for b2 being set holds
( b2 = Subformulae b1 iff for b3 being set holds
( b3 in b2 iff ex b4 being ZF-formula st
( b4 = b3 & b4 is_subformula_of b1 ) ) );

theorem Th99: :: ZF_LANG:99
canceled;

theorem Th100: :: ZF_LANG:100
for b1, b2 being ZF-formula holds
( b1 in Subformulae b2 implies b1 is_subformula_of b2 )
proof end;

theorem Th101: :: ZF_LANG:101
for b1, b2 being ZF-formula holds
( b1 is_subformula_of b2 implies Subformulae b1 c= Subformulae b2 )
proof end;

theorem Th102: :: ZF_LANG:102
for b1, b2 being Variable holds Subformulae (b1 '=' b2) = {(b1 '=' b2)}
proof end;

theorem Th103: :: ZF_LANG:103
for b1, b2 being Variable holds Subformulae (b1 'in' b2) = {(b1 'in' b2)}
proof end;

theorem Th104: :: ZF_LANG:104
for b1 being ZF-formula holds Subformulae ('not' b1) = (Subformulae b1) \/ {('not' b1)}
proof end;

theorem Th105: :: ZF_LANG:105
for b1, b2 being ZF-formula holds Subformulae (b1 '&' b2) = ((Subformulae b1) \/ (Subformulae b2)) \/ {(b1 '&' b2)}
proof end;

theorem Th106: :: ZF_LANG:106
for b1 being Variable
for b2 being ZF-formula holds Subformulae (All b1,b2) = (Subformulae b2) \/ {(All b1,b2)}
proof end;

theorem Th107: :: ZF_LANG:107
for b1 being ZF-formula holds
( b1 is atomic iff Subformulae b1 = {b1} )
proof end;

theorem Th108: :: ZF_LANG:108
for b1 being ZF-formula holds
( b1 is negative implies Subformulae b1 = (Subformulae (the_argument_of b1)) \/ {b1} )
proof end;

theorem Th109: :: ZF_LANG:109
for b1 being ZF-formula holds
( b1 is conjunctive implies Subformulae b1 = ((Subformulae (the_left_argument_of b1)) \/ (Subformulae (the_right_argument_of b1))) \/ {b1} )
proof end;

theorem Th110: :: ZF_LANG:110
for b1 being ZF-formula holds
( b1 is universal implies Subformulae b1 = (Subformulae (the_scope_of b1)) \/ {b1} )
proof end;

theorem Th111: :: ZF_LANG:111
for b1, b2, b3 being ZF-formula holds
( not ( not b1 is_immediate_constituent_of b2 & not b1 is_proper_subformula_of b2 & not b1 is_subformula_of b2 ) & b2 in Subformulae b3 implies b1 in Subformulae b3 )
proof end;

scheme :: ZF_LANG:sch 1
s1{ P1[ ZF-formula] } :
for b1 being ZF-formula holds P1[b1]
provided
E85: for b1 being ZF-formula holds
( b1 is atomic implies P1[b1] ) and E86: for b1 being ZF-formula holds
( b1 is negative & P1[ the_argument_of b1] implies P1[b1] ) and E87: for b1 being ZF-formula holds
( b1 is conjunctive & P1[ the_left_argument_of b1] & P1[ the_right_argument_of b1] implies P1[b1] ) and E88: for b1 being ZF-formula holds
( b1 is universal & P1[ the_scope_of b1] implies P1[b1] )
proof end;

scheme :: ZF_LANG:sch 2
s2{ P1[ ZF-formula] } :
for b1 being ZF-formula holds P1[b1]
provided
E85: for b1 being ZF-formula holds
( ( for b2 being ZF-formula holds
( b2 is_proper_subformula_of b1 implies P1[b2] ) ) implies P1[b1] )
proof end;